array_flip

Wisselt array-indexen en -waarden om.
Syntaxis:

Array array_flip(array arr)

Deze functie "loopt" door een array en verwisselt de sleutels en waarden ervan. De oorspronkelijke array arr wordt niet gewijzigd en de resulterende array wordt eenvoudigweg geretourneerd. Als er meerdere elementen in de array aanwezig zijn met dezelfde waarden, wordt alleen met de laatste rekening gehouden.

De waarden in de arr-array moeten gehele getallen of tekenreekswaarden zijn. Anders wordt het sleutel/waarde-paar niet verwerkt.

De functie array_flip() retourneert FALSE als het verwerken van de array een fout veroorzaakt.

$trans = array_flip($trans);
$origineel = strtr ($str, $trans);

Een voorbeeld van het gebruik van de functie array_flip():

Een waarde meerdere keren herhalen
1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);

Array(
=> b
=>c
)

array_change_key_case

De functie stelt de arraysleutelwaarden in op hoofdletters of kleine letters.
Syntaxis:

Array array_change_key_case(array arr[, int registr])

De functie array_change_key_case() retourneert de oorspronkelijke array arr waarbij de sleutels zijn omgezet in hoofdletters of kleine letters.
Het optionele parameterregister kan de volgende waarden aannemen:
CASE_LOWER - alle arraysleutels worden geconverteerd naar kleine letters (standaardwaarde);
CASE_UPPER - naar hoofdletters.
Met deze functie worden toetsen die uit cijfers bestaan ​​niet gewijzigd.
Voorbeeld van het gebruik van de functie array_change_key_case():

$array = array("Eerste" => 1, "Tweede" => 4);
print_r(array_change_key_case($array, CASE_UPPER));
print_r(array_change_key_case($array, CASE_LOWER));

Het voorbeeld levert het volgende op:

Array(
=> 1
=> 2
Array(
=> 1
=> 2
)

Functie ondersteund door PHP 4 >= 4.2.0, PHP 5

array_combine

De functie combineert twee arrays, waarbij de waarden van de eerste de sleutels worden, en de waarden van de tweede de waarden.
Syntaxis:

Array array_combine(arraysleutels, arraywaarden)

De functie array_combine() retourneert een array waarvan de sleutels de waarden zijn van de sleutelsarray en waarvan de waarden de waarden zijn van de waardenarray.
De functie retourneert FALSE als de afmetingen van de sleutels en waardenarrays niet overeenkomen, of als deze arrays geen waarden bevatten.
Een voorbeeld van het gebruik van de functie array_combine():

$b = array("avocado", "appel", "banaan");
$c = array_combine($a, $b);

print_r($c);
?>

Het voorbeeld levert het volgende op:

Array(
=> avocado
=> appel
=> banaan
)

Functie ondersteund door PHP 5

array_key_bestaat

Het controleren van het bestaan ​​van een bepaalde sleutel in een array.
Syntaxis:

Bool array_key_exists (gemengde sleutel, array-zoekopdracht)

De functie array_key_exists() retourneert TRUE als de zoekarray een element met een indexsleutel bevat.
Anders wordt FALSE geretourneerd.

Een voorbeeld van het gebruik van de functie array_key_exists():

1, "tweede" => 4);
if (array_key_exists("eerste", $search_array)) (
echo "De Eerst element bevindt zich in de array";
}
?>

In PHP 4.0.6. De naam van deze functie is key_exists().

Functie ondersteund door PHP 4 >= 4.0.1, PHP 5

array_product()

Bereken het product van arraywaarden (PHP 5 >= 5.1.0RC1)

Beschrijving:

Nummer array_product (matrixarray)

array_product() retourneert het product van de arraywaarden als een geheel getal of drijvende-kommagetal.

Voorbeeld van het gebruik van array_product()

$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\N";

Het resultaat van het uitvoeren van dit voorbeeld:

Product(a) = 384

array_reduce()

Reduceer een array iteratief tot één enkele waarde met behulp van een callback-functie (PHP 4 >= 4.0.5, PHP 5)

Beschrijving:

Gemengde array_reduce (array-invoer, callback-functie [, int initial])

array_reduce() past iteratief de functie toe op de elementen van de invoerarray en reduceert zo de array tot één enkele waarde. Als de optionele initiële parameter is opgegeven, wordt deze aan het begin van het proces gebruikt, of als eindresultaat als de array leeg is.

Voorbeeld van het gebruik van array_reduce()

functie rsum($v, $w)
{
$v += $w;
retourneer $v;
}

functie rmul($v, $w)
{
$v *= $w;
retourneer $v;
}

$a = array(1, 2, 3, 4, 5);
$x = array();
$b = array_reduce($a, "rsum");
$c = array_reduce($a, "rmul", 10);
$d = array_reduce($x, "rsum", 1);
?>

Het resultaat is dat $b 15 bevat, $c 1200 (= 1*2*3*4*5*10) en $d 1 bevat.

array_walk_recursive()

Pas recursief een aangepaste functie toe op elk array-element (PHP 5)

Beschrijving:

Bool array_walk_recursive (array &input, callback funcname [, gemengde gebruikersdata])

Past de aangepaste functie funcname toe op elk element van de invoerarray. Deze functie verwerkt elk element van een multidimensionale array. De functie funcname heeft doorgaans twee parameters. De arraywaarde als eerste parameter en de sleutel/index als tweede. Als de optionele parameter userdata is opgegeven, wordt deze als derde parameter doorgegeven aan de funcname callback-functie.

Retourneert TRUE bij succes of FALSE bij fout.

Opmerking: Als u wilt dat funcname waarden in een array wijzigt, definieert u de eerste parameter van funcname als referentie. Vervolgens worden alle wijzigingen toegepast op de array-elementen.

Voorbeeld van het gebruik van array_walk_recursive()

$sweet = array("a" => "appel", "b" => "banaan");
$fruits = array("zoet" => $zoet, "zuur" => "citroen");

functie test_print($item, $key)
{
echo "$key bevat $item\n";
}

array_walk_recursive($fruits, "test_print");
?>

Uitvoer van het bovenstaande programma:

Een appel houdt vast
b houdt banaan vast
zuur bevat citroen

Merk op dat de "zoete" toets nooit wordt weergegeven. Er wordt geen sleutel doorgegeven die overeenkomt met een waarde van het type array.

array_keys

Retourneert een lijst met arraysleutels.
Syntaxis:

Array array_keys(array arr [,gemengde zoekwaarde])

De functie retourneert een array waarvan de waarden alle tekenreeks- en numerieke toetsen van de array arr zijn. Als de optionele parameter zoekwaarde is opgegeven, worden alleen de sleutels geretourneerd die een overeenkomstige zoekwaarde hebben.
Een voorbeeld van het gebruik van de functie array_keys():

100, "kleur" => "rood", 15);
print_r(array_keys($arr));

$arr = array("blauw", "rood", "groen", "blauw", "blauw");
print_r(array_keys($arr, "blauw"));

$array = array("color" => array("blauw", "rood", "groen"), "size" => array("klein", "medium", "groot"));
print_r(array_keys($array));
?>

Het bovenstaande voorbeeld levert het volgende op:

Array(
=> 0
=> kleur
Array(
=> 0
=> 3
=> 4
Array(
=> kleur
=> maat
)

De functie array_keys() werd geïntroduceerd in PHP 4.

Het equivalent voor PHP 3 is:

Functie array_keys ($arr, $term="") (
$t = array();
while (lijst($k,$v) = elke($arr)) (
if ($term && $v != $term) (
doorgaan;
}
$t = $k;
}
retourneer $t;
}

Functie ondersteund door PHP 4, PHP 5

array_waarden

Associatieve array-indexen verwijderen.
Syntaxis:

Array array_values(array arr)

De functie array_values() retourneert een lijst met alle waarden in de associatieve array arr. Tegelijkertijd vervangt het alle tekenreekstoetsen door numerieke toetsen.
Een voorbeeld van het gebruik van de functie array_values():

$arr = array("grootte" => "XL", "kleur" => "goud");
print_r(array_waarden($arr));

Dit voorbeeld levert het volgende op:

Array(
=>XL
=> goud
)

Functie ondersteund door PHP 4, PHP 5

in_matrix

Controleert een array op de aanwezigheid van een waarde.
Syntaxis:

Bool in_array (gemengde naald, array hooiberg [, bool strict])

De functie in_array() retourneert TRUE als de hooibergarray een element met de waarde naald bevat, en anders FALSE.
Als u de derde optionele parameter strict instelt op TRUE, zal de functie in_array() bij controle ook waardetypen vergelijken.
Opmerking: als de parameter Needle een tekenreeks is, is de vergelijking hoofdlettergevoelig.
Opmerking: in eerdere PHP-versies dan 4.2.0 kon de parameter Needle geen array zijn.
Voorbeeld van het gebruik van de functie in_array():

if (in_array("Irix", $os)) (
echo "Ik heb Irix";
}
if (in_array("mac", $os)) (
echo "Ik heb mac";
}
?>

De tweede voorwaarde zal niet werken, omdat De zoekopdracht in de array is hoofdlettergevoelig.
Het voorbeeld levert het volgende op:

Ik heb Irix

Voorbeeld van het gebruik van de functie in_array(): Gebruik van de parameter strict

if (in_array(array("p", "h"), $a)) (
echo "ph is gevonden";
}

if (in_array(array("f", "i"), $a)) (
echo "fi is gevonden";
}

if (in_array("o", $a)) (
echo "o is gevonden";
}
?>

Het voorbeeld levert het volgende op:

Ph is gevonden
o gevonden

Functie ondersteund door PHP 4, PHP 5

array_count_values

Retourneert het aantal arraywaarden.
Syntaxis:

Array array_count_values(array arr)

Deze functie telt hoe vaak elke waarde voorkomt in de array arr en retourneert een associatieve array met de sleutels -
array-elementen en waarden - het aantal herhalingen van deze elementen. Met andere woorden, de functie array_count_values().
telt de frequentie waarmee waarden in de arr-array voorkomen.
Een voorbeeld van het gebruik van de functie array_count_values():

$arr = array(1, "hallo", 1, "wereld", "hallo");
print_r(array_count_values($arr));

Het voorbeeld levert het volgende op:

Array(
=> 2
=> 2
=> 1
)

Functie ondersteund door PHP 4, PHP 5

Retourneert het aantal array-elementen.
Syntaxis:

Int groottevan(array arr)

De functie sizeof() retourneert het aantal elementen in de arr-array, vergelijkbaar met de werking van de functie count().

Retourneert het aantal elementen in een array of object.
Syntaxis:

Aantal int(gemengde var [, int-modus])

De functie count() retourneert het aantal elementen in een array of var-object. Als var een scalaire variabele is, retourneert de functie 1 als zo'n variabele bestaat, of 0 als zo'n variabele niet bestaat.
Opgemerkt moet worden dat 0 ook wordt geretourneerd als een array zonder elementen (NULL) wordt opgegeven.

Als de optionele modusparameter is opgegeven, wordt het totale aantal elementen in de array geteld. Dit kan handig zijn bij het vinden van het aantal elementen in multidimensionale arrays.
Voorbeeld van het gebruik van de functie count():

$a = 3;
$a = 5;
$resultaat = aantal($a);
// $resultaat == 3

$ b = 7;
$ b = 9;
$ b = 11;
$resultaat = aantal($b);
// $resultaat == 3;
?>

Voorbeeld van het gebruik van de functie count(): (PHP >= 4.2.0)

array("oranje", "banaan", "appel"),
"veggie" => array("wortel", "kraag", "erwt"));

// recursieve countecho-telling ($food, COUNT_RECURSIVE); // zal 8 afdrukken

// normaal countecho-aantal ($food); // zal 2 afdrukken
?>

Functie ondersteund door PHP 3, PHP 4, PHP 5

array_som

Retourneert de som van alle array-elementen.
Syntaxis:

Gemengde array_sum(array arr)

De functie array_sum() retourneert de som van alle numerieke elementen van een array. Het type getal dat wordt geretourneerd (geheel getal of float) is afhankelijk van het type waarden in de array.

Voorbeeld van het gebruik van de functie array_sum():

echo "som(a) = " . array_sum($a) . "
";

$b = array("a" => 1,2, "b" => 2,3, "c" => 3,4);
echo "som(b) = " . array_sum($b) . "
";
?>

Dit voorbeeld levert het volgende op:

Som(a) = 20
som(b) = 6,9

Functie ondersteund door PHP 4 >=4.0.4, PHP 5

array_rand

Voert een willekeurige selectie van array-indices uit.
Syntaxis:

Gemengde array_rand(array arr [, int num_req])

De functie array_rand() is handig als je één of meerdere willekeurige waarden uit een array wilt selecteren. Deze functie retourneert willekeurig geselecteerde indices van de array-elementen arr.
Het argument num_req specificeert het aantal indexen dat moet worden geretourneerd. Als één element is geselecteerd, retourneert de functie array_rand() een willekeurige sleutel als waarde.
Voorbeeld van het gebruik van de functie array_rand():

// hier hebben we de generator voor willekeurige getallen geïnitialiseerd
//$arr = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($arr, 2);
echo $arr[$rand_keys]."
";
echo $arr[$rand_keys]."
";
?>

Functie ondersteund door PHP 4, PHP 5

arrays (13)

Vanaf PHP7.3 waarmee u rechtstreeks toegang hebt tot de laatste sleutel (buitenste niveau) van de array

Dit betekent dat u de uiteindelijke sleutelwaarde kunt verkrijgen zonder:

1. het verplaatsen van de array-aanwijzer (waarvoor twee regels code nodig zijn), of
2. sorteren, omkeren, ploffen, tellen, indexeren van een reeks sleutels of andere gekkigheid

Deze functie was een welkome en welkome aanvulling op de array-functietoolriem die de prestaties verbetert, ongewenste bijwerkingen vermijdt en schone/eenvoudige/intuïtieve code biedt.

$array = ["a" => "één", "b" => "twee", "c" => "drie"]; if (!function_exists("array_key_last")) ( echo "upgrade alstublieft naar php7.3"; ) else ( echo "Eerste sleutel: ", key($array) , "\n"; echo "Laatste sleutel: ", array_key_last ($array) , "\n"; next($array); // verplaats de array-aanwijzer naar het tweede element echo "Tweede sleutel:", key($array) , "\n"; array_key_last($array)

Eerste sleutel: een Laatste sleutel: c //<-- unaffected by the pointer position, NICE! Second Key: b Last Key: c // <-- unaffected by the pointer position, NICE!

Enkele opmerkingen:

• array_key_last() is een functie die vergelijkbaar is met array_key_first() .
• Beide functies zijn "onbewuste aanwijzingen".
• Beide functies retourneren null als de array leeg is.
• De weggegooide zusterfuncties (array_value_first() en array_value_last()) zouden ook pointer-onbewuste toegang hebben geboden tot boekensteunelementen, maar ze konden blijkbaar niet genoeg stemmen krijgen om tot leven te komen.

Hier zijn enkele relevante pagina's over de nieuwe functies:

Hoe kan ik de laatste sleutel van een array verkrijgen?

De oplossing zou zijn om een ​​combinatie van eind en sleutel te gebruiken (citaten) :

• end() verplaatst de interne pointer van de array naar het laatste element en retourneert de waarde ervan.
• key() retourneert het indexelement van de huidige arraypositie.

Dus een stukje code als dit zou de oplossing moeten zijn:

$array = array("eerste" => 123, "tweede" => 456, "laatste" => 789,); einde($array); // verplaats de interne pointer naar het einde van de array $key = key($array); // haal de sleutel op van het element waarnaar wordt verwezen door de interne pointer var_dump($key);

Tekenreeks "laatste" (lengte=4)

die. de sleutel van het laatste element van mijn array.

Hierna bevindt de interne array-aanwijzer zich aan het einde van de array. Zoals vermeld in de opmerkingen, kunt u reset() op de array uitvoeren om de aanwijzer naar het begin van de array terug te brengen.

Probeer de functies array_pop en array_keys als volgt te gebruiken:

1, "twee" => 2, "drie" => 3); echo array_pop(array_keys($array)); // drukt drie af?>

Gebruik gewoon: echo $array;

Je kunt dit gebruiken:

$array = array("één" => "appel", "twee" => "oranje", "drie" => "peer"); einde($array); echosleutel($array);

Een andere oplossing is om een ​​functie te maken en deze te gebruiken:

Functie endKey($array)( end($array); return key($array); ) $array = array("one" => "appel", "twee" => "oranje", "drie" => " peer"); echo endKey($array);

Ik weet niet of het sneller zal zijn of niet, maar het is gemakkelijker om het op deze manier te doen en je vermijdt de fout door end() niet door te geven aan de functie...

het heeft alleen een variabele nodig... het maakt niet uit om nog een regel code te schrijven en deze vervolgens uit te schakelen als dat nodig is.

$array = array("eerste" => 123, "tweede" => 456, "laatste" => 789,); $sleutels = array_keys($array); $laatste = einde($sleutels);

Hoewel end() het eenvoudigste lijkt, is het niet het snelste.

Een sneller en krachtiger alternatief is array_slice()

Strike van de redactie: deze bewering is niet onderbouwd en in de commentaren is tegenbewijs aangehaald. Als er enige waarheid schuilt in de beweringen van deze poster over snelheid/efficiëntie, dan moet er een benchmarktest worden uitgevoerd.

$laatste_sleutel = sleutel(array_slice($array, -1, 1, TRUE));

$arr = array("sleutel1"=>"waarde1","sleutel2"=>"waarde2","sleutel3"=>"waarde3"); lijst($last_key) = elke(array_reverse($arr)); print $laatste_sleutel; // sleutel3

Vanaf PHP 7.3 (2018) hiervoor er is (eindelijk) een functie: http://php.net/manual/en/function.array-key-last.php

$array = ["appel"=>10,"druif"=>15,"oranje"=>20]; echo array_key_last ($array)

Ik geef de voorkeur

End(array_keys($myarr))

Ik zou ook graag een alternatieve oplossing voor dit probleem willen voorstellen.

Ervan uitgaande dat al uw sleutels numeriek zijn zonder spaties, is mijn voorkeursmethode om de array te tellen en vervolgens minus 1 vanaf die waarde (om rekening te houden met het feit dat array-sleutels beginnen bij 0.

$array = array(0=>"hond", 1=>"kat"); $lastKey = aantal($array)-1; $lastKeyValue = $array[$lastKey]; var_dump($lastKey); print_r($lastKeyValue);

Dit geeft je:

Een andere manier (hoewel in wezen gelijk aan new ArrayList(Arrays.asList(array))) is het oplossen van new ArrayList(Arrays.asList(array)) :

Collections.addAll(arraylijst, array);

Laatste update: 1/11/2015

Arrays zijn ontworpen om sets gegevens of elementen op te slaan. Elk element in de array heeft zijn eigen unieke sleutel en waarde. Laten we dus de lijst met telefoonmodellen opslaan in een array:

"; ?>

Hier wordt een array $phones gemaakt met vier elementen. Elk element in de array vertegenwoordigt een sleutelwaardepaar. Het eerste element $phones = "Nokia N9" heeft dus een sleutel - het getal 0, en een waarde - de string "Nokia N9". In dergelijke arrays worden de numerieke toetsen ook wel indexen genoemd.

U kunt de functie count() gebruiken om het aantal elementen in een array te achterhalen. En omdat de sleutels in volgorde van 0 tot 3 staan, en omdat u de grootte van de array kent, kunt u de array-elementen in een for-lus weergeven.

Om de relatie tussen de sleutels en waarden van de elementen duidelijker te maken, laten we de array afdrukken met behulp van de print_r-functie:

Print_r($telefoons);

We krijgen de volgende uitvoer:

Array ( => Nokia N9 => Samsung Galaxy ACE II => Sony Xperia Z3 => Samsung Galaxy III)

Het maken van een array zou ook gelijkwaardig zijn aan het volgende:

"; ?>

Als er geen elementsleutel is opgegeven, gebruikt PHP cijfers als sleutels. In dit geval begint de nummering van de sleutels vanaf nul en wordt elke nieuwe sleutel met één verhoogd.

Als we de sleutel van een element in een array kennen, hebben we toegang tot dit element en kunnen we de waarde ervan verkrijgen of wijzigen:

// haal het element op met sleutel 1 $myPhone = $phones; echo "$mijntelefoon
"; // een nieuwe waarde toewijzen $phones = "Samsung X650"; echo "$phones
";

Maar niet alleen gehele getallen, maar ook strings kunnen als sleutels worden gebruikt:

Dergelijke arrays worden ook wel genoemd associatief.

array-operator

Eén manier om een ​​array te maken is hierboven besproken. Maar er is er nog één, waarbij gebruik wordt gemaakt van de operator array().

De operator array() neemt een reeks elementen. Ook de sleutels worden hier niet expliciet gespecificeerd. Daarom nummert PHP elementen automatisch vanaf nul. Maar we kunnen ook voor elk element een sleutel specificeren:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); echo $telefoons["samsumg"]; ?>

Met de => bewerking kunt u een sleutel aan een specifieke waarde toewijzen.

Itereren over associatieve arrays

Hierboven hebben we gekeken hoe je een for-lus kunt gebruiken om alle elementen van een array weer te geven, waarbij de sleutels opeenvolgend worden gespecificeerd met getallen van 0 tot 3. Dit werkt echter niet met associatieve arrays. En voor hen heeft PHP een speciaal type lus - foreach...as:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); foreach($phones als $item) echo "$item
"; ?>

In een foreach-lus worden alle elementen opeenvolgend uit de array verwijderd en wordt hun waarde in de variabele geplaatst die is opgegeven na het trefwoord as. In dit geval worden alle vier de waarden uit de array $phones achtereenvolgens in de variabele $item geplaatst. Wanneer het laatste element uit de array wordt opgehaald, eindigt de lus.

Met de foreach-lus kunt u niet alleen waarden ophalen, maar ook elementsleutels:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); foreach($phones as $key=>$value) echo "$key => $value
"; ?>

Hierbij wordt bij het doorlopen van de elementen van de lus de sleutel van het element overgedragen naar de variabele $key, en wordt de waarde ervan overgedragen naar de variabele $value.

Een alternatief voor de foreach-lus is om de lijst en elke functie te gebruiken:

"iPhone5", "samsumg"=>"Samsung Galaxy III", "nokia" => "Nokia N9", "sony" => "Sony XPeria Z3"); while (list($key, $value) = every($phones)) echo "$key => $value
"; ?>

De while-lus loopt totdat elke functie false retourneert. De functie Each doorloopt alle elementen van de array $phones en retourneert deze als een array die de sleutel en waarde van het element bevat. Deze array wordt vervolgens doorgegeven aan de lijstfunctie en de arraywaarden worden toegewezen aan de variabelen tussen haakjes. Wanneer elke functie klaar is met het doorlopen van de array $phones, retourneert deze false en eindigt de while-lus.

Multidimensionale arrays

In de voorgaande voorbeelden werd alleen rekening gehouden met eendimensionale arrays, waarbij de elementwaarden getallen of tekenreeksen vertegenwoordigden. Maar in PHP kunnen arrays ook multidimensionaal zijn, dat wil zeggen arrays waarbij een element van de array zelf een array is. Laten we bijvoorbeeld een multidimensionale array maken:

array("iPhone5", "iPhone5s", "iPhone6") , "samsumg"=>array("Samsung Galaxy III", "Samsung Galaxy ACE II"), "nokia" => array("Nokia N9", "Nokia Lumia 930"), "sony" => array("Sony XPeria Z3", "Xperia Z3 Dual", "Xperia T2 Ultra")); foreach ($telefoons als $brand => $items) ( echo "

$merk

"; echo"

"; foreach ($items als $key => $value) ( ​​​echo "
• $waarde
";) echo"

"; } ?>

En bij het uitvoeren krijgen we 4 lijsten:

Om toegang te krijgen tot een bepaald element, moet u ook de sleutels tussen vierkante haakjes opgeven. Laten we bijvoorbeeld eens kijken naar het eerste element in de eerste array. Omdat de sleutel van de eerste array "apple" is en de sleutel van het eerste element in de eerste array het getal 0 is (aangezien we de sleutels niet expliciet hebben gespecificeerd):

Echo $telefoons["appel"];

Je kunt het tweede element van de derde array op een vergelijkbare manier verkrijgen:

Echo $telefoons["nokia"];

Laten we zeggen dat geneste arrays ook associatieve arrays vertegenwoordigen:

array("apple" => "iPhone5", "samsumg" => "Samsung Galaxy III", "nokia" => "Nokia N9"), "tablets" => array("lenovo" => "Lenovo IdeaTab A3500" , "samsung" => "Samsung Galaxy Tab 4", "apple" => "Apple iPad Air")); foreach ($technieken als $tovar => $items) ( echo "

$product

"; echo"

"; foreach ($items als $key => $value) ( ​​​echo "
• $sleutel: $waarde
";) echo"

"; ) // wijs een andere waarde toe aan een van de elementen $technics["phones"]["nokia"] = "Nokia Lumnia 930"; // geef deze waarde weer echo $technics["phones"]["nokia" ];?

Associatieve array– een onvervangbaar datatype dat wordt gebruikt om een ​​verzameling unieke sleutels en bijbehorende waarden te beschrijven – is een basiselement van alle programmeertalen, inclusief PHP. In feite spelen associatieve arrays zo'n belangrijke rol bij webprogrammering dat PHP ondersteuning biedt voor een verscheidenheid aan functies en eigenschappen die arrays met gegevens op elke denkbare manier kunnen manipuleren. Deze uitgebreide ondersteuning kan overweldigend zijn voor ontwikkelaars die op zoek zijn naar de meest efficiënte manieren om arrays in hun applicaties te beheren. In dit artikel geef ik je 10 tips waarmee je je gegevens op een eindeloos aantal manieren kunt opdelen, hakken en versnipperen.

1. Array-elementen toevoegen.

PHP is een zwak getypeerde taal, dat wil zeggen dat het de array of de grootte ervan niet in detail hoeft te beschrijven. In plaats daarvan kan de array tegelijkertijd worden gedeclareerd en gevuld:

$capitals = array("Alabama" => "Montgomery", "Alaska" => "Juneau", "Arizona" => "Phoenix");

Extra array-elementen kunnen op de volgende manier worden toegevoegd:

$capitals["Arkansas"] = "Kleine rots";

Als u met genummerde arrays werkt en er de voorkeur aan geeft elementen toe te voegen (aan het begin van de array) en elementen toe te voegen met behulp van een functie met een uitgebreide naam, overweeg dan de functies array_push() en array_unshift() (deze functies werken niet met associatieve arrays) .

2. Array-elementen verwijderen

Om een ​​element uit een array te verwijderen, gebruik je de unset() functie:

Unset($capitals["Californië"]);

Door met genummerde arrays te werken, heb je meer vrijheid als het gaat om het verwijderen van array-elementen. Dat wil zeggen dat u de functies array_shitt() en array_pop() kunt gebruiken om respectievelijk een element van het begin en het einde van de array te verwijderen.

3. Wissel sleutels en waarden om

Stel dat u een nieuwe array wilt maken met de naam $states, met de hoofdsteden van de staten als indexen en de staten zelf als associatieve waarden. Deze taak (het wisselen van sleutels en waarden) kan eenvoudig worden opgelost met behulp van de functie array_flip():

$capitals = array("Alabama" => "Montgomery", "Alaska" => "Juneau", "Arizona" => "Phoenix"); $states = array_flip($hoofdletters); // $states = array(// "Montgomery" => string "Alabama", // "Juneau" => string "Alaska", // "Phoenix" => string "Arizona" //);

4. Arrays samenvoegen

Laten we aannemen dat de vorige array werd gebruikt in combinatie met een webgebaseerde "flashcard"-service en dat je studenten de kans wilde geven om hun kennis niet alleen over de hoofdsteden van de wereld te testen, maar ook over de hoofdsteden van de Verenigde Staten. Je kunt een array (met hoofdletters) samenvoegen met een array (met hoofdletters van de wereld) met behulp van de functie array_merge():

$stateCapitals = array("Alabama" => "Montgomery", "Alaska" => "Juneau", "Arizona" => "Phoenix"); $countryCapitals = array ("Australië" => "Canberra", "Oostenrijk" => "Wenen", "Algerije" => "Algiers"); $capitals = array_merge($stateCapitals, $countryCapitals);

5. Arraywaarden bewerken

Stel dat de gegevens in de array mogelijk fouten bevatten die verband houden met het gebruik van hoofdletters, en u wilt deze fouten corrigeren voordat u de gegevens in de database invoert. In dit geval kunt u de functie array_map() gebruiken om een ​​callback-functie toe te passen op elk element van de array:

Functie hoofdletter($element) ( $element = strtolower($element); // Converteer alle letters naar kleine letters return ucwords($element); // Converteer het eerste teken van elk woord in de regel naar hoofdletters ) $capitals = array( "Alabama" => "montGoMEry", "Alaska" => "Juneau", "Arizona" => "phoeniX"); $capitals = array_map("capitalize", $capitals);

6. Sorteer arrays op sleutels

Flashcard-toepassingen (flashcard - een kaart met tekst en een afbeelding (gebruikt bij het onderwijzen van een vreemde taal)) maken gebruik van verschillende onderwijstechnieken, waaronder het op bepaalde manieren sorteren van kaarten, bijvoorbeeld alfabetisch. U kunt associatieve arrays sorteren op sleutels met behulp van de ksort() functie:

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); ksort($hoofdletters);

7. Randomisatie van de arrayvolgorde

Je kunt elementen in willekeurige volgorde afspelen met behulp van de shuffle() functie:

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); shuffle($hoofdletters); foreach ($hoofdletters als $k=>$v) echo "$k: $v
";

Resultaat:

Let op bij de uitgang we krijgen geen associatieve array, maar een numerieke array.

Als u, in plaats van de array willekeurig te maken, een willekeurige waarde wilt selecteren, gebruikt u de functie array_rand().

8. Bepaal of sleutels en waarden bestaan

U kunt de functie in_array() gebruiken om te bepalen of array-elementen bestaan:

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); if (in_array("Juneau", $capitals)) ( echo "Bestaat!"; ) else ( echo "Bestaat niet!"; )

De mogelijkheid om te bepalen of er arraysleutels bestaan, is minder bekend. Het wordt geïmplementeerd met behulp van de array_key_exists() functie:

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); if (array_key_exists("Alaska", $capitals)) ( echo "Sleutel bestaat!"; ) else ( echo "Sleutel bestaat niet!"; )

9. Op zoek naar een array

Mogelijk wilt u een doorzoekbare flashcardbron aanbieden, zodat gebruikers gemakkelijk de staat kunnen vinden die bij een specifieke hoofdstad hoort. Dit kan worden gedaan met behulp van de functie array_search() (deze functie zoekt in een array naar een bepaalde waarde en retourneert de bijbehorende sleutel):

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); $state = array_search("Juneau", $capitals); // $state = "Alaska"

10. Standaard PHP-bibliotheek

De PHP Standard Library (SPL) biedt ontwikkelaars een aanzienlijk aantal datastructuren, interfaces, uitzonderingen en andere functies waar PHP voorheen niet over kon bogen. Een van deze eigenschappen is de mogelijkheid om door een array te itereren met behulp van objectgeoriënteerde syntaxis.

$capitals = array("Arizona" => "Phoenix", "Alaska" => "Juneau", "Alabama" => "Montgomery"); $arrayObject = nieuw ArrayObject($hoofdletters); foreach ($arrayObject as $state => $capital) ( printf("Het kapitaal van %s is %s
", $state, $capital); ) // De hoofdstad van Arizona is Phoenix // De hoofdstad van Alaska is Juneau // De hoofdstad van Alabama is Montgomery

Dit is slechts een van de coole functies van SPL. Raadpleeg de PHP-documentatie voor meer informatie.