Array-type

Arrays

En array i PHP är faktiskt en ordnad mappning. En mappning är en typ som associerar värden till nycklar. Denna typ är optimerad för flera olika användningar; den kan behandlas som en array, lista (vektor), hashtabell (en implementation av en mappning), ordbok, samling, stack, kö och troligen mer. Eftersom arrayvärden kan vara andra arrays, är träd och flerdimensionella arrays också möjliga.

Förklaring av dessa datastrukturer går utöver omfattningen av denna manual, men minst ett exempel ges för var och en av dem. För mer information, se den omfattande litteraturen som finns om detta breda ämne.

Syntax

Specificera med array()

En array kan skapas med språkkonstruktionen array(). Den tar ett godtyckligt antal komma-separerade nyckel => värde-par som argument.

array(
    nyckel  => värde,
    nyckel2 => värde2,
    nyckel3 => värde3,
    ...
)

Kommat efter det sista arrayelementet är valfritt och kan utelämnas. Detta görs vanligtvis för enradiga arrays, dvs array(1, 2) är att föredra framför array(1, 2, ). För flerradiga arrays å andra sidan används det avslutande kommat ofta, eftersom det underlättar tillägg av nya element i slutet.

Notera: En kort array-syntax finns som ersätter array() med [].

Exempel #1 En enkel array

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

// Använder kort array-syntax
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>

Nyckeln kan antingen vara en int eller en sträng. Värdet kan vara av vilken typ som helst.

Dessutom kommer följande typomvandlingar att ske: Strängar som innehåller giltiga decimala heltal, om inte numret är föregånget av ett plustecken, kommer att omvandlas till typen int. T.ex. kommer nyckeln "8" faktiskt att lagras under 8. Å andra sidan kommer inte "08" att omvandlas, eftersom det inte är ett giltigt decimalt heltal. Flyttal omvandlas också till ints, vilket innebär att den fraktionella delen kommer att trunkeras. T.ex. kommer nyckeln 8.7 faktiskt att lagras under 8. Bools omvandlas till ints också, dvs nyckeln true kommer faktiskt att lagras under 1 och nyckeln false under 0. Null kommer att omvandlas till den tomma strängen, dvs nyckeln null kommer faktiskt att lagras under "". Arrays och objekt kan inte användas som nycklar. Att göra så kommer att resultera i en varning: Illegal offset type. Om flera element i arraydeklarationen använder samma nyckel, kommer endast det sista att användas eftersom alla andra skrivs över.

Exempel #2 Typomvandling och överskrivningsexempel

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

Ovanstående exempel kommer att skriva ut:

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

Eftersom alla nycklar i ovanstående exempel omvandlas till 1, kommer värdet att skrivas över vid varje nytt element och det sista tilldelade värdet "d" är det enda som är kvar.

PHP-arrays kan innehålla int och strängnycklar samtidigt eftersom PHP inte skiljer mellan indexerade och associativa arrays.

Exempel #3 Blandade int och strängnycklar

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

Ovanstående exempel kommer att skriva ut:

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

Nyckeln är valfri. Om den inte anges kommer PHP att använda ökningen av det största tidigare använda int-nyckeln.

Exempel #4 Indexerade arrays utan nyckel

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

Ovanstående exempel kommer att skriva ut:

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

Det är möjligt att ange nyckeln endast för vissa element och utelämna den för andra:

Exempel #5 Nycklar inte på alla element

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

Ovanstående exempel kommer att skriva ut:

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

Som du kan se tilldelades det sista värdet "d" nyckeln 7. Detta beror på att den största heltalsnyckeln innan det var 6.

Exempel #6 Komplex typomvandling och överskrivningsexempel

Detta exempel inkluderar alla varianter av typomvandling av nycklar och överskrivning av element.

<?php
$array = array(
    1    => 'a',
    '1'  => 'b', // värdet "a" kommer att skrivas över av "b"
    1.5  => 'c', // värdet "b" kommer att skrivas över av "c"
    -1 => 'd',
    '01'  => 'e', // eftersom detta inte är en heltalssträng kommer det INTE att överskriva nyckeln för 1
    '1.5' => 'f', // eftersom detta inte är en heltalssträng kommer det INTE att överskriva nyckeln för 1
    true => 'g', // värdet "c" kommer att skrivas över av "g"
    false => 'h',
    '' => 'i',
    null => 'j', // värdet "i" kommer att skrivas över av "j"
    'k', // värdet "k" tilldelas nyckeln 2. Detta beror på att den största heltalsnyckeln innan det var 1
    2 => 'l', // värdet "k" kommer att skrivas över av "l"
);

var_dump($array);
?>

Ovanstående exempel kommer att skriva ut:

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

Tillgång till arrayelement med hakparentessyntax

Arrayelement kan nås med syntaxen array[nyckel].

Exempel #7 Tillgång till arrayelement

<?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"]);
?>

Ovanstående exempel kommer att skriva ut:

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

Notera:

Före PHP 8.0.0 kunde hakparenteser och krullparenteser användas omväxlande för att komma åt arrayelement (t.ex. skulle $array[42] och $array{42} göra samma sak i exemplet ovan). Krullparentessyntaxen avskrevs från och med PHP 7.4.0 och stöds inte längre från och med PHP 8.0.0.

Exempel #8 Array dereferencing

<?php
function getArray() {
    return array(1, 2, 3);
}

$secondElement = getArray()[1];
?>

Notera:

Att försöka komma åt en arraynyckel som inte har definierats är detsamma som att komma åt någon annan odefinierad variabel: ett E_WARNING-nivå felmeddelande (E_NOTICE-nivå före PHP 8.0.0) kommer att utfärdas och resultatet kommer att vara null.

Notera:

Array dereferencing av ett skalärt värde som inte är en sträng ger null. Före PHP 7.4.0 utfärdades inte ett felmeddelande. Från och med PHP 7.4.0 utfärdas E_NOTICE; från och med PHP 8.0.0 utfärdas E_WARNING.

Skapa/ändra med hakparentessyntax

En befintlig array kan modifieras genom att explicit ange värden i den.

Detta görs genom att tilldela värden till arrayen och ange nyckeln inom hakparenteser. Nyckeln kan också utelämnas, vilket resulterar i ett tomt par hakparenteser ([]).

$arr[nyckel] = värde;
$arr[] = värde;
// nyckeln kan vara en int eller sträng
// värdet kan vara vilket värde som helst av vilken typ som helst

Om $arr ännu inte finns eller är inställt på null eller false, kommer det att skapas, så detta är också ett alternativt sätt att skapa en array. Denna praxis avråds dock eftersom om $arr redan innehåller något värde (t.ex. en sträng från en förfrågningsvariabel) kommer detta värde att stanna på plats och [] kan faktiskt stå för en strängåtkomstoperator. Det är alltid bättre att initiera en variabel genom en direkt tilldelning.

Notera: Från och med PHP 7.1.0 kastar tillämpning av den tomma indexoperatören på en sträng ett fatalt fel. Tidigare konverterades strängen tyst till en array.

Notera: Från och med PHP 8.1.0 är det avrått att skapa en ny array från ett falskt värde. Att skapa en ny array från null och odefinierade värden är fortfarande tillåtet.

För att ändra ett visst värde, tilldela ett nytt värde till det elementet med dess nyckel. För att ta bort ett nyckel/värde-par, anropa unset()-funktionen på det.

<?php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56;    // Detta är detsamma som $arr[13] = 56;
                // vid denna tidpunkt i skriptet

$arr["x"] = 42; // Detta lägger till ett nytt element i
                // arrayen med nyckeln "x"
                
unset($arr[5]); // Detta tar bort elementet från arrayen

unset($arr);    // Detta raderar hela arrayen
?>

Notera:

Som nämnts ovan, om ingen nyckel anges, tas maximumvärdet av de befintliga int-nycklarna, och den nya nyckeln kommer att vara det maximumvärdet plus 1 (men minst 0). Om inga int-nycklar finns ännu kommer nyckeln att vara 0 (noll).

Notera att den maximala heltalsnyckeln som används för detta behöver inte nödvändigtvis finnas i arrayen för närvarande. Den behöver bara ha funnits i arrayen någon gång sedan arrayen senast omindexerades. Följande exempel illustrerar:

<?php
// Skapa en enkel array.
$array = array(1, 2, 3, 4, 5);
print_r($array);

// Ta nu bort varje objekt, men låt arrayen själv vara intakt:
foreach ($array as $i => $value) {
    unset($array[$i]);
}
print_r($array);

// Lägg till ett objekt (notera att den nya nyckeln är 5, istället för 0).
$array[] = 6;
print_r($array);

// Omindexera:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>

Ovanstående exempel kommer att skriva ut:

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

Arraydestrukturering

Arrays kan destruktureras med språkkonstruktionerna [] (från och med PHP 7.1.0) eller list(). Dessa konstruktioner kan användas för att destrukturera en array till distinkta variabler.

<?php
$source_array = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $source_array;

echo $foo;    // skriver ut "foo"
echo $bar;    // skriver ut "bar"
echo $baz;    // skriver ut "baz"
?>

Arraydestrukturering kan användas i foreach för att destrukturera en flerdimensionell array under iteration.

<?php
$source_array = [
    [1, 'John'],
    [2, 'Jane'],
];

foreach ($source_array as [$id, $name]) {
    // logik här med $id och $name
}
?>

Arrayelement kommer att ignoreras om variabeln inte anges. Arraydestrukturering börjar alltid vid index 0.

<?php
$source_array = ['foo', 'bar', 'baz'];

// Tilldela elementet vid index 2 till variabeln $baz
[, , $baz] = $source_array;

echo $baz;    // skriver ut "baz"
?>

Från och med PHP 7.1.0 kan associativa arrays också destruktureras. Detta gör det också enklare att välja rätt element i numeriskt indexerade arrays eftersom indexet kan anges explicit.

<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];

// Tilldela elementet vid index 'baz' till variabeln $three
['baz' => $three] = $source_array;

echo $three;    // skriver ut 3

$source_array = ['foo', 'bar', 'baz'];

// Tilldela elementet vid index 2 till variabeln $baz
[2 => $baz] = $source_array;

echo $baz;    // skriver ut "baz"
?>

Arraydestrukturering kan användas för enkel byte av två variabler.

<?php
$a = 1;
$b = 2;

[$b, $a] = [$a, $b];

echo $a;    // skriver ut 2
echo $b;    // skriver ut 1
?>

Notera:

Spridningsoperatorn (...) stöds inte i tilldelningar.

Notera:

Att försöka komma åt en arraynyckel som inte har definierats är detsamma som att komma åt någon annan odefinierad variabel: ett E_WARNING-nivå felmeddelande (E_NOTICE-nivå före PHP 8.0.0) kommer att utfärdas, och resultatet kommer att vara null.

Användbara funktioner

Det finns ganska många användbara funktioner för att arbeta med arrays. Se avsnittet om arrayfunktioner.

Notera:

Unset()-funktionen tillåter borttagning av nycklar från en array. Var medveten om att arrayen inte kommer att omindexeras. Om ett verkligt "ta bort och skifta" beteende önskas, kan arrayen omindexeras med funktionen array_values().

<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* kommer att producera en array som skulle ha definierats som
   $a = array(1 => 'one', 3 => 'three');
   och INTE
   $a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// Nu är $b array(0 => 'one', 1 =>'three')
?>

Foreach-kontrollstrukturen finns specifikt för arrays. Den ger ett enkelt sätt att traversera en array.

Dos och don'ts för arrayer

Varför är $foo[bar] fel? == Använd alltid citattecken runt en strängliteral arrayindex. Till exempel är $foo['bar'] korrekt, medan $foo[bar] inte är det. Men varför? Det är vanligt att stöta på denna typ av syntax i gamla skript:

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

Detta är fel, men det fungerar. Anledningen är att denna kod har en odefinierad konstant (bar) snarare än en sträng ('bar' - observera citattecknen). Det fungerar eftersom PHP automatiskt omvandlar en bar sträng (en ociterad sträng som inte motsvarar någon känd symbol) till en sträng som innehåller den bar strängen. Till exempel, om det inte finns någon definierad konstant som heter bar, kommer PHP att ersätta in strängen 'bar' och använda den.

Varning Fallbacken för att behandla en odefinierad konstant som bar sträng utfärdar ett felmeddelande på nivå E_NOTICE. Detta har avskrivits från och med PHP 7.2.0 och utfärdar ett felmeddelande på nivå E_WARNING. Från och med PHP 8.0.0 har det tagits bort och kastar ett felundantag.

Notera: Detta betyder inte att nyckeln alltid ska citeras. Citera inte nycklar som är konstanter eller variabler, eftersom detta kommer att förhindra att PHP tolkar dem.

<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Enkel array:
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
    echo "\nChecking $i: \n";
    echo "Bad: " . $array['$i'] . "\n";
    echo "Good: " . $array[$i] . "\n";
    echo "Bad: {$array['$i']}\n";
    echo "Good: {$array[$i]}\n";
}
?>

Ovanstående exempel kommer att skriva ut:

Checking 0: 
Notice: Undefined index:  $i in /path/to/script.html on line 9
Bad: 
Good: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Bad: 
Good: 1

Checking 1: 
Notice: Undefined index:  $i in /path/to/script.html on line 9
Bad: 
Good: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Bad: 
Good: 2

Fler exempel för att demonstrera detta beteende:

<?php
// Visa alla fel
error_reporting(E_ALL);

$arr = array('frukt' => 'äpple', 'grönsak' => 'morot');

// Korrekt
print $arr['frukt'];  // äpple
print $arr['grönsak']; // morot

// Felaktigt. Detta fungerar men kastar också ett PHP-fel på nivå E_NOTICE på grund av
// en odefinierad konstant med namnet frukt
// 
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit];    // äpple

// Detta definierar en konstant för att visa vad som händer. Värdet 'grönsak'
// tilldelas en konstant som heter frukt.
define('fruit', 'veggie');

// Lägg märke till skillnaden nu
print $arr['frukt'];  // äpple
print $arr[fruit];    // morot

// Följande är okej, eftersom det är inuti en sträng. Konstanter söks inte
// inuti strängar, så inget E_NOTICE uppstår här
print "Hello $arr[fruit]";      // Hello apple

// Med ett undantag: hakparenteser som omger arrayer inuti strängar tillåter att konstanter
// tolkas
print "Hello {$arr[fruit]}";    // Hello carrot
print "Hello {$arr['fruit']}";  // Hello apple

// Detta kommer inte att fungera och kommer att resultera i ett syntaxfel, såsom:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Detta gäller naturligtvis även för att använda superglobaler i strängar
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";

// Sammansättning är ett annat alternativ
print "Hello " . $arr['fruit']; // Hello apple
?>

När error_reporting är inställt på att visa E_NOTICE-nivåfel (genom att ställa in det på E_ALL, till exempel) kommer sådana användningar att bli omedelbart synliga. Som standard är error_reporting inställt på att inte visa meddelanden.

Som anges i syntaxavsnittet måste det som är inuti hakparenteserna ('[' och ']') vara ett uttryck. Det betyder att kod som denna fungerar:

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

Detta är ett exempel på att använda ett funktionsreturvärde som arrayindex. PHP känner också till konstanter:

<?php
$error_descriptions[E_ERROR]   = "Ett fatalt fel har inträffat";
$error_descriptions[E_WARNING] = "PHP utfärdade en varning";
$error_descriptions[E_NOTICE]  = "Detta är bara en informell notis";
?>

Notera att E_ERROR också är ett giltigt identifierare, precis som bar i det första exemplet. Men det sista exemplet är i själva verket detsamma som att skriva:

<?php
$error_descriptions[1] = "Ett fatalt fel har inträffat";
$error_descriptions[2] = "PHP utfärdade en varning";
$error_descriptions[8] = "Detta är bara en informell notis";
?>

eftersom E_ERROR motsvarar 1, etc.

Så varför är det då dåligt? Vid någon tidpunkt i framtiden kan PHP-teamet vilja lägga till en annan konstant eller nyckelord, eller en konstant i annan kod kan störa. Till exempel är det redan fel att använda orden tom och standard på detta sätt, eftersom de är reserverade nyckelord.

Notera: För att upprepa, inuti en sträng med dubbla citattecken är det giltigt att inte omge arrayindex med citattecken så "$foo[bar]" är giltigt. Se ovanstående exempel för detaljer om varför samt avsnittet om variabeltolkning i strängar.

Konvertera till array

För någon av typerna int, float, string, bool och resource resulterar konvertering av ett värde till en array i en array med ett enda element med index noll och värdet av det skalära som konverterades. Med andra ord är (array)$scalarValue exakt detsamma som array($scalarValue).

Om ett objekt konverteras till en array är resultatet en array vars element är objektets egenskaper. Nycklarna är medlemsvariabelnamnen, med några anmärkningsvärda undantag: heltalsegenskaper är otillgängliga; privata variabler har klassnamnet före variabelnamnet; skyddade variabler har en '*' före variabelnamnet. Dessa föregående värden har NUL-byte på båda sidor. Oinitierade typade egenskaper ignoreras tyst.

<?php

class A {
    private $B;
    protected $C;
    public $D;
    function __construct()
    {
        $this->{1} = null;
    }
}

var_export((array) new A());
?>

Ovanstående exempel kommer att skriva ut:

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

Dessa NUL kan resultera i något oväntat beteende:

<?php

class A {
    private $A; // Detta kommer att bli '\0A\0A'
}

class B extends A {
    private $A; // Detta kommer att bli '\0B\0A'
    public $AA; // Detta kommer att bli 'AA'
}

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

Ovanstående exempel kommer att skriva ut:

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

Ovanstående verkar ha två nycklar med namnet 'AA', även om en av dem faktiskt heter '\0A\0A'.

Konvertering av null till en array resulterar i en tom array.

Jämföra

Det är möjligt att jämföra arrays med array_diff()-funktionen och med arrayoperatorer.

Arrayutpackning

En array med prefixet ... kommer att expandera på plats under arraydefinitionen. Endast arrays och objekt som implementerar Traversable kan expanderas. Arrayutpackning med ... är tillgänglig från och med PHP 7.4.0.

Det är möjligt att expandera flera gånger och lägga till normala element före eller efter ...-operatorn:

Exempel #9 Enkel arrayutpackning

<?php
// Använder kort array-syntax.
// Fungerar också med array()-syntax.
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; //[1, 2, 3]
$arr3 = [0, ...$arr1]; //[0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; //[1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; //[1, 2, 3, 1, 2, 3]

function getArr() {
  return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; //['a', 'b', 'c' => 'd']
?>

Arrayutpackning med ...-operatorn följer semantiken för array_merge()-funktionen. Det vill säga senare strängnycklar skriver över tidigare och heltalnycklar omnumreras:

Exempel #10 Arrayutpackning med duplicerad nyckel

<?php
// strängnyckel
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// heltalnyckel
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// Vilket är [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// där de ursprungliga heltalnycklarna inte har bevarats.
?>

Notera:

Nycklar som varken är heltal eller strängar kastar ett TypeError. Sådana nycklar kan endast genereras av ett Traversable-objekt.

Notera:

Före PHP 8.1 stöds inte arrayutpackning av en array som har en strängnyckel:

<?php

$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatalt fel: Oupptäckt fel: Kan inte packa upp array med strängnycklar i example.php:5

$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // fungerar. [1, 2, 3, 4, 5]
?>

Exempel

Arraytypen i PHP är mycket mångsidig. Här är några exempel:

<?php
// Detta:
$a = array( 'färg' => 'röd',
            'smak' => 'söt',
            'form' => 'rund',
            'namn'  => 'äpple',
            4        // nyckeln kommer att vara 0
          );

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

// . . .är helt ekvivalent med detta:
$a = array();
$a['färg'] = 'röd';
$a['smak'] = 'söt';
$a['form'] = 'rund';
$a['namn']  = 'äpple';
$a[]        = 4;        // nyckeln kommer att vara 0

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

// Efter att ovanstående kod har exekverats kommer $a att vara arrayen
// array('färg' => 'röd', 'smak' => 'söt', 'form' => 'rund', 
// 'namn' => 'äpple', 0 => 4), och $b kommer att vara arrayen 
// array(0 => 'a', 1 => 'b', 2 => 'c'), eller helt enkelt array('a', 'b', 'c').
?>

Exempel #11 Använda array()

<?php
// Array som (egenskaps-)karta
$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'språk'       => 'engelska',
              'korta_taggar' => sant
            );
            
// strikt numeriska nycklar
$array = array( 7,
                8,
                0,
                156,
                -10
              );
// detta är detsamma som array(0 => 7, 1 => 8, ...)

$switching = array(         10, // nyckel = 0
                    5    =>  6,
                    3    =>  7, 
                    'a'  =>  4,
                            11, // nyckel = 6 (maximum av heltal-index var 5)
                    '8'  =>  2, // nyckel = 8 (heltal!)
                    '02' => 77, // nyckel = '02'
                    0    => 12  // värdet 10 kommer att skrivas över av 12
                  );
                  
// tom array
$empty = array();         
?>

Exempel #12 Samling

<?php
$färger = array('röd', 'blå', 'grön', 'gul');

foreach ($färger as $färg) {
    echo "Gillar du $färg?\n";
}

?>

Ovanstående exempel kommer att skriva ut:

Gillar du röd?
Gillar du blå?
Gillar du grön?
Gillar du gul?

Att ändra värdena i arrayen direkt är möjligt genom att skicka dem med referens.

Exempel #13 Ändra element i loopen

<?php
foreach ($färger as &$färg) {
    $färg = mb_strtoupper($färg);
}
unset($färg); /* säkerställ att följande skrivningar till
$färg kommer inte att ändra det sista arrayelementet */

print_r($färger);
?>

Ovanstående exempel kommer att skriva ut:

Array
(
    [0] => RÖD
    [1] => BLÅ
    [2] => GRÖN
    [3] => GUL
)

Detta exempel skapar en array med ett-baserat index.

Exempel #14 Ett-baserat index

<?php
$firstquarter  = array(1 => 'januari', 'februari', 'mars');
print_r($firstquarter);
?>

Ovanstående exempel kommer att skriva ut:

Array 
(
    [1] => 'januari'
    [2] => 'februari'
    [3] => 'mars'
)

Exempel #15 Fylla en array

<?php
// fyll en array med alla objekt från en katalog
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}
closedir($handle); 
?>

Arrays är ordnade. Ordningen kan ändras med olika sorteringsfunktioner. Se avsnittet om arrayfunktioner för mer information. Funktionen count() kan användas för att räkna antalet objekt i en array.

Exempel #16 Sortera en array

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

Eftersom värdet på en array kan vara vad som helst, kan det också vara en annan array. Detta möjliggör skapandet av rekursiva och flerdimensionella arrays.

Exempel #17 Rekursiva och flerdimensionella arrays

<?php
$frukter = array ( "frukter"  => array ( "a" => "apelsin",
                                       "b" => "banan",
                                       "c" => "äpple"
                                     ),
                  "nummer" => array ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "hål"   => array (      "första",
                                       5 => "andra",
                                            "tredje"
                                     )
                );

// Några exempel för att adressera värden i ovanstående array 
echo $frukter["hål"][5];    // skriver ut "andra"
echo $frukter["frukter"]["a"]; // skriver ut "apelsin"
unset($frukter["hål"][0]);  // ta bort "första"

// Skapa en ny flerdimensionell array
$juicer["äpple"]["grön"] = "bra"; 
?>

Arraytilldelning involverar alltid värdkopiering. Använd referensoperatören för att kopiera en array med referens.

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 ändras,
             // $arr1 är fortfarande array(2, 3)
             
$arr3 = &$arr1;
$arr3[] = 4; // nu är $arr1 och $arr3 samma
?>