Array-Manipulation
|
Funktion keys
liefert ein Array aus allen Schlüsseln eines Hashes.
Sie wird häufig verwendet, um in einer
Schleife auf alle Elemente des
Hash zuzugreifen, meist zusammen mit sort verwendet.
|
my(@ara,%ha);
%ha = ('r'=>123,'g'=>234,'b'=>210);
@ara = keys(%ha);
# @ara=('r','g','b');
@ara = sort keys(%ha);
# @ara=('b','g','r');
|
Funktion values
liefert ein Array aus allen Werten eines Hashes.
|
my(@ara,%ha);
%ha = ('r'=>123,'g'=>234,'b'=>210);
@ara = values(%ha);
# @ara=(123,234,210);
|
'Funktion' qw
ist eigentlich ein 'quote-like' Operator (quoted words), welcher einen String in
eine Liste von Worten zerlegt. Als Wort-Trennzeichen dient das Leerzeichen.
Der String wird ohne (!) quotes in () übergeben,
allfällig darin enthaltene quotes werden wie jedes andere Zeichen verwendet..
qw wird oft zur bequemen Übergabe von Strings an Listen
verwendet, z.B. zur Initialisierung von Arrays.
|
my(@ars) = qw(das ist,ein "Test");
# @ars=('das','ist,ein','\"Test\"');
|
Funktion splice
Diese Funktion ist sehr flexibel und verschiedene Array-Operationen ausführen.
Sie schneidet einen Teil aus einem Array und fügt an der gleichen Stelle ein
anderes Array ein. Alle modernen Programmiersprachen bieten diese Standard-Funktion.
Um Elemente aus einem Array @ara zu entfernen erhält
die splice-Funktion 3 Argumente (@ara, $offset, $len)
Aus dem Array @ara wird ab (inkl.)
Element $ara[$offset] die Anzahl
von $len Elementen entfernt.
Die entfernten (!) Elemente werden von der Funktion splice
zurückgegeben (hier an das Array @s ).
Zum Löschen von Elementen oder Slices kann auch
Funktion
delete verwendet werden (s.
Löschen von Arrays).
|
Entfernen von Elementen mit splice
my(@ara,@s);
@ara=('a'..'f');
# @ara=('a','b','c','d','e','f');
@s = splice(@ara,3,2);
# @s=('d','e');
# @ara=('a','b','c','f');
|
Um neue Elemente einzufügen erhält die Funktion 4
Argumente (@ara, $offset, 0, @arb)
In das Array @ara werden vor dem
Element $ara[$offset] alle Elemente von
Array @arb eingefügt.
Zum Einfügen von Elementen am Anfang oder Ende können auch die
Funktionen unshift
und push
verwendet werden (s. Datenspeicher).
|
Einfügen von Elementen mit splice
my(@ara,@arb,@s);
@ara=('a'..'f');
@arb=('x','y');
# @ara=('a','b','c','d','e','f');
@s = splice(@ara,3,0,@arb);
# @s=();
# @ara=('a','b','c','x','y','d','e','f');
|
Um Elemente sowohl einzufügen als auch zu entfernen erhält die
Funktion 4 Argumente (@ara, $offset, $len, @arb).
Aus dem Array @ara wird ab
Element $ara[$offset] die Anzahl
von $len Elementen entfernt.
An der gleichen Position werden alle Elemente von
Array @arb eingefügt.
Die entfernten Elemente werden von der
Funktion splice zurückgegeben
(hier an das Array @s).
|
Entfernen und Einfügen von Elementen mit splice
my(@ara,@arb,@s);
@ara=('a'..'f');
@arb=('x','y');
# @ara=('a','b','c','d','e','f');
@s = splice(@ara,3,2,@arb);
# @s=('d','e');
# @ara=('a','b','c','x','y','f');
|
Für negative Argumente gelten besondere Regeln:
Wenn $offset<0 wird die Position vom Ende des Arrays
gezählt.
Beispiel: $offset=-1 bezeichnet das letzte Element
(hier $ara[5]="f"),
$offset=-2 bezeichnet das vorletzte Element
(hier $ara[4]="e").
|
Entfernen von Elementen mit splice
my(@ara,@s);
@ara = ('a'..'f');
# @ara=('a','b','c','d','e','f');
@s = splice(@ara,-5,2);
# @s=('b','c');
# @ara=('a','d','e','f');
|
Funktion map
bietet eine elegante und effiziente Möglichkeit, um einfache Operationen
an allen Elementen eines Arrays oder Hashes auszuführen.
Der Programm-Block in {} enthält ein Mini-Programm,
welches auf alle Elemente angewendet wird. Der Wert jedes Elements wird in der
Variablen $_ übergeben, das Programm damit
ausgeführt, das Ergebnis in das Element des Ziel-Arrays übertragen.
Das 3. Beispiel erzeugt eine Zufallszahl für jedes Element,
d.h. $_ muss nicht unbedingt verwendet werden.
Vorsicht - $_ ist ein Alias
für das bearbeitete Element, d.h. eine Änderung von $_
bewirkt eine Änderung des 'Original'-Array-Elements !
Das letzte Beispiel zeigt, wie ein Hash aufgebaut werden kann. Das Mini-Programm
muss für jedes Hash-Element 2 Daten (Schlüssel, Wert) zurückgeben,
die mit Beistrich , getrennt werden.
Funktion map eignet sich ausgezeichnet für einfache
Arithmetik oder Text-Manipulation.
|
my(@ara,@arb,%ha);
@ara = (0..5);
@arb = map {$_ * 2} @ara;
# @arb=(0,2,4,6,8,10);
@arb = map {$_ * $_} @ara;
# @arb=(0,1,4,9,16,25);
@arb = map { int(rand(100)) } @ara;
# @arb=(38,59,73,3,31,53);
@arb = map {"x".$_} @ara;
# @arb=('x0','x1','x2','x3','x4','x5');
map {$_=1} @ara; # Vorsicht !
# @ara=(1,1,1,1,1,1);
@ara=(65..67);
%ha = map {chr($_),$_} @ara;
# %ha=('A'=>65,'B'=>66,'C'=>67);
|
Funktion grep
bietet die Möglichkeit, ein Filter aus einem
Regulären Ausdruck
auf alle Elemente eines Arrays anzuwenden.
Der Programm-Block in {} enthält einen Regulären
Ausdruck. Nur bei einem Treffer wird das Element ausgegeben.
Das zweite Beispiel zeigt die Umkehrung - Hier werden nur die
nicht zutreffenden Array-Elemente ausgegeben.
Das dritte Beispiel zeigt die gleichzeitige Anwendung einer Zeichen-Substitution
(vorangestelltes s): jedes erste vorkommende Zeichen e wird durch x ersetzt.
♦ Details zu
Regulären
Ausdrücken.
|
my(@ara,@arb);
@ara = qw(Das ist ein neuer Test);
@arb = grep {/s/} @ara;
# @arb=('Das','ist','Test');
@arb = grep { !/s/} @ara;
# @arb=('ein','neuer');
@arb = grep {s/e/x/} @ara;
# @arb=('xin','nxuer','Txst');
|
Perl
Vorsicht: Die Übergabe großer Arrays erfordert viel Rechenzeit !
Diese Methode ist sparsam und schnell, und zwar sowohl zur Übergabe von Arrays
an Subs als auch zur Rückgabe von Arrays aus subs !