blob: b4a65cada289912651bffb177edd7f3e4fab5c8e [file] [log] [blame]
sort_array(E)
FUNKTION:
mixed *sort_array(mixed *arr, mixed func [, mixed ob])
PARAMETER:
arr - zu sortierendes Array
func - zu rufende Methode; kann als String (Funktionsname) oder
Closure uebergeben werden
ob - Objekt, an dem Methode gerufen werden soll; kann als String
(Filename) oder Objektpointer uebergeben werden
BESCHREIBUNG
Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der
Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben.
Die Elemente des zu sortierenden Arrays werden paarweise an die
Sortierfunktion als Argumente uebergeben.
Die Sortierfunktion sollte eine Zahl
- >0 zurueckgeben, wenn die Elemente in der falschen
Reihenfolge sind
- <=0 zurueckgeben, wenn die Elemente in der richtigen
Reihenfolge sind.
Verwendung von Methoden:
Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings
oder Objekts angegeben wird, wird this_object() angenommen.
Verwendung von Closures:
Es koennen Lfun-, Lambda- und Inline-Closures verwendet werden.
Lfun-Closures koennen, wenn im selben Objekt vorhanden, auch
'private' oder/und 'static' deklariert sein, muessen aber zu dem
Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
Von der Verwendung von Lambda-Closures wird ausdruecklich abgeraten.
BEMERKUNGEN:
(1) sort_array() unterstuetzt keinen extra-Parameter
(2) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
also selbst Arrays oder Mappings, so fuehrt eine Aenderung im Rueckgabe-
Array zur Aenderung im Ursprungsarray:
int *i, *j;
i=({({1}),({2,3}),({4,5,6})});
j=sort_array(i, // sortiert der Groesse nach absteigend
function int ( mixed x, mixed y ) {
return sizeof(x) < sizeof(y); }
);
Zu diesem Zeitpunkt ist i == ({ ({1}),({2,3}),({4,5,6}) })
j == ({ ({4,5,6}),({2,3}),({1}) })
Fuehrt man jetzt die Zuweisung j[0][0]=8; aus
resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) })
j == ({ ({8,5,6}),({2,3}),({1}) })
BEISPIELE:
### Sortieren von Zahlen in aufsteigender Reihenfolge ###
int *arr = ({ 3, 8, 1, 3 })
// Folgend identische Resultate, aber andere Ansaetze:
#1: nutzt die 'Efun' > als Lfun-Closure (ideal hier):
sort_array(arr, #'>);
#2: mit Sortierfunktion im selben Objekt:
int is_greater (int a, int b) {
return a > b;
}
#2a: sortiert mittels der Lfun im selben Objekt die Elemente in das
Rueckgabearray
sort_array(arr, "is_greater", this_object())
sort_array(arr, "is_greater")
#2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer)
sort_array(arr, #'is_greater)
#3: nutzt eine Lambda-Closure (langsamer, nicht fuer alle leserlich)
sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b})))
#4: analog zu 3, mit Inline-Closure
sort_array(arr, function int (int a, int b) {
return a > b; } );
Resultat in allen Faellen: ({1,3,3,8})
### Sortieren von geschachtelten Arrays ###
arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })
// Vorgehen identisch, allerdings muss die Sortierfunktion
// angepasst werden (siehe auch das Beispiel unter Verwendung von
// Inline-Closures oben unter "Bemerkungen"):
int is_greater (mixed *a, mixed *b) {
return a[1] > b[1];
}
SIEHE AUCH:
Arrays: filter(E), map(E)
Objektarrays: filter_objects(E), map_objects(E)
Mappings: filter_indices(E), map_indices(E)
Sonstiges: unique_array()
alist, transpose_array(E)
----------------------------------------------------------------------------
Last modified: Mon Feb 18 23:09 2008 by Arathorn