PHP
arrays

Invoering

Syntaxis

• $ array = array ('Value1', 'Value2', 'Value3'); // Toetsen standaard op 0, 1, 2, ...,
• $ array = array ('Value1', 'Value2',); // Optionele volgkomma
• $ array = array ('key1' => 'Value1', 'key2' => 'Value2',); // Expliciete sleutels
• $ array = array ('key1' => 'Value1', 'Value2',); // Array (['key1'] => Value1 [1] => 'Value2')
• $ array = ['key1' => 'Value1', 'key2' => 'Value2',]; // PHP 5.4+ steno
• $ array [] = 'ValueX'; // Voeg 'ValueX' toe aan het einde van de array
• $ array ['keyX'] = 'ValueX'; // Wijs 'valueX' toe aan key 'keyX'
• $ array + = ['keyX' => 'valueX', 'keyY' => 'valueY']; // Elementen aan een bestaande array toevoegen / overschrijven

parameters

Opmerkingen

Een array initialiseren

Een array kan leeg worden geïnitialiseerd:

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

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

Een array kan worden geïnitialiseerd en vooraf worden ingesteld met waarden:

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

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

Een array kan ook worden geïnitialiseerd met aangepaste indexen (ook een associatieve array genoemd) :

// 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'
];

Als de variabele nog niet eerder is gebruikt, maakt PHP deze automatisch aan. Hoewel handig, kan dit de code moeilijker te lezen maken:

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

De index gaat meestal verder waar u was gebleven. PHP zal proberen numerieke strings als gehele getallen te gebruiken:

$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!

Om een array met een vaste grootte te initialiseren, kunt u 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);

Opmerking: een array die is gemaakt met SplFixedArray heeft een kleinere geheugenvoetafdruk voor grote gegevenssets, maar de sleutels moeten gehele getallen zijn.

Om een array te initialiseren met een dynamische grootte, maar met n niet lege elementen (bijvoorbeeld een placeholder) kan een lus als volgt:

$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 ) 

Als al uw tijdelijke aanduidingen hetzelfde zijn, kunt u deze ook maken met de functie array_fill() :

array array_fill (int $ start_index, int $ num, gemengde $ waarde)

Dit maakt en retourneert een array met num invoer van value , sleutels beginnend bij start_index .

Opmerking: als de start_index negatief is, begint deze met de negatieve index en gaat deze verder vanaf 0 voor de volgende elementen.

$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)

Conclusie: met array_fill() bent u beperkter voor wat u daadwerkelijk kunt doen. De lus is flexibeler en biedt u meer mogelijkheden.

Wanneer u een array wilt die is gevuld met een bereik van getallen (bijv. 1-4), kunt u elk element aan een array toevoegen of de functie range() :

matrixbereik (gemengd $ start, gemengd $ einde [, nummer $ step = 1])

Met deze functie maakt u een array met een reeks elementen. De eerste twee parameters zijn vereist, waar ze het begin- en eindpunt van het (inclusief) bereik instellen. De derde parameter is optioneel en definieert de grootte van de stappen die worden genomen. Als u een range van 0 tot 4 met een stepsize van 1 , bestaat de resulterende array uit de volgende elementen: 0 , 1 , 2 , 3 en 4 . Als de stapgrootte wordt verhoogd naar 2 (dwz range(0, 4, 2) ), dan is de resulterende array: 0 , 2 en 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 kan werken met gehele getallen, praalwagens, booleans (die naar gehele getallen worden geworpen) en tekenreeksen. Voorzichtigheid is echter geboden bij het gebruik van drijvers als argumenten vanwege het precisieprobleem met drijvende komma.

Controleer of de sleutel bestaat

Gebruik array_key_exists() of isset() of !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

Merk op dat isset() een element met null behandelt als niet-bestaand. Terwijl !empty() hetzelfde doet voor elk element dat false (met een zwakke vergelijking; bijvoorbeeld null , '' en 0 worden allemaal als false behandeld door !empty() ). While isset($map['foobar']); is true !empty($map['foobar']) is false . Dit kan leiden tot fouten (het is bijvoorbeeld gemakkelijk om te vergeten dat de tekenreeks '0' als vals wordt behandeld), dus het gebruik van !empty() wordt vaak afgekeurd.

Merk ook op dat isset() en !empty() zullen werken (en false retourneren) als $map helemaal niet is gedefinieerd. Dit maakt ze enigszins foutgevoelig om te gebruiken:

// 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

U kunt ook controleren op rangordes:

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

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

Merk op dat isset() betere prestaties array_key_exists() dan array_key_exists() aangezien de laatste een functie is en de eerste een taalconstructie.

U kunt ook key_exists() , wat een alias is voor array_key_exists() .

Controleren of er een waarde in de array bestaat

De functie in_array() retourneert true als er een item in een array bestaat.

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

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

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

U kunt ook de functie array_search() gebruiken om de sleutel van een specifiek item in een array op te halen.

$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'));

Het arraytype valideren

De functie is_array() retourneert true als een variabele een array is.

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

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

U kunt het matrixtype in een functie typen om een parametertype af te dwingen; het passeren van iets anders leidt tot een fatale fout.

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

U kunt ook de functie gettype() .

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

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

ArrayAccess en Iterator-interfaces

Een andere handige functie is toegang tot uw aangepaste objectcollecties als arrays in PHP. Er zijn twee interfaces beschikbaar in PHP (> = 5.0.0) om dit te ondersteunen: ArrayAccess en Iterator . Met het eerste hebt u toegang tot uw aangepaste objecten als array.

ArrayAccess

Stel dat we een gebruikersklasse en een databasetabel hebben waarin alle gebruikers zijn opgeslagen. We willen een UserCollection klasse maken die:

1. Sta ons toe om bepaalde gebruikers aan te spreken met hun unieke gebruikersnaam
2. basisbewerkingen (niet alle CRUD, maar ten minste Maken, Ophalen en Verwijderen) uitvoeren op onze gebruikerscollectie

Overweeg de volgende bron (hierna gebruiken we de syntaxis voor het maken van een korte array [] beschikbaar sinds versie 5.4):

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
}

dan kunnen we :

$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']));

die het volgende uitvoert, ervan uitgaande dat er geen testuser voordat we de code lanceerden:

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)

BELANGRIJK: offsetExists wordt niet aangeroepen wanneer u het bestaan van een sleutel controleert met de functie array_key_exists . De volgende code zal dus twee keer 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

Laten we onze klasse van bovenaf uitbreiden met een paar functies van de Iterator interface om het met foreach en while te herhalen.

Eerst moeten we een eigenschap toevoegen met onze huidige index van iterator, laten we deze toevoegen aan de klasse-eigenschappen als $_position :

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

Ten tweede, laten we de Iterator interface toevoegen aan de lijst met interfaces die door onze klasse worden geïmplementeerd:

class UserCollection implements ArrayAccess, Iterator {

voeg vervolgens de vereiste functies van de interface zelf toe:

// 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

Dus al met al is hier de complete bron van de klasse die beide interfaces implementeert. Merk op dat dit voorbeeld niet perfect is, omdat de ID's in de database mogelijk niet opeenvolgend zijn, maar dit is alleen geschreven om u het hoofdidee te geven: u kunt uw objectenverzamelingen op elke mogelijke manier ArrayAccess door ArrayAccess en Iterator interfaces te implementeren:

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
}

en een foreach die door alle gebruikersobjecten loopt:

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

die zoiets oplevert

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

Een reeks variabelen maken

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

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

Deze methode wordt vaak in kaders gebruikt om een reeks variabelen tussen twee componenten door te geven.