Arrayer

Här är den översatta texten till svenska, formaterad för MediaWiki-användning:

```wikitext

Arrays

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

Förklaring av dessa datastrukturer går utanför denna manuals räckvidd, men åtminstone 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

Ange med array()

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

array( nyckel => värde, nyckel2 => värde2, nyckel3 => värde3, ... ) Kommatering efter det sista arrayelementet är valfri och kan utelämnas. Detta görs vanligtvis för enradiga arrayer, dvs. array(1, 2) är att föredra framför array(1, 2, ). För flerlinjiga arrayer å andra sidan används den avslutande komman vanligtvis, eftersom det underlättar tillägg av nya element i slutet.

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

Exempel #1 En enkel array

<?php $array = array( "foo" => "bar", "bar" => "foo", ); // Använda den korta array-syntaxen $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 nyckelomvandlingar att ske: - Strängar som innehåller giltiga decimala heltal, om inte numret föregås av ett plustecken, kommer att omvandlas till heltalstyp. Ex. nyckeln "8" kommer faktiskt att lagras under 8. Å andra sidan kommer "08" inte att omvandlas, eftersom det inte är ett giltigt decimalt heltal. - Flyttal omvandlas också till heltal, vilket innebär att decimaldelen kommer att trunkeras. Ex. nyckeln 8.7 kommer faktiskt att lagras under 8. - Booler omvandlas till heltal 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 "". - Arrayer och objekt kan inte användas som nycklar. Att göra så resulterar i en varning: Illegal offset type. Om flera element i arraydeklarationen använder samma nyckel, kommer bara den senaste att användas eftersom alla andra skrivs över.

Exempel #2 Typomvandling och överlagringsexempel

<?php $array = array( 1 => "a", "1" => "b", 1.5 => "c", true => "d", ); var_dump($array); ?> Ovanstående exempel kommer att producera:

array(1) {

 [1]=>
 string(1) "d"

} Eftersom alla nycklar i exemplet ovan omvandlas till 1, kommer värdet att skrivas över för varje nytt element och det senast tilldelade värdet "d" är det enda som är kvar.

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

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 producera:

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 inkrementet av den största tidigare använda int-nyckeln.

Exempel #4 Indexerade arrayer utan nyckel

<?php $array = array("foo", "bar", "hello", "world"); var_dump($array); ?> Ovanstående exempel kommer att producera:

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 bara för vissa element och lämna den ut 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 producera:

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 överlagringsexempel

Detta exempel inkluderar alla varianter av typomvandling av nycklar och överlagring 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 heltalsträng kommer det INTE att skriva över nyckeln för 1
'1.5' => 'f', // eftersom detta inte är en heltalsträng kommer det INTE att skriva över nyckeln för 1
true => 'g', // värdet "c" kommer att skrivas över av "g"
false => 'h',
''</nowiki> => 'i',
null => 'j', // värdet "i" kommer att skrivas över av "j"
'k', // värdet "k" tilldelas nyckeln 2. Detta är för 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 producera:

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"

}

Åtkomst av arrayelement med hakparentes-syntax

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

Exempel #7 Åtkomst av 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 producera:

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

Obs:

Innan PHP 8.0.0 kunde hakparenteser och klammerparenteser användas omväxlande för åtkomst av arrayelement (t.ex. $array[42] och $array{42} skulle göra samma sak i exemplet ovan). Klammerparentessyntaxen blev inaktuell 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-dereferens

<?php

function getArray() {

return array(1, 2, 3);

}

$secondElement = getArray()[1];

?>

Obs:

Att försöka åtkomst en arraynyckel som inte har definierats är detsamma som att åtkomst vilken annan odefinierad variabel som helst: ett felmeddelande på E_WARNING-nivå (E_NOTICE-nivå före PHP 8.0.0) kommer att utfärdas, och resultatet blir null.

Obs:

Array-dereferens av ett skalärt värde som inte är en sträng ger null. Före PHP 7.4.0 utfärdades inget 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 hakparentes-syntax

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

Detta görs genom att tilldela värden till arrayen, med angivande av 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 inte finns ännu eller är inställt på null eller false, kommer den 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. sträng från en förfrågningsvariabel) så kommer detta värde att stanna på platsen och [] kan faktiskt stå för en strängåtkomstoperator. Det är alltid bättre att initiera en variabel genom en direkt tilldelning.

Obs: Från och med PHP 7.1.0 leder tillämpning av tomindexoperatören på en sträng till ett fatalt fel. Tidigare omvandlades strängen tyst till en array.

Obs: Från och med PHP 8.1.0 är det föråldrat att skapa en ny array från false-värdet. 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 hjälp av 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 till

// arrayen med nyckel "x"

unset($arr[5]); // Detta tar bort elementet från arrayen

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

?>

Obs:

Som nämnts ovan, om ingen nyckel anges, tas maximum av de befintliga int-indexen, och den nya nyckeln blir det maximala värdet plus 1 (men åtminstone 0). Om inga int-index finns ännu kommer nyckeln att vara 0 (noll).

Observera att det maximala heltalsnyckeln som används för detta behöver inte för närvarande finnas i arrayen. Det behöver bara ha funnits i arrayen vid någon tidpunkt sedan arrayen senast indexerades om. Följande exempel illustrerar:

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

// Radera nu varje objekt, men lämna själva arrayen intakt: foreach ($array as $i => $value) { unset($array[$i]); } print_r($array);

// Lägg till ett objekt (observera 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 producera:

Array

(

   [0] => 1
   [1] => 2
   [2] => 3
   [3] => 4
   [4] => 5

)

Array()

Array (

   [5] => 6

)

Array(

   [0] => 6
   [1] => 7

)

Array-destrukturering

Arrayer kan destruktureras med konstruktionerna [] (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 $käll_array = ['foo', 'bar', 'baz']; [$foo, $bar, $baz] = $käll_array; echo $foo; // skriver ut "foo" echo $bar; // skriver ut "bar" echo $baz; // skriver ut "baz" ?> Array-destrukturering kan användas i foreach för att destrukturera en flerdimensionell array medan den itereras över.

<?php $käll_array = [ [1, 'John'], [2, 'Jane'], ]; foreach ($käll_array as [$id, $name]) { // logik här med $id och $name } ?> Arrayelement kommer att ignoreras om variabeln inte tillhandahålls. Array-destrukturering börjar alltid vid index 0.

<?php $käll_array = ['foo', 'bar', 'baz']; // Tilldela elementet vid index 2 till variabeln $baz [, , $baz] = $käll_array; echo $baz; // skriver ut "baz" ?> Från och med PHP 7.1.0 kan associativa arrayer också destruktureras. Detta gör det också lättare att välja rätt element i numeriskt indexerade arrayer eftersom indexet kan anges explicit.

<?php $käll_array = ['foo' => 1, 'bar' => 2, 'baz' => 3]; // Tilldela elementet vid index 'baz' till variabeln $three ['baz' => $three] = $käll_array; echo $three; // skriver ut 3 $käll_array = ['foo', 'bar', 'baz']; // Tilldela elementet vid index 2 till variabeln $baz [2 => $baz] = $käll_array; echo $baz; // skriver ut "baz" ?> Array-destrukturering 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 ?> Obs:

Spridningsoperatören (...) stöds inte i tilldelningar.

Obs:

Att försöka åtkomst en arraynyckel som inte har definierats är detsamma som att åtkomst vilken annan odefinierad variabel som helst: ett felmeddelande på E

_WARNING-nivå (E_NOTICE-nivå före PHP 8.0.0) kommer att utfärdas, och resultatet blir null.

Användbara funktioner

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

Obs:

Unset()

funktionen gör det möjligt att ta bort nycklar från en array. Observera att arrayen inte kommer att omindexeras. Om ett verkligt "ta bort och skifta"-beteende önskas, kan arrayen omindexeras med hjälp av array_values()-funktionen.

<?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 arrayer. Den ger ett enkelt sätt att traversera en array.

Array gör och inte gör

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' - märk 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 med namnet 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 fel på E_NOTICE-nivå. Detta har avskaffats från och med PHP 7.2.0 och utfärdar ett fel på E_WARNING-nivå. Från och med PHP 8.0.0 har det tagits bort och kastar ett Error-undantag.

Obs: Detta innebär inte att alltid citera nyckeln. 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 producera:

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('fruit' => 'apple', 'veggie' => 'carrot'); // Korrekt print $arr['fruit']; // apple print $arr['veggie']; // morot // Felaktigt. Detta fungerar men kastar också ett PHP-fel på E_NOTICE-nivå på grund av // en odefinierad konstant med namnet fruit // // Notice: Use of undefined constant fruit - assumed 'fruit' in... print $arr[fruit]; // apple // Detta definierar en konstant för att demonstrera vad som händer. Värdet 'veggie' // tilldelas en konstant med namnet fruit. define('fruit', 'veggie'); // Observera skillnaden nu print $arr['fruit']; // apple print $arr[fruit]; // morot // Följande är okej, eftersom det är inuti en sträng. Konstanter söks inte efter // inom strängar, så inget E_NOTICE uppstår här print "Hello $arr[fruit]"; // Hello apple // Med ett undantag: klammerparenteser runt arrayer inom strängar gör att konstanter // kan tolkas print "Hello {$arr[fruit]}"; // Hello morot print "Hello {$arr['fruit']}"; // Hello apple // Detta fungerar inte och kommer att resultera i ett tolkningsfel, såsom: // Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING' // Detta gäller naturligtvis också för användning av 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 den på E_ALL, till exempel), blir sådana användningar 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. Detta innebär 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 ett informellt meddelande"; ?> Observera att E_ERROR också är ett giltigt identifierare, precis som bar i det första exemplet. Men det senaste 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 ett informellt meddelande"; ?> eftersom E_ERROR motsvarar 1, etc.

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

Obs: 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, sträng, bool och resurs 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 ett '*' 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());
?>
</nowiki>
Ovanstående exempel kommer att producera:

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)
Dessa NUL kan resultera i något oväntat beteende:

<pre>
<?php

class A {
    private $A; // Detta blir '\0A\0A'
}

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

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

Ovanstående exempel kommer att producera:

array(3) {
  ["\0B\0A"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

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

Konvertera null till en array resulterar i en tom array.

Jämföra

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

Array-uppackning

En array föregången av ... kommer att expanderas på plats under arraydefinitionen. Endast arrayer och objekt som implementerar Traversable kan expanderas. Array-uppackning 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 ...-operatören:

Exempel #9 Enkel array-uppackning

<?php

// Använda 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']

?>

Uppackning av en array med ...-operatören följer semantiken för array_merge()-funktionen. Det vill säga, senare strängnycklar skriver över tidigare och heltalnycklar omnumreras:

Exempel #10 Array-uppackning 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 behållits.
?>

Obs:

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

Obs:

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

<?php
$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5

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

Exempel

Array-typen i PHP är mycket mångsidig. Här är några exempel:

<?php
// Detta:
$a = array( 'color' => 'red',
            'taste' => 'sweet',
            'shape' => 'round',
            'name'  => 'apple',
            4        // nyckeln blir 0
          );

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

// . . .är helt ekvivalent med detta:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // nyckeln blir 0

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

// Efter att ovanstående kod har utförts, kommer $a att vara arrayen
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
// 'name' => 'apple', 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 (egendoms-)karta

$map = array( 'version'    => 4,
'OS'         => 'Linux',
'lang'       => 'english',
'short_tags' => true
);

// 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
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as $color) {
echo "Do you like $color?\n";
}

?>

Ovanstående exempel kommer att producera:

Do you like red? Do you like blue? Do you like green? Do you like yellow?

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

Exempel #13 Ändra element i loopen

<?php

foreach ($colors as &$color) {

$color = mb_strtoupper($color);

}

unset($color); /* säkerställ att följande skrivningar till

$color inte kommer att modifiera det sista arrayelementet */

print_r($colors);

?>

Ovanstående exempel kommer att producera:

Array
(
    [0] => RED
    [1] => BLUE
    [2] =>

 GREEN
    [3] => YELLOW
)

Detta exempel skapar en ett-baserad array.

Exempel #14 En-baserad index

<?php $firstquarter = array(1 => 'January', 'February', 'March'); print_r($firstquarter); ?> Ovanstående exempel kommer att producera:

Array (

   [1] => 'January'
   [2] => 'February'
   [3] => 'March'

)

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); ?> Arrayer ä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 arrayer.

Exempel #17 Rekursiva och flerdimensionella arrayer

<?php $fruits = array ( "fruits" => array ( "a" => "orange", "b" => "banana", "c" => "apple" ),"numbers" => array ( 1, 2,3,4,5,6), "holes" => array ( "first", 5 => "second", "third" ) );

// Några exempel för att adressera värden i arrayen ovan

echo $fruits["holes"][5]; // skriver ut "second" echo $fruits["fruits"]["a"]; // skriver ut "orange" unset($fruits["holes"][0]); // ta bort "first"

// Skapa en ny flerdimensionell array

$juices["apple"]["green"] = "good";

?>

Array-tilldelning innebär alltid värdkopiering. Använd referensoperatören för att kopiera en array som 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 densamma
?>

PHP

Språkreferens

https://www.php.net/manual/en/language.types.array.php