PHP
SPL-gegevensstructuren

SplFixedArray

Verschil met PHP Array

Het standaardmatrixtype van PHP is feitelijk geïmplementeerd als geordende hash-kaarten, waarmee we arrays kunnen maken die bestaan uit sleutel / waarde-paren waarbij waarden van elk type kunnen zijn en sleutels zowel getallen als strings kunnen zijn. Dit is echter niet traditioneel hoe arrays worden gemaakt.

Zoals u in deze illustratie kunt zien, kan een normale PHP-array meer worden bekeken als een geordende set sleutel / waarde-paren, waarbij elke sleutel aan elke waarde kan worden toegewezen. Merk op dat we in deze array sleutels hebben die zowel getallen als strings zijn, maar ook waarden van verschillende typen en de sleutel heeft geen invloed op de volgorde van de elementen.

$arr = [
    9     => "foo",
    1     => 4.2,
    "bar" => null,
];

foreach($arr as $key => $value) {
    echo "$key => $value\n";
}

Dus de bovenstaande code zou ons precies geven wat we zouden verwachten.

9 => foo
1 => 4.2
bar => 

Normale PHP-arrays zijn ook dynamisch van formaat voor ons. Ze groeien en krimpen als we automatisch waarden van en naar de array pushen.

In een traditionele array is de grootte echter vast en bestaat volledig uit hetzelfde type waarde. In plaats van sleutels is elke waarde ook toegang via de index, die kan worden afgeleid door de offset in de array.

Omdat we de grootte van een bepaald type en de vaste grootte van de array zouden weten, is een offset de type size * n n de positie van de waarde in de array vertegenwoordigt. Dus in het bovenstaande voorbeeld geeft $arr[0] ons 1 , het eerste element in de array en $arr[1] geeft ons 2 , enzovoort.

SplFixedArray beperkt het type waarden echter niet. Het beperkt de toetsen alleen tot nummertypen. Het heeft ook een vaste grootte.

Dit maakt SplFixedArrays op een bepaalde manier efficiënter dan normale PHP-arrays. Ze zijn compacter waardoor ze minder geheugen nodig hebben.

Instantiëren van de array

SplFixedArray is geïmplementeerd als een object, maar kan worden benaderd met dezelfde vertrouwde syntaxis die u gebruikt voor een normale PHP-array, omdat deze de ArrayAccess interface implementeren. Ze implementeren ook Countable en Iterator interfaces, zodat ze zich gedragen zoals u gewend bent dat arrays zich gedragen in PHP (dat wil zeggen dingen als count($arr) en foreach($arr as $k => $v) werken op dezelfde manier voor SplFixedArray zoals bij normale arrays in PHP.

De constructor SplFixedArray neemt één argument, namelijk de grootte van de array.

$arr = new SplFixedArray(4);

$arr[0] = "foo";
$arr[1] = "bar";
$arr[2] = "baz";

foreach($arr as $key => $value) {
    echo "$key => $value\n";
}

Dit geeft u wat u zou verwachten.

0 => foo
1 => bar
2 => baz
3 => 

Dit werkt ook zoals verwacht.

var_dump(count($arr));

Geeft ons...

int(4)

Merk op dat in SplFixedArray, in tegenstelling tot een normale PHP-array, de sleutel de volgorde van het element in onze array weergeeft, omdat het een echte index is en niet alleen een kaart .

Het formaat van de array wijzigen

Houd er rekening mee dat omdat de array een vaste grootte heeft, count altijd dezelfde waarde zal retourneren. Dus hoewel unset($arr[1]) resulteert in $arr[1] === null , blijft count($arr) nog steeds 4 .

Om het formaat van de array te wijzigen, moet u de methode setSize gebruiken.

$arr->setSize(3);

var_dump(count($arr));

foreach($arr as $key => $value) {
    echo "$key => $value\n";
}

Nu krijgen we ...

int(3)
0 => foo
1 => 
2 => baz

Importeren naar SplFixedArray & Exporteren vanuit SplFixedArray

U kunt ook een normale PHP-array in en uit een SplFixedArray importeren / exporteren met de methoden fromArray en toArray .

$array      = [1,2,3,4,5];
$fixedArray = SplFixedArray::fromArray($array);

foreach($fixedArray as $value) {
    echo $value, "\n";
}

1
2
3
4
5

De andere kant op gaan.

$fixedArray = new SplFixedArray(5);

$fixedArray[0] = 1;
$fixedArray[1] = 2;
$fixedArray[2] = 3;
$fixedArray[3] = 4;
$fixedArray[4] = 5;

$array = $fixedArray->toArray();

foreach($array as $value) {
    echo $value, "\n";
}

1
2
3
4
5