PHP 5.5.16 is released

Arrays

Ein Array in PHP ist tatsächlich eine geordnete Map. Eine Map ist ein Typ, der Werte zu Schlüsseln zuordnet. Dieser Typ ist für einige verschiedene Nutzungsarten optimiert. Er kann als ein Array verwendet werden, als Liste (Vektor), Hash Table (eine Implementierung einer Map), Dictionary, Collection, Stack, Queue und wahrscheinlich noch andere. Da ein Wert eines Arrays ein weiteres Array sein kann sind auch Bäume und mehrdimensionale Arrays möglich.

Die Erläuterung dieser Datenstrukturen ist nicht im Rahmen dieses Handbuches, aber wenigstens ein Beispiel für jedes ist hier angegeben. Um weitere Informationen zu erhalten wird auf die immense Literatur zu diesem weiten Feld verwiesen.

Syntax

Spezifizierung mittels array()

Ein Array kann durch das Sprachkonstrukt array() erzeugt werden. Dies nimmt eine beliebige Anzahl kommaseparierter Schlüssel => Wert- Paare als Parameter entgegen.

array(
    Schlüssel  => Wert,
    Schlüssel2 => Wert2,
    Schlüssel3 => Wert3,
    ...
)

Das Komma nach dem letzten Array-Element ist optional und kann weggelassen werden. Dies wird üblicherweise in einzeiligen Arrays getan, d.h. array(1, 2) wird der Schreibweise array(1, 2, ) vorgezogen. Andererseits wird bei mehrzeiligen Arrays wird das Komma am Ende üblicherweise genutzt, da dies ein einfaches Hinzufügen weiterer Elemente am Ende erlaubt.

Seit PHP 5.4 kann auch eine kurze Array-Syntax verwendet werden, welche array() durch [] ersetzt.

Beispiel #1 Ein einfaches Array

<?php
$array 
= array(
    
"foo" => "bar",
    
"bar" => "foo",
);

// seit PHP 5.4
$array = [
    
"foo" => "bar",
    
"bar" => "foo",
];
?>

Der Schlüssel kann entweder ein Integer oder ein String sein. Der Wert kann beliebige Datentypen annehmen.

Zusätzlich werden die folgenden Typkonvertierungen auf den Schlüssel angewendet:

  • Strings die einen gültigen Integer enthalten werden zum entsprechenden Integer umgewandelt. Beispielsweise wird der Schlüssel "8" tatsächlich unter 8 gespeichert. Andererseits wird "08" nicht umgewandelt, da dies kein gültiger Ganzzahlwert ist.
  • Floats werden ebenfalls zu Integer umgewandelt, was ein Abschneiden des Dezimalbruches zur Folge hat. Beispielsweise wird der Schlüssel 8.7 als 8 gespeichert.
  • Bools werden ebenfalls zu Integer umgewandelt, d.h. der Schlüssel true wird unter 1 gespeichert und der Schlüssel false unter 0.
  • Null wird zu einem leeren String umgewandelt, d.h. der Schlüssel null wird tatsächlich unter "" gespeichert.
  • Werte vom typ Array oder Object können nicht als Schlüssel verwendet werden. Ein Versuch dies zu tun wird die Warnung Illegal offset type zur Folge haben.

Wenn mehrere Elemente in einer Array-Deklaration den gleichen Schlüssel verwenden, dann wird nur der letzte verwendet und alle weiteren überschrieben.

Beispiel #2 Beispiel für Typenumwandlung und Überschreibung

<?php
$array 
= array(
    
1    => "a",
    
"1"  => "b",
    
1.5  => "c",
    
true => "d",
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(1) {
  [1]=>
  string(1) "d"
}

Da alle Schlüssel im obigen Beispiel zu 1 umgewandelt werden, wird der Wert dieses Elements durch jeden angegebenen Wert überschrieben und nur der letzte zugewiesene Wert "d" bleibt übrig.

Arrays können in PHP gleichzeitig Schlüssel der Typen Integer und String enthalten, da PHP nicht zwischen indizierten und assoziativen Arrays unterscheidet.

Beispiel #3 Gemischte Integer und String Schlüssel

<?php
$array 
= array(
    
"foo" => "bar",
    
"bar" => "foo",
    
100   => -100,
    -
100  => 100,
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

Die Angabe des Schlüssel ist optional.Ist keiner angegeben, so wird PHP den bisher größten angegebenen Integer Schlüssel erhöhen und das Ergebnis als Schlüssel verwenden.

Beispiel #4 Indizierte Arrays ohne Schlüssel

<?php
$array 
= array("foo""bar""hello""world");
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

Es ist auch möglich den Schlüssel nur bei einigen Elementen anzugeben:

Beispiel #5 Schlüssel nicht bei allen Elementen

<?php
$array 
= array(
         
"a",
         
"b",
    
=> "c",
         
"d",
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Wie Sie sehen können wurde dem letzten Wert "d" der Schlüssel 7 zugewiesen. Dies erfolgte da der größte vorherige ganzzahlige Schlüssel die 6 war.

Zugriff auf Elemente mit eckigen Klammern

Auf Eleemente eines Arrays kann durch Verwendung der Syntax array[Schlüssel] zugegriffen werden.

Beispiel #6 Zugriff auf Array-Elemente

<?php
$array 
= array(
    
"foo" => "bar",
    
42    => 24,
    
"multi" => array(
         
"dimensional" => array(
             
"array" => "foo"
         
)
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

string(3) "bar"
int(24)
string(3) "foo"

Hinweis:

Sowohl eckige als auch geschweifte Klammern können verwendet werden, um auf die Elemente eines Arrays zuzugreifen (z.B. werden im obigen Beispiel $array[43] und array{42} auf das gleiche Element zugreifen).

Seit PHP 5.4 ist es möglich ein Array aus dem Rückgabewert eines Funktion direkt zu dereferenzieren. Vorher war dies nur über temporäre Variablen möglich.

Seit PHP 5.5 ist es möglich ein Array-Literal zu dereferenzieren.

Beispiel #7 Array-Dereferenzierung

<?php
function getArray() {
    return array(
123);
}

// seit PHP 5.4
$secondElement getArray()[1];

// vorher
$tmp getArray();
$secondElement $tmp[1];

// oder
list(, $secondElement) = getArray();
?>

Hinweis:

Der Versuch auf einen nicht definierten Arrayschlüssel zuzugreifen ist gleichwertig zum Zugriff jeder anderen undefinierten Variable: Ein Fehler der Stufe E_NOTICE wird ausgegeben und das Ergebnis ist NULL.

Anlegen/Ändern mit eckigen Klammern

Ein bestehendes Array kann verändert werden, indem man explizit Werte darin setzt.

Dies wird getan, indem man Werte dem Array zuweist und dabei den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei weggelassen werden, woraus ein leeres Klammernpaar resultiert ([]).

$arr[Schlüssel] = Wert;
$arr[] = Wert;
// Schlüssel kann ein Integer oder String sein
// Wert kann einen beliebigen Typen haben

Falls $arr noch nicht existiert wird es erzeugt, dies ist also eine alternative Methode, um ein Array zu erzeugen. Dieses Vorgehen wird jedoch nicht empfohlen, da falls $arr bereits einen Wert enthält (z.B. ein String aus einer Requestvariablen) bleibt dieser Wert bestehen und [] kann tatsächlich für den String-Zugriffs-Operator stehen. Es ist immer besser eine Variable durch direkte Zuweisung zu initialisieren.

Um einen bestimmten Wert zu ändern, kann man einen Wert zum Element anhand dessen Schlüssel zuweisen. Um ein Schlüssel-Wert-Paar zu entfernen, kann man die Funktion unset() darauf anwenden.

<?php
$arr 
= array(=> 112 => 2);

$arr[] = 56;    // Dies ist das selbe wie $arr[13] = 56;
                // an dieser Stelle im Programmablauf

$arr["x"] = 42// Dies fügt ein neues Element zum Array
                // mit dem Schlüssel "x" hinzu

unset($arr[5]); // Dies entfernt das Element aus dem
                // Array

unset($arr);    // Dies löscht das gesamte Array
?>

Hinweis:

Wie vorher bereits erwähnt wird das Maximum der bestehenden Schlüssel vom Typ Integer verwendet, wenn kein Schlüssel angegeben ist, und der neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn noch kein Integer-Schlüssel existiert wird der schlüssel 0 (Null) verwendet.

Beachten Sie, dass der Maximalwert der Integer-Schlüssel dafür aktuell nicht im Array existieren muss. Er muss nur zu einem vorherigen Zeitpunkt im Array existiert haben seitdem das Array zuletzt neu indiziert wurde. Das folgende Beispiel erläutert dies:

<?php
// Create a simple array.
$array = array(12345);
print_r($array);

// Nun wird jeder Wert gelöscht, aber das Array selbst bleibt bestehen
foreach ($array as $i => $value) {
    unset(
$array[$i]);
}
print_r($array);

// Ein Element wird hinzugefügt
// (Beachten Sie, dass der neue Schlüssel 5 ist statt 0)
$array[] = 6;
print_r($array);

// Neue Indizierung
$array array_values($array);
$array[] = 7;
print_r($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Nützliche Funktionen

Es gibt einige nützliche Funktionen für die Arbeit mit Arrays, die im Abschnitt Array-Funktionen nachgeschlagen werden können.

Hinweis:

Die Funktion unset() erlaubt es Schlüssel aus einem Array zu entfernen. Beachten Sie dabei, dass das Array nicht neu indiziert wird. Falls ein echtes Verhalten von "entfernen und verschieben" gewünscht ist, dann kann das Array mittels array_values() neu indiziert werden.

<?php
$a 
= array(=> 'one'=> 'two'=> 'three');
unset(
$a[2]);
/* dies wird ein Array erzeugen, dass wie folgt definiert wäre
   $a = array(1 => 'one', 3 => 'three');
   und nicht so
   $a = array(1 => 'one', 2 =>'three');
*/

$b array_values($a);
// Nun ist $b array(0 => 'one', 1 =>'three')
?>

Die Kontrollstruktur foreach existiert speziell für Arrays. Sie bietet eine einfache Möglichkeit, ein Array zu durchlaufen.

Do's und Dont's für Arrays

Wieso ist $foo[bar] falsch?

Verwenden Sie immer Anführungszeichen um ein Zeichenkettenliteral des Index eines Arrays. Beispilsweise ist $foo['bar'] richtig, $foo[bar] hingegen nicht. Aber wieso nicht? Es ist üblich die folgende Schreibweise in alten Skripten zu finden:

<?php
$foo
[bar] = 'enemy';
echo 
$foo[bar];
// etc
?>

Dies ist falsch, funktioniert aber. Der Grund dafür ist, dass dieser Code eine undefinierte Konstante (bar) anstatt eines String verwendet ('bar' - beachten Sie die Anführungszeichen). PHP kann zukünftig Konstanten definieren die zum Leidwesen dieses Codes den gleichen Namen haben könnten. Dies funktioniert, da PHP automatisch einen nackten String (ein String ohne Anführungszeichen welcher nicht einem bekannten Symbol entspricht) in einen String umwandelt, welcher den nackten String enthält. Beispielsweise wird, wenn keine Konstante namens bar definiert ist, PHP diese automatisch durch den String 'bar' ersetzen und verwenden.

Hinweis: Dies bedeutet nicht, dass man den Schlüssel immer in Anführungszeichen schreiben muss. Schreiben Sie keine Schlüssel in Anführungszeichen, welche Konstanten oder Variablen sind, da dies PHP daran hindern wird diese zu interpretieren.

<?php
error_reporting
(E_ALL);
ini_set('display_errors'true);
ini_set('html_errors'false);
// Simples Array:
$array = array(12);
$count count($array);
for (
$i 0$i $count$i++) {
    echo 
"\nPrüfe $i: \n";
    echo 
"Schlecht: " $array['$i'] . "\n";
    echo 
"Gut: " $array[$i] . "\n";
    echo 
"Schlecht: {$array['$i']}\n";
    echo 
"Gut: {$array[$i]}\n";
}
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Prüfe 0: 
Notice: Undefined index:  $i in /path/to/script.html on line 9
Schlecht: 
Gut: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Schlecht: 
Gut: 1

Prüfe 1: 
Notice: Undefined index:  $i in /path/to/script.html on line 9
Schlecht: 
Gut: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Schlecht: 
Gut: 2

Weitere Beispiele zur Erläuterung dieses Verhaltens:

<?php
// Alle Fehler anzeigen
error_reporting(E_ALL);

$arr = array('fruit' => 'apple''veggie' => 'carrot');

// Korrekt
print $arr['fruit'];  // apple
print $arr['veggie']; // carrot

// Inkorrekt. Dies Funktioniert, aber PHP wirft einen Fehler der Stufe
// E_NOTICE, da eine undefinierte Konstante namens fruit verwendet wird
// 
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit];    // apple

// Dies definiert eine Konstante, um darzustellen was hier passiert. Der Wert
// 'veggie' wird einer Konstanten namens fruit zugewiesen
define('fruit''veggie');

// Beachten Sie nun den Unterschied
print $arr['fruit'];  // apple
print $arr[fruit];    // carrot

// Hier ist es in Ordnung, da dies innerhalb eines String ist. Innerhalb eines
// Strings wird nicht nach Konstanten gesucht, weshalb kein E_NOTICE auftritt
print "Hello $arr[fruit]";      // Hello apple

// Mit einer Ausnahme: Klammern um ein Array sorgen dafür, dass Konstanten
// interpretiert werden
print "Hello {$arr[fruit]}";    // Hello carrot
print "Hello {$arr['fruit']}";  // Hello apple

// Dies wird nicht funktionieren und zu einem Parser Fehler führen:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Dies gilt natürlich ebenso für superglobale Werte innerhalb von Strings
print "Hello $arr['fruit']";
print 
"Hello $_GET['foo']";

// Konkatenation ist eine weitere Möglichkeit
print "Hello " $arr['fruit']; // Hello apple
?>

Wenn error_reporting so eingestellt wird, dass Fehler der Stufe E_NOTICE angezeigt werden (indem man es auf E_ALL stellt), so wird diese Verwendung sofort sichtbar. Standardmäßig ist error_reporting nicht entsprechend eingestellt, um solche Hinweise zu zeigen.

Wie im Anschnitt zur Syntax gezeigt muss der Inhalt der eckigen Klammern '[' und ']') ein Ausdruck sein. Das bedeutet dass folgendes funktioniert:

<?php
echo $arr[somefunc($bar)];
?>

Dieses Beispiel zeigt, wie der Rückgabewert einer Funktion als Arrayindex verwendet wird. PHP kann auch Konstanten auflösen:

<?php
$error_descriptions
[E_ERROR]   = "A fatal error has occurred";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE]  = "This is just an informal notice";
?>

Beachten Sie, dass E_ERROR ein gültiger Bezeichner ist, genau wie bar im ersten Beispiel. Das vorherige Beispiel ist gleichbedeutend mit:

<?php
$error_descriptions
[1] = "A fatal error has occurred";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>

da E_ERROR gleich 1 ist usw.

Wieso ist es also schlecht?

Irgendwann in der Zukunft könnte das PHP-Team eine weitere Konstante oder ein Schlüsselwort hinzufügen oder eine Kostante in anderem Code könnte Einfluss nehmen. Es ist beispielsweise bereits falsch die Wörter empty oder default so zu schreiben, da dies reservierte Schlüsselwörter sind.

Hinweis: Zur Wiederholung: innerhalb eines String in doppelten Anführungszeichen ist es korrekt einen Arrayschlüssel ohne Anführungszeichen zu schreiben wie "$foo[bar]". Die obigen Beispiele erklären dies ebenso wie der Abschnitt zum Parsen von Variablen in Strings.

Konvertierung zu Array

Für jeden der Typen Integer, Float, String, Boolean und Resource führt eine Konvertierung eines Wertes in ein Array zu einem Array mit einem einzigen Wert mit dem Index Null und dem Wert des Skalaren der konvertiert wurde. Anders ausgedrückt ist (array)$scalarValue exakt identisch mit array($scalarValue).

Wenn ein Object in ein Array konvertiert wird, so ist das Ergebnis ein Array dessen werte die Eigenschaften des Object sind. Die Schlüssel sind die Namen der Eigenschaften des Objektes mit einigen Ausnahmen: Eigenschaften mit Ganzzahl-Namen sind nicht zugreifbar, privaten Variablen wird der Name der Klasse vorangestellt und protected Variablen wird ein '*' dem Namen der Variablen vorangestellt. Diese vorangestellten Werte haben Null-Bytes auf beiden Seiten. Dies kann zu unerwartetem Verhalten führen:

<?php

class {
    private 
$A// Dies wird zu '\0A\0A'
}

class 
extends {
    private 
$A// Dies wird zu '\0B\0A'
    
public $AA// Dies wird zu 'AA'
}

var_dump((array) new B());
?>

Im obigen Beispiel scheint es zwei Schlüssel namens 'AA' zu geben, obwohl einer davon eigentlich '\0A\0A' ist.

Die Konvertierung von NULL in ein Array führt zu einem leeren Array.

Vergleiche

Es ist möglich Arrays mit der Funktion array_diff() und mit Array-Operatoren zu vergleichen.

Beispiele

Der Array-Typ in PHP ist sehr vielseitig. Hier sind einige Beispiele:

<?php
// This:
$a = array( 'color' => 'red',
            
'taste' => 'sweet',
            
'shape' => 'round',
            
'name'  => 'apple',
            
4        // Schlüssel wird 0 sein
          
);

$b = array('a''b''c');

// . . .ist komplett gleichbedeutend mit:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // Schlüssel wird 0 sein

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Nachdem der obige Code ausgeführt wurde wird $a das Array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
// 'name' => 'apple', 0 => 4) sein und $b wird das Array
// array(0 => 'a', 1 => 'b', 2 => 'c') oder einfacher array('a', 'b', 'c')
// sein
?>

Beispiel #8 Benutzung von array()

<?php
// Array als Map von Eigenschaften
$map = array( 'version'    => 4,
              
'OS'         => 'Linux',
              
'lang'       => 'english',
              
'short_tags' => true
            
);

// Streng numerische Schlüssel
$array = array( 7,
                
8,
                
0,
                
156,
                -
10
              
);
// das ist gleichbedeutend mit array(0 => 7, 1 => 8, ...)

$switching = array(         10// Schlüssel = 0
                    
5    =>  6,
                    
3    =>  7
                    
'a'  =>  4,
                            
11// Schlüssel = 6 (Maximum der Integer-Schlüssel war 5)
                    
'8'  =>  2// Schlüssel = 8 (Integer!)
                    
'02' => 77// Schlüssel = '02'
                    
0    => 12  // Der Wert 10 wird mit 12 überschrieben
                  
);

// Leeres array
$empty = array();         
?>

Beispiel #9 Collection

<?php
$colors 
= array('red''blue''green''yellow');

foreach (
$colors as $color) {
    echo 
"Do you like $color?\n";
}

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Do you like red?
Do you like blue?
Do you like green?
Do you like yellow?

Die Veränderung der Werte eines Array ist seit PHP mit der Übergabe als Referenz direkt möglich. Vorher war ein Workaround notwendig:

Beispiel #10 Elemente in der Schleife verändern

<?php
// PHP 5
foreach ($colors as &$color) {
    
$color strtoupper($color);
}
unset(
$color); /* Sicherstellen, dass nachfolgende
Zugriffe auf $color nicht das letzte Element ändern */

// Workaround für ältere Versionen
foreach ($colors as $key => $color) {
    
$colors[$key] = strtoupper($color);
}

print_r($colors);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [0] => RED
    [1] => BLUE
    [2] => GREEN
    [3] => YELLOW
)

Dieses Beispiel erzeugt ein Array mit erstem Schlüsse 1

Beispiel #11 1-basierte Indizes

<?php
$firstquarter  
= array(=> 'January''February''March');
print_r($firstquarter);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array 
(
    [1] => 'January'
    [2] => 'February'
    [3] => 'March'
)

Beispiel #12 Ein Array befüllen

<?php
// Dies füllt ein Array mit allen Einträgen eines Verzeichnisses
$handle opendir('.');
while (
false !== ($file readdir($handle))) {
    
$files[] = $file;
}
closedir($handle); 
?>

Arrays sind sortiert. Die Reihenfolge kann durch verschiedene Sortierfunktionen verändert werden. Siehe Array-Funktionen für mehr Informationen. Die Funktion count() kann herangezogen werden, um die Anzahl der Elemente eines Array zu ermitteln.

Beispiel #13 Ein Array sortieren

<?php
sort
($files);
print_r($files);
?>

Da die Werte eines Array beliebig sein können, können diese auch andere Arrays sein. Dies ermöglicht die Erzeugung von rekursiven und mehrdimensionalen Arrays.

Beispiel #14 Rekursive und mehrdimensionale Arrays

<?php
$fruits 
= array ( "fruits"  => array ( "a" => "orange",
                                       
"b" => "banana",
                                       
"c" => "apple"
                                     
),
                  
"numbers" => array ( 1,
                                       
2,
                                       
3,
                                       
4,
                                       
5,
                                       
6
                                     
),
                  
"holes"   => array (      "first",
                                       
=> "second",
                                            
"third"
                                     
)
                );

// Einige Beispiele um auf Werde in den obigen Beispielen zuzugreifen
echo $fruits["holes"][5];    // prints "second"
echo $fruits["fruits"]["a"]; // prints "orange"
unset($fruits["holes"][0]);  // remove "first"

// Ein neues mehrdimensionales Array erzeugen
$juices["apple"]["green"] = "good"
?>

Zuweisung von Arrays zu Variablen involviert immer eine Kopie der Werte. Verwenden Sie den Referez-Operator um eine Kopie einer Referenz auf ein Array zu erzeugen.

<?php
$arr1 
= array(23);
$arr2 $arr1;
$arr2[] = 4// $arr2 ist geändert,
             // $arr1 ist weiterhin array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4// nun sind $arr1 und $arr3 identisch
?>
add a note add a note

User Contributed Notes 21 notes

up
67
mlvljr
3 years ago
please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
up
33
chris at ocportal dot com
1 year ago
Note that array value buckets are reference-safe, even through serialization.

<?php
$x
='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo
$test['B']; // Outputs "changed"
?>

This can be useful in some cases, for example saving RAM within complex structures.
up
45
ken underscore yap atsign email dot com
6 years ago
"If you convert a NULL value to an array, you get an empty array."

This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.

<?php $values = search(...); ?>

Now you want to merge the array with another array. What do we do if $values is NULL? No problem:

<?php $combined = array_merge((array)$values, $other); ?>

Voila.
up
42
jeff splat codedread splot com
9 years ago
Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:

<html>
<body>
<?php
    printf
("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    <input type="hidden" name="Windows3.1" value="Sux">
    <input type="submit" value="Click" />
</form>
</body>
</html>

Once you click on the button, the page displays the following:

POST: Array ( [Windows3_1] => Sux )
up
17
ivegner at yandex dot ru
11 months ago
Note that objects of classes extending ArrayObject SPL class are treated as arrays, and not as objects when converting to array.

<?php
class ArrayObjectExtended extends ArrayObject
{
    private
$private = 'private';
    public
$hello = 'world';
}

$object = new ArrayObjectExtended();
$array = (array) $object;

// This will not expose $private and $hello properties of $object,
// but return an empty array instead.
var_export($array);
?>
up
33
ia [AT] zoznam [DOT] sk
8 years ago
Regarding the previous comment, beware of the fact that reference to the last value of the array remains stored in $value after the foreach:

<?php
foreach ( $arr as $key => &$value )
{
   
$value = 1;
}

// without next line you can get bad results...
//unset( $value );

$value = 159;
?>

Now the last element of $arr has the value of '159'. If we remove the comment in the unset() line, everything works as expected ($arr has all values of '1').

Bad results can also appear in nested foreach loops (the same reason as above).

So either unset $value after each foreach or better use the longer form:

<?php
foreach ( $arr as $key => $value )
{
   
$arr[ $key ] = 1;
}
?>
up
32
lars-phpcomments at ukmix dot net
9 years ago
Used to creating arrays like this in Perl?

@array = ("All", "A".."Z");

Looks like we need the range() function in PHP:

<?php
$array
= array_merge(array('All'), range('A', 'Z'));
?>

You don't need to array_merge if it's just one range:

<?php
$array
= range('A', 'Z');
?>
up
2
note dot php dot lorriman at spamgourmet dot org
7 months ago
There is another kind of array (php>=  5.3.0) produced by

$array = new SplFixedArray(5);

Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation.

Supposing a large string-keyed array

$arr=['string1'=>$data1, 'string2'=>$data2 etc....]

when getting the keyed data with

$data=$arr['string1'];

php does *not* have to search through the array comparing each key string to the given key ('string1') one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it's all hidden away.

However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :

http://uk3.php.net/SplFixedArray

Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It's also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).
up
25
caifara aaaat im dooaat be
8 years ago
[Editor's note: You can achieve what you're looking for by referencing $single, rather than copying it by value in your foreach statement. See http://php.net/foreach for more details.]

Don't know if this is known or not, but it did eat some of my time and maybe it won't eat your time now...

I tried to add something to a multidimensional array, but that didn't work at first, look at the code below to see what I mean:

<?php

$a1
= array( "a" => 0, "b" => 1 );
$a2 = array( "aa" => 00, "bb" => 11 );

$together = array( $a1, $a2 );

foreach(
$together as $single ) {
   
$single[ "c" ] = 3 ;
}

print_r( $together );
/* nothing changed result is:
Array
(
    [0] => Array
        (
            [a] => 0
            [b] => 1
        )
    [1] => Array
        (
            [aa] => 0
            [bb] => 11
        )
) */

foreach( $together as $key => $value ) {
   
$together[$key]["c"] = 3 ;
}

print_r( $together );

/* now it works, this prints
Array
(
    [0] => Array
        (
            [a] => 0
            [b] => 1
            [c] => 3
        )
    [1] => Array
        (
            [aa] => 0
            [bb] => 11
            [c] => 3
        )
)
*/

?>
up
1
Ray.Paseur often uses Gmail
1 month ago
Array-to-String conversion by assignment or by using an array in a string context gives a string of data that contains only the word, 'Array' and this data substitution often occurs silently.  This happens because the standard PHP installation suppresses Notice-level messages, and the array-to-string conversion, even though it causes data loss, is only considered a Notice condition.  Here is how to discern what PHP is doing.
http://php.net/manual/en/language.types.array.php
http://php.net/manual/en/language.types.string.php#language.types.string.casting

<?php // demo/array_to_string.php
/**
* Starting with the default standard error-level of E_ALL ~ E_NOTICE
* OUTPUTS:
* Array
*/
$xyz = array('X', 'Y', 'Z');
echo
$xyz;

/**
* Setting the error-level of E_ALL causes Notice messages to appear
* OUTPUTS:
* Notice: Array to string conversion in /path/to/demo/array_to_string.php on line XXX
* Array
*/
error_reporting(E_ALL);
$xyz = array('X', 'Y', 'Z');
echo
$xyz;
up
1
martijntje at martijnotto dot nl
2 years ago
Please note that adding the magic __toString() method to your objects will not allow you to seek an array with it, it still throws an Illegal Offset warning.

The solution is to cast it to a string first, like this

$array[(string) $stringableObject]
up
-5
cromney at pointslope dot com
1 year ago
One thing to be careful of is making any assumptions about the underlying implementation with respect to performance. For example, the documentation talks about hash-maps, which might lead you to expect O(1) key lookups.

<?php

function find_val($n) {
 
$t = array();
 
$last = null;
 
  for (
$x = 0; $x < $n; $x++) {
   
$last = "" . $x;
   
$t[] = $last;
  }
 
 
var_dump(in_array($last, $t));


 
function
find_key($n) {
 
$t = array();
 
$last = null;
 
  for (
$x = 0; $x < $n; $x++) {
   
$last = "" . $x;
   
$t[$last] = true;
  }
 
 
var_dump(array_key_exists($last, $t));


$n = 1600000;

find_val($n);
// Time taken: 1123ms

find_key($n);
// Time taken: 803

/*

Additional Timings:

n        find_val(ms)  find_key(ms)
100000   99             82
200000   169            130
400000   301            217
800000   570            416
1600000  1123           803

*/
?>

In my tests, both in_array and array_key_exists exhibited the same order of growth.
up
-4
Anonymous
7 years ago
This page should include details about how associative arrays are implemened inside PHP; e.g. using hash-maps or b-trees.

This has important implictions on the permance characteristics of associative arrays and how they should be used; e.g. b-tree are slow to insert but handle collisions better than hashmaps.  Hashmaps are faster if there are no collisions, but are slower to retrieve when there are collisions.  These factors have implictions on how associative arrays should be used.
up
-5
Spudley
7 years ago
On array recursion...

Given the following code:

<?php
$myarray
= array('test',123);
$myarray[] = &$myarray;
print_r($myarray);
?>

The print_r() will display *RECURSION* when it gets to the third element of the array.

There doesn't appear to be any other way to scan an array for recursive references, so if you need to check for them, you'll have to use print_r() with its second parameter to capture the output and look for the word *RECURSION*.

It's not an elegant solution, but it's the only one I've found, so I hope it helps someone.
up
-8
harry at ddtechnologies dot com
1 year ago
PHP array_diff_assoc() Function

You can compare the keys and values of two arrays, and return the differences:

<?php
$a1
=array("red","green","blue","yellow");
$a2=array("red","green","blue");

$result=array_diff_assoc($a1,$a2);
print_r($result);
?>

http://www.show-ip.org
up
-16
Walter Tross
4 years ago
It is true that "array assignment always involves value copying", but the copy is a "lazy copy". This means that the data of the two variables occupy the same memory as long as no array element changes.

E.g., if you have to pass an array to a function that only needs to read it, there is no advantage at all in passing it by reference.
up
-19
gtisza at gmail dot com
1 year ago
Be very careful when using a result as an array. <?php echo $a['foo']['bar']['baz'] ?> will throw an error if $a is an object, and throw a warning if $a is an array but does not have the right keys, but it will silently return true if $a is null or boolean or int, and if $a is a string, it will return its first character. (This is true even with E_STRICT set.) This can be a major gotcha with functions which return null or false if they are unsuccessful.
up
-4
brta dot akos at gmail dot com
7 months ago
Why not to user one-based arrays:

<?php
$a 
= array(1 => 'a', 'b', 'd');
print_r($a);
array_splice($a,2,0,'c');
print_r($a);
?>

output:
Array ( [1] => a [2] => b [3] => d ) Array ( [0] => a [1] => b [2] => c [3] => d )
up
-8
ffe
6 months ago
<?php

error_reporting
(E_ALL);

$res=42;

echo(
"+".$res[0]."+".$res[10]."+");

$res[0]=1;

?>

The last line correctly states "Warning: Cannot use a scalar value as an array", but the echo produces +++ as output with no warning. This seems strange to me.
up
-58
carl at linkleaf dot com
6 years ago
Its worth noting that there does not appear to be any functional limitations on the length or content of string indexes. The string indexes for your arrays can contain any characters, including new line characters, and can be of any length:

<?php

$key
= "XXXXX";
$test = array($key => "test5");

for (
$x = 0; $x < 500; $x++) {
 
$key .= "X";
 
$value = "test" . strlen($key);
 
$test[$key] = $value;
}

echo
"<pre>";
print_r($test);
echo
"</pre>";

?>

Keep in mind that using extremely long array indexes is not a good practice and could cost you lots of extra CPU time. However, if you have to use a long string as an array index you won't have to worry about the length or content.
up
-38
azuleta at eycambiental dot com
11 months ago
I think there's a mistake in the las example:
...'<?php
$arr1
= array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 ha cambiado,
             // $arr1 sigue siendo array(2, 3)
           
$arr3 = &$arr1;
$arr3[] = 4; // ahora $arr1 y $arr3 son iguales
?>'

I think it should be: ...'ahora $arr2 y $arr3 son iguales'...

Thanks.
To Top