PHP
SPL-datastrukturer

SplFixedArray

Skillnad från PHP Array

PHPs standard Array-typ implementeras faktiskt som beställda hash-kartor, som gör att vi kan skapa matriser som består av nyckel- / värdepar där värden kan vara av valfri typ och nycklar kan vara antingen siffror eller strängar. Detta är dock inte traditionellt hur matriser skapas.

Så som du kan se från denna illustration kan en normal PHP-array ses mer som en ordnad uppsättning nyckel- / värdepar, där varje tangent kan kartlägga till valfritt värde. Lägg märke till i den här arrayen vi har nycklar som är både siffror och strängar, liksom värden av olika typer och nyckeln har ingen betydelse för elementens ordning.

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

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

Så koden ovan skulle ge oss exakt vad vi förväntar oss.

9 => foo
1 => 4.2
bar => 

Regelbundna PHP-arrayer är också dynamiska för oss. De växer och krymper när vi skjuter och pop-värden automatiskt till och från matrisen.

Men i en traditionell grupp är storleken fast och består helt och hållet av samma typ av värde. I stället för nycklar är varje värde åtkomst genom dess index, vilket kan dras av av dess offset i arrayen.

Eftersom vi skulle veta storleken på en given typ och den fasta storleken på matrisen en förskjutning är då type size * n var n representerar värdets position i arrayen. Så i exemplet ovan ger $arr[0] oss 1 , det första elementet i matrisen och $arr[1] ger oss 2 , och så vidare.

SplFixedArray begränsar dock inte värdetypen. Det begränsar bara nycklarna till nummertyper. Den har också en fast storlek.

Detta gör SplFixedArrays effektivare än vanliga PHP-arrayer på ett särskilt sätt. De är mer kompakta så de kräver mindre minne.

Instantiera matrisen

SplFixedArray implementeras som ett objekt, men det kan nås med samma bekanta syntax som du får åtkomst till en normal PHP-array eftersom de implementerar ArrayAccess gränssnittet. De implementerar också Countable och Iterator gränssnitt så att de beter sig på samma sätt som du skulle vara van vid att matriser som uppträder i PHP (dvs saker som count($arr) och foreach($arr as $k => $v) fungerar på samma sätt för SplFixedArray som de gör vanliga matriser i PHP.

SplFixedArray-konstruktören tar ett argument, vilket är storleken på matrisen.

$arr = new SplFixedArray(4);

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

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

Detta ger dig vad du kan förvänta dig.

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

Detta fungerar också som förväntat.

var_dump(count($arr));

Ger oss...

int(4)

Meddelande i SplFixedArray, till skillnad från en normal PHP-array, visar nyckeln ordningens element i vårt array, eftersom det är ett riktigt index och inte bara en karta .

Ändra storlek på matrisen

Kom bara ihåg att eftersom matrisen har en fast storlek kommer räkningen alltid att returnera samma värde. Så medan unset($arr[1]) kommer att resultera i $arr[1] === null , count($arr) fortfarande 4 .

Så för att ändra storlek på matrisen måste du setSize metoden setSize .

$arr->setSize(3);

var_dump(count($arr));

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

Nu får vi ...

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

Importera till SplFixedArray & Exportera från SplFixedArray

Du kan också importera / exportera en normal PHP-array till och från en SplFixedArray med fromArray och toArray .

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

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

1
2
3
4
5

Gå åt andra hållet.

$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