PHP
Arrays

Einführung

Syntax

• $ array = array ('Value1', 'Value2', 'Value3'); // Schlüssel sind standardmäßig 0, 1, 2, ...,
• $ array = array ('Value1', 'Value2',); // Optionales Nachkomma
• $ array = array ('key1' => 'Value1', 'key2' => 'Value2',); // Explizite Schlüssel
• $ array = array ('key1' => 'Value1', 'Value2',); // Array (['key1'] => Value1 [1] => 'Value2')
• $ array = ['key1' => 'Value1', 'key2' => 'Value2',]; // PHP 5.4+ Abkürzung
• $ array [] = 'ValueX'; // Hängen Sie 'ValueX' an das Ende des Arrays an
• $ array ['keyX'] = 'ValueX'; // "valueX" dem Schlüssel "keyX" zuordnen
• $ array + = ['keyX' => 'valueX', 'keyY' => 'valueY']; // Hinzufügen / Überschreiben von Elementen in einem vorhandenen Array

Parameter

Bemerkungen

Array initialisieren

Ein Array kann leer initialisiert werden:

// An empty array
$foo = array();

// Shorthand notation available since PHP 5.4
$foo = [];

Ein Array kann initialisiert und mit Werten vorbelegt werden:

// Creates a simple array with three strings
$fruit = array('apples', 'pears', 'oranges');

// Shorthand notation available since PHP 5.4
$fruit = ['apples', 'pears', 'oranges'];

Ein Array kann auch mit benutzerdefinierten Indizes (auch assoziatives Array genannt) initialisiert werden:

// A simple associative array
$fruit = array(
   'first'  => 'apples',
   'second' => 'pears', 
   'third'  => 'oranges'
);

// Key and value can also be set as follows
$fruit['first'] = 'apples';

// Shorthand notation available since PHP 5.4
$fruit = [
    'first'  => 'apples', 
    'second' => 'pears', 
    'third'  => 'oranges'
];

Wenn die Variable noch nicht verwendet wurde, erstellt PHP sie automatisch. Dies ist zwar praktisch, aber der Code wird möglicherweise schwieriger zu lesen:

$foo[] = 1;     // Array( [0] => 1 )
$bar[][] = 2;   // Array( [0] => Array( [0] => 2 ) )

Der Index wird normalerweise dort fortgesetzt, wo Sie aufgehört haben. PHP versucht, numerische Zeichenfolgen als Ganzzahlen zu verwenden:

$foo = [2 => 'apple', 'melon'];  // Array( [2] => apple, [3] => melon )
$foo = ['2' => 'apple', 'melon']; // same as above
$foo = [2 => 'apple', 'this is index 3 temporarily', '3' => 'melon']; // same as above! The last entry will overwrite the second!

Um ein Array mit fester Größe zu initialisieren, können Sie SplFixedArray :

$array = new SplFixedArray(3);

$array[0] = 1;
$array[1] = 2;
$array[2] = 3;
$array[3] = 4; // RuntimeException

// Increase the size of the array to 10
$array->setSize(10);

Hinweis: Ein mit SplFixedArray erstelltes SplFixedArray hat bei großen Datenmengen einen geringeren Speicherbedarf, die Schlüssel müssen jedoch Ganzzahlen sein.

Um ein Array mit einer dynamischen Größe, aber mit n nicht leeren Elementen (z. B. einem Platzhalter) zu initialisieren, können Sie eine Schleife wie folgt verwenden:

$myArray = array();
$sizeOfMyArray = 5;
$fill = 'placeholder';

for ($i = 0; $i < $sizeOfMyArray; $i++) {
    $myArray[] = $fill;
}

// print_r($myArray); results in the following:
// Array ( [0] => placeholder [1] => placeholder [2] => placeholder [3] => placeholder [4] => placeholder ) 

Wenn alle Ihre Platzhalter gleich sind, können Sie sie auch mit der Funktion array_fill() erstellen:

array array_fill (int $ start_index, int $ num, gemischter $ -Wert)

Dadurch wird ein Array mit num Einträgen von value erstellt und start_index . Die Schlüssel beginnen bei start_index .

Hinweis: Wenn der start_index negativ ist, beginnt er mit dem negativen Index und geht von 0 für die folgenden Elemente aus.

$a = array_fill(5, 6, 'banana'); // Array ( [5] => banana, [6] => banana, ..., [10] => banana)
$b = array_fill(-2, 4, 'pear'); // Array ( [-2] => pear, [0] => pear, ..., [2] => pear)

Fazit: Mit array_fill() Sie für das, was Sie tatsächlich tun können, eingeschränkt. Die Schleife ist flexibler und eröffnet Ihnen ein breiteres Spektrum an Möglichkeiten.

Wenn Sie ein Array mit einem Zahlenbereich (z. B. 1-4) füllen möchten, können Sie entweder jedes einzelne Element an ein Array anhängen oder die Funktion range() verwenden:

Array-Bereich (gemischt $ start, gemischt $ end [, Anzahl $ step = 1])

Diese Funktion erstellt ein Array mit einem Bereich von Elementen. Die ersten beiden Parameter sind erforderlich, um den Start- und Endpunkt des (einschließlich) Bereichs festzulegen. Der dritte Parameter ist optional und definiert die Größe der durchgeführten Schritte. Wenn Sie einen range von 0 bis 4 mit einer stepsize von 1 stepsize , besteht das Array aus den folgenden Elementen: 0 , 1 , 2 , 3 und 4 . Wenn die Schrittgröße auf 2 erhöht wird (dh range(0, 4, 2) ), wäre das resultierende Array: 0 , 2 und 4 .

$array = [];
$array_with_range = range(1, 4);

for ($i = 1; $i <= 4; $i++) {
    $array[] = $i;
}
    
print_r($array); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
print_r($array_with_range); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )

range kann mit Ganzzahlen, Floats, Booleans (die zu Ganzzahlen umgewandelt werden) und Strings arbeiten. Bei der Verwendung von Gleitkommazahlen als Argumente ist jedoch Vorsicht geboten.

Überprüfen Sie, ob der Schlüssel vorhanden ist

Verwenden Sie array_key_exists() oder isset() oder !empty() :

$map = [
    'foo' => 1,
    'bar' => null,
    'foobar' => '',
];

array_key_exists('foo', $map); // true
isset($map['foo']); // true
!empty($map['foo']); // true

array_key_exists('bar', $map); // true
isset($map['bar']); // false
!empty($map['bar']); // false

Beachten Sie, dass isset() ein Element mit null als nicht vorhanden behandelt. Während !empty() dasselbe für jedes Element tut, das gleich false (mit einem schwachen Vergleich; beispielsweise werden null , '' und 0 von !empty() ) alle als falsch behandelt. Während isset($map['foobar']); ist true !empty($map['foobar']) ist false . Dies kann zu Fehlern führen (zum Beispiel kann leicht vergessen werden, dass die Zeichenfolge '0' als falsch behandelt wird), so dass die Verwendung von !empty() oft missbilligt wird.

Beachten Sie auch, dass isset() und !empty() funktionieren (und false zurückgeben), wenn $map nicht definiert ist. Dies macht sie etwas fehleranfällig für die Verwendung:

// Note "long" vs "lang", a tiny typo in the variable name.
$my_array_with_a_long_name = ['foo' => true];
array_key_exists('foo', $my_array_with_a_lang_name); // shows a warning
isset($my_array_with_a_lang_name['foo']); // returns false

Sie können auch nach ordinalen Arrays suchen:

$ord = ['a', 'b']; // equivalent to [0 => 'a', 1 => 'b']

array_key_exists(0, $ord); // true
array_key_exists(2, $ord); // false

Beachten Sie, dass isset() eine bessere Leistung als array_key_exists() da letzteres eine Funktion und das array_key_exists() ein Sprachkonstrukt ist.

Sie können auch key_exists() , ein Alias ​​für array_key_exists() .

Prüfen, ob im Array ein Wert vorhanden ist

Die Funktion in_array() gibt true zurück, wenn ein Element in einem Array vorhanden ist.

$fruits = ['banana', 'apple'];

$foo = in_array('banana', $fruits);
// $foo value is true

$bar = in_array('orange', $fruits);
// $bar value is false

Sie können auch die Funktion array_search() , um den Schlüssel eines bestimmten Elements in einem Array array_search() .

$userdb = ['Sandra Shush', 'Stefanie Mcmohn', 'Michael'];
$pos = array_search('Stefanie Mcmohn', $userdb);
if ($pos !== false) {
    echo "Stefanie Mcmohn found at $pos";
}

$userdb = [
    [
        "uid" => '100',
        "name" => 'Sandra Shush',
        "url" => 'urlof100',
    ],
    [
        "uid" => '5465',
        "name" => 'Stefanie Mcmohn',
        "pic_square" => 'urlof100',
    ],
    [
        "uid" => '40489',
        "name" => 'Michael',
        "pic_square" => 'urlof40489',
    ]
];

$key = array_search(40489, array_column($userdb, 'uid'));

Überprüfung des Array-Typs

Die Funktion is_array() gibt true zurück, wenn eine Variable ein Array ist.

$integer = 1337;
$array = [1337, 42];

is_array($integer); // false
is_array($array); // true

Sie können den Array-Typ in eine Funktion eingeben, um einen Parametertyp zu erzwingen. Das Weitergeben von etwas anderem führt zu einem schwerwiegenden Fehler.

function foo (array $array) { /* $array is an array */ }

Sie können auch die Funktion gettype() verwenden.

$integer = 1337;
$array = [1337, 42];

gettype($integer) === 'array'; // false
gettype($array) === 'array'; // true

ArrayAccess- und Iterator-Schnittstellen

Eine weitere nützliche Funktion ist der Zugriff auf Ihre benutzerdefinierten Objektsammlungen als Arrays in PHP. Im PHP-Kern (> = 5.0.0) sind zwei Schnittstellen verfügbar, die dies unterstützen: ArrayAccess und Iterator . Ersteres ermöglicht den Zugriff auf Ihre benutzerdefinierten Objekte als Array.

ArrayAccess

Angenommen, es gibt eine Benutzerklasse und eine Datenbanktabelle, in der alle Benutzer gespeichert sind. Wir möchten eine UserCollection Klasse erstellen, die:

1. Erlauben Sie uns, bestimmte Benutzer anhand ihres eindeutigen Benutzernamens anzusprechen
2. grundlegende Operationen (nicht alle CRUDs, aber zumindest Erstellen, Abrufen und Löschen) für unsere Benutzersammlung ausführen

Betrachten Sie die folgende Quelle (im Folgenden verwenden wir die seit Version 5.4 verfügbare kurze Array-Erstellungssyntax [] ):

class UserCollection implements ArrayAccess {
    protected $_conn;
    
    protected $_requiredParams = ['username','password','email'];
    
    public function __construct() {
        $config = new Configuration();

        $connectionParams = [
            //your connection to the database
        ];
        
        $this->_conn = DriverManager::getConnection($connectionParams, $config);
    }
    
    protected function _getByUsername($username) {
        $ret = $this->_conn->executeQuery('SELECT * FROM `User` WHERE `username` IN (?)',
            [$username]
        )->fetch();
        
        return $ret;
    }
    
    // START of methods required by ArrayAccess interface
    public function offsetExists($offset) {
        return (bool) $this->_getByUsername($offset);
    }

    public function offsetGet($offset) {
        return $this->_getByUsername($offset);
    }

    public function offsetSet($offset, $value) {
        if (!is_array($value)) {
            throw new \Exception('value must be an Array');
        }

        $passed = array_intersect(array_values($this->_requiredParams), array_keys($value));
        if (count($passed) < count($this->_requiredParams)) {
            throw new \Exception('value must contain at least the following params: ' . implode(',', $this->_requiredParams));
        }
        $this->_conn->insert('User', $value);
    }

    public function offsetUnset($offset) {
        if (!is_string($offset)) {
            throw new \Exception('value must be the username to delete');
        }
        if (!$this->offsetGet($offset)) {
            throw new \Exception('user not found');
        }
        $this->_conn->delete('User', ['username' => $offset]);
    }
    // END of methods required by ArrayAccess interface
}

dann können wir :

$users = new UserCollection();

var_dump(empty($users['testuser']),isset($users['testuser']));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(empty($users['testuser']), isset($users['testuser']), $users['testuser']);
unset($users['testuser']);
var_dump(empty($users['testuser']), isset($users['testuser']));

testuser gibt Folgendes aus, vorausgesetzt, es gab keinen testuser bevor wir den Code starteten:

bool(true)
bool(false)
bool(false)
bool(true)
array(17) {
  ["username"]=>
  string(8) "testuser"
  ["password"]=>
  string(12) "testpassword"
  ["email"]=>
  string(13) "[email protected]"
}
bool(true)
bool(false)

WICHTIG: offsetExists wird nicht aufgerufen, wenn Sie das Vorhandensein eines Schlüssels mit der Funktion array_key_exists überprüfen. Der folgende Code gibt also zweimal false :

var_dump(array_key_exists('testuser', $users));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(array_key_exists('testuser', $users));

Iterator

Lassen Sie uns unsere Klasse von oben mit ein paar Funktionen der Iterator Schnittstelle erweitern, um mit foreach und while iterieren zu können.

Zuerst müssen wir eine Eigenschaft hinzufügen, die unseren aktuellen Iterator-Index enthält. $_position wir sie den Klasseneigenschaften als $_position :

// iterator current position, required by Iterator interface methods
protected $_position = 1;

Zweitens fügen wir der Liste der Schnittstellen, die von unserer Klasse implementiert werden, die Iterator Schnittstelle hinzu:

class UserCollection implements ArrayAccess, Iterator {

fügen Sie dann die von der Schnittstelle benötigten Funktionen selbst hinzu:

// START of methods required by Iterator interface
public function current () {
    return $this->_getById($this->_position);
}
public function key () {
    return $this->_position;
}
public function next () {
    $this->_position++;
}
public function rewind () {
    $this->_position = 1;
}
public function valid () {
    return null !== $this->_getById($this->_position);
}
// END of methods required by Iterator interface

Alles in allem ist hier also die vollständige Quelle der Klasse vorhanden, die beide Schnittstellen implementiert. Beachten Sie, dass dieses Beispiel nicht perfekt ist, da die IDs in der Datenbank möglicherweise nicht sequenziell sind. Dies wurde jedoch nur geschrieben, um Ihnen die Hauptidee zu vermitteln: Sie können Ihre Objektsammlungen auf jede mögliche Weise ArrayAccess , indem Sie ArrayAccess und Iterator Schnittstellen implementieren:

class UserCollection implements ArrayAccess, Iterator {
    // iterator current position, required by Iterator interface methods
    protected $_position = 1;
    
    // <add the old methods from the last code snippet here>
    
    // START of methods required by Iterator interface
    public function current () {
        return $this->_getById($this->_position);
    }
    public function key () {
        return $this->_position;
    }
    public function next () {
        $this->_position++;
    }
    public function rewind () {
        $this->_position = 1;
    }
    public function valid () {
        return null !== $this->_getById($this->_position);
    }
    // END of methods required by Iterator interface
}

und eine foreach-Schleife durch alle Benutzerobjekte:

foreach ($users as $user) {
    var_dump($user['id']);
}

was etwas ausgeben wird

string(2) "1"
string(2) "2"
string(2) "3"
string(2) "4"
...

Ein Array von Variablen erstellen

$username = 'Hadibut';
$email = '[email protected]';

$variables = compact('username', 'email');
// $variables is now ['username' => 'Hadibut', 'email' => '[email protected]']

Diese Methode wird häufig in Frameworks verwendet, um ein Array von Variablen zwischen zwei Komponenten zu übergeben.