| Pacchetto | mx.collections |
| Classe | public class Sort |
| Ereditarietà | Sort  EventDispatcher Object |
| Implementa | ISort |
| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
 | A partire da Flex 4.5, Adobe consiglia di utilizzare la classe spark.collections.Sort come alternativa a questa classe. |
Provides the sorting information required to establish a sort on an existing view (ICollectionView interface or class that implements the interface). After you assign a Sort instance to the view's
sort property, you must call the view's
refresh() method to apply the sort criteria.
Typically the sort is defined for collections of complex items, that is
collections in which the sort is performed on one or more properties of
the objects in the collection.
The following example shows this use:
var col:ICollectionView = new ArrayCollection();
// In the real world, the collection would have more than one item.
col.addItem({first:"Anders", last:"Dickerson"});
// Create the Sort instance.
var sort:Sort = new Sort();
// Set the sort field; sort on the last name first, first name second.
// Both fields are case-insensitive.
sort.fields = [new SortField("last",true), new SortField("first",true)];
// Assign the Sort object to the view.
col.sort = sort;
// Apply the sort to the collection.
col.refresh();
There are situations in which the collection contains simple items,
like String, Date, Boolean, etc.
In this case, apply the sort to the simple type directly.
When constructing a sort for simple items, use a single sort field,
and specify a null
name (first) parameter
in the SortField object constructor.
For example:
var col:ICollectionView = new ArrayCollection();
col.addItem("California");
col.addItem("Arizona");
var sort:Sort = new Sort();
// There is only one sort field, so use a null
// first parameter.
sort.fields = [new SortField(null, true)];
col.sort = sort;
col.refresh();
The Flex implementations of the ICollectionView interface retrieve all items from a remote location before executing a sort. If you use paging with a sorted list, apply the sort to the remote collection before you retrieve the data.
By default this Sort class does not provide correct language specific
sorting for strings. For this type of sorting please see the
spark.collections.Sort and
spark.collections.SortField classes.
Mostra sintassi MXML
Nascondi sintassi MXMLThe <mx:Sort> tag has the following attributes:
<mx:Sort Properties compareFunction="Internal compare function" fields="null" unique="false | true" />
In case items have inconsistent data types or items have complex data types, the use of the default built-in compare functions is not recommended. Inconsistent sorting results may occur in such cases. To avoid such problem, provide a custom compare function and/or make the item types consistent.
Just like any other AdvancedStyleClient-based classes,
the Sort and SortField classes do not have a
parent-child relationship in terms of event handling. Locale changes in a
Sort instance are not dispatched to its SortField
instances automatically. The only exceptional case is the internal default
SortField instance used when no explicit fields are provided.
In this case, the internal default SortField instance follows
the locale style that the owner Sort instance has.
Proprietà MXML predefinitafields
Elementi API correlati
| Proprietà | Definito da | ||
|---|---|---|---|
| compareFunction : Function
The method used to compare items when sorting. | Sort | ||
 | constructor : Object
Un riferimento all'oggetto classe o alla funzione di costruzione per una determinata istanza di oggetto. | Object | |
| fields : Array
An Array of ISortField objects that specifies the fields to compare. | Sort | ||
| unique : Boolean
Indicates if the sort should be unique. | Sort | ||
| Metodo | Definito da | ||
|---|---|---|---|
Sort()
Constructor. | Sort | ||
| addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
Registra un oggetto listener di eventi con un oggetto EventDispatcher, in modo che il listener riceva la notifica di un evento. | EventDispatcher | |
|
Invia un evento nel flusso di eventi. | EventDispatcher | |
findItem(items:Array, values:Object, mode:String, returnInsertionIndex:Boolean = false, compareFunction:Function = null):int
Finds the specified object within the specified array (or the insertion
point if asked for), returning the index if found or -1 if not. | Sort | ||
|
Verifica se per l'oggetto EventDispatcher sono presenti listener registrati per un tipo specifico di evento. | EventDispatcher | |
|
Indica se per un oggetto è definita una proprietà specifica. | Object | |
|
Indica se un'istanza della classe Object si trova nella catena di prototipi dell'oggetto specificato come parametro. | Object | |
Return whether the specified property is used to control the sort. | Sort | ||
|
Indica se la proprietà specificata esiste ed è enumerabile. | Object | |
|
Rimuove un listener dall'oggetto EventDispatcher. | EventDispatcher | |
Goes through the fields array and calls
reverse() on each of the ISortField objects in
the array. | Sort | ||
|
Imposta la disponibilità di una proprietà dinamica per le operazioni cicliche. | Object | |
Apply the current sort to the specified array (not a copy). | Sort | ||
|
Restituisce la rappresentazione in formato stringa di questo oggetto, formattato in base alle convenzioni specifiche per le versioni localizzate. | Object | |
|
Restituisce la rappresentazione in formato stringa dell'oggetto specificato. | Object | |
|
Restituisce il valore di base dell'oggetto specificato. | Object | |
|
Verifica se un listener di eventi è registrato con questo oggetto EventDispatcher o qualsiasi suo antenato per il tipo di evento specificato. | EventDispatcher | |
| Costante | Definito da | ||
|---|---|---|---|
| ANY_INDEX_MODE : String = "any" [statico]
When executing a find return the index any matching item. | Sort | ||
| FIRST_INDEX_MODE : String = "first" [statico]
When executing a find return the index for the first matching item. | Sort | ||
| LAST_INDEX_MODE : String = "last" [statico]
When executing a find return the index for the last matching item. | Sort | ||
compareFunction | proprietà |
compareFunction:Function| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
The method used to compare items when sorting.
If you specify this property, Flex ignores any
compareFunction properties that you specify in the
ISortField objects that you use in this class.
The compare function must have the following signature:
function [name](a:Object, b:Object, fields:Array = null):int
This function must return the following value:
- -1, if the
Object ashould appear before theObject bin the sorted sequence - 0, if the
Object aequals theObject b - 1, if the
Object ashould appear after theObject bin the sorted sequence
To return to the internal comparision function, set this value to
null.
The fields array specifies the object fields
to compare.
Typically the algorithm will compare properties until the field list is
exhausted or a non-zero value can be returned.
For example:
function myCompare(a:Object, b:Object, fields:Array = null):int
{
var result:int = 0;
var i:int = 0;
var propList:Array = fields ? fields : internalPropList;
var len:int = propList.length;
var propName:String;
while (result == 0 && (i < len))
{
propName = propList[i];
result = compareValues(a[propName], b[propName]);
i++;
}
return result;
}
function compareValues(a:Object, b:Object):int
{
if (a == null && b == null)
return 0;
if (a == null)
return 1;
if (b == null)
return -1;
if (a < b)
return -1;
if (a > b)
return 1;
return 0;
}
The default value is an internal compare function that can perform a string, numeric, or date comparison in ascending or descending order. Specify your own function only if you need a need a custom comparison algorithm. This is normally only the case if a calculated field is used in a display.
Alternatively you can specify separate compare functions for each
sort field by using the ISortField class
compareFunction property; This way you can use the default
comparison for some fields and a custom comparison for others.
Implementazione
public function get compareFunction():Function public function set compareFunction(value:Function):voidfields | proprietà |
fields:Array| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
An Array of ISortField objects that specifies the fields to compare.
The order of the ISortField objects in the array determines
field priority order when sorting.
The default sort comparator checks the sort fields in array
order until it determinines a sort order for the two
fields being compared.
Il valore predefinito è null.
Questa proprietà può essere utilizzata come origine per l’associazione di dati. Quando questa proprietà viene modificata, invia l’evento fieldsChanged .
Implementazione
public function get fields():Array public function set fields(value:Array):voidElementi API correlati
unique | proprietà |
unique:Boolean| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Indicates if the sort should be unique.
Unique sorts fail if any value or combined value specified by the
fields listed in the fields property result in an indeterminate or
non-unique sort order; that is, if two or more items have identical
sort field values. An error is thrown if the sort is not unique.
The sorting logic uses this unique property value only if sort
field(s) are specified explicitly. If no sort fields are specified
explicitly, no error is thrown even when there are identical value
elements.
Il valore predefinito è false.
Implementazione
public function get unique():Boolean public function set unique(value:Boolean):voidSort | () | Funzione di costruzione |
public function Sort()| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Constructor.
Creates a new Sort with no fields set and no custom comparator.
findItem | () | metodo |
public function findItem(items:Array, values:Object, mode:String, returnInsertionIndex:Boolean = false, compareFunction:Function = null):int| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Finds the specified object within the specified array (or the insertion
point if asked for), returning the index if found or -1 if not.
The ListCollectionView class findxxx()
methods use this method to find the requested item; as a general rule,
it is easier to use these functions, and not findItem()
to find data in ListCollectionView-based objects.
You call the findItem() method directly when writing a
class that supports sorting, such as a new ICollectionView
implementation.
The input items array need to be sorted before calling this function.
Otherwise this function will not be able to find the specified value
properly.
Parametri
items:Array — the Array within which to search.
| |||||||
values:Object — Object containing the properties to look for (or
the object to search for, itself).
The object must consist of field name/value pairs, where
the field names are names of fields specified by the
fields property, in the same order they
are used in that property.
You do not have to specify all of the fields from the
fields property, but you
cannot skip any in the order.
Therefore, if the fields
properity lists three fields, you can specify its first
and second fields in this parameter, but you cannot
specify only the first and third fields.
| |||||||
mode:String — String containing the type of find to perform.
Valid values are:
| |||||||
returnInsertionIndex:Boolean (default = false)values parameter,
and this parameter is true the
findItem()
method returns the insertion point for the values,
that is the point in the sorted order where you
should insert the item.
| |||||||
compareFunction:Function (default = null)null value,
findItem() function uses the
compare function determined by the ISort
instance's compareFunction property,
passing in the array of fields determined
by the values object and the current
SortFields.
If you provide a non-null value, findItem()
function uses it as the compare function.
The signature of the function passed as
compareFunction must be as follows:
function myCompareFunction(a:Object, b:Object):int.
Note that there is no third argument unlike the
compare function for ISort.compareFunction()
property.
|
int — int The index in the array of the found item.
If the returnInsertionIndex parameter is
false and the item is not found, returns -1.
If the returnInsertionIndex parameter is
true and the item is not found, returns
the index of the point in the sorted array where the
values would be inserted.
|
propertyAffectsSort | () | metodo |
public function propertyAffectsSort(property:String):Boolean| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Return whether the specified property is used to control the sort.
The function cannot determine a definitive answer if the sort uses a
custom comparator; it always returns true in this case.
Parametri
property:String — The name of the field that to test.
|
Boolean — Whether the property value might affect the sort outcome.
If the sort uses the default compareFunction, returns
true if the
property parameter specifies a sort field.
If the sort or any ISortField uses a custom comparator,
there's no way to know, so return true.
|
reverse | () | metodo |
public function reverse():void| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Goes through the fields array and calls
reverse() on each of the ISortField objects in
the array. If the field was descending now it is ascending,
and vice versa.
Note: an ICollectionView does not automatically
update when the objects in the fields array are modified;
call its refresh() method to update the view.
sort | () | metodo |
public function sort(items:Array):void| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
Apply the current sort to the specified array (not a copy).
To prevent the array from being modified, create a copy
use the copy in the items parameter.
Flex ICollectionView implementations call the
sort method automatically and ensure that the sort is
performed on a copy of the underlying data.
Parametri
items:Array — Array of items to sort.
|
ANY_INDEX_MODE | Costante |
public static const ANY_INDEX_MODE:String = "any"| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
When executing a find return the index any matching item.
FIRST_INDEX_MODE | Costante |
public static const FIRST_INDEX_MODE:String = "first"| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
When executing a find return the index for the first matching item.
LAST_INDEX_MODE | Costante |
public static const LAST_INDEX_MODE:String = "last"| Versione linguaggio: | ActionScript 3.0 |
| Versione prodotto: | Flex 3 |
| Versioni runtime: | Flash Player 9, AIR 1.1 |
When executing a find return the index for the last matching item.
Tue Jun 12 2018, 02:44 PM Z