Hoe u een nieuwe array toevoegt aan het einde van een bestaande array. Elementen toevoegen aan een array

array_pad

Voegt verschillende elementen toe aan de array.
Syntaxis:

Array array_pad (array-invoer, int pad_size, gemengde pad_waarde)

De functie array_pad() retourneert een kopie van de invoerarray waaraan elementen met pad_values ​​zijn toegevoegd, zodat het aantal elementen in de resulterende array pad_size is.
Als pad_size>0, worden de elementen aan het einde van de array toegevoegd, en if<0 - то в начало.
Als de waarde van pad_size kleiner is dan de elementen in de originele invoerarray, zal er geen optelling plaatsvinden en retourneert de functie de originele invoerarray.
Voorbeeld van het gebruik van de functie array_pad():

$arr = array(12, 10, 4);
$resultaat = array_pad($arr, 5, 0);
// $resultaat = array(12, 10, 4, 0, 0);
$resultaat = array_pad($arr, -7, -1);
// $result = array(-1, -1, -1, -1, 12, 10, 4)
$result = array_pad($arr, 2, "noop");
// zal niet toevoegen

array_map

Pas een aangepaste functie toe op alle elementen van de opgegeven arrays.
Syntaxis:

Array array_map (gemengde callback, array arr1 [, array ...])

De functie array_map() retourneert een array die de elementen van alle opgegeven arrays bevat na verwerking door de callback-functie van de gebruiker.
Het aantal parameters dat wordt doorgegeven aan de door de gebruiker gedefinieerde functie moet overeenkomen met het aantal arrays dat wordt doorgegeven aan array_map().

Voorbeeld van het gebruik van de functie array_map(): Een enkele array verwerken

retourneer $n*$n*$n;
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("kubus", $a);
print_r($b);
?>

Array(
=> 1
=> 8
=> 27
=> 64
=> 125
)

Voorbeeld van het gebruik van de functie array_map(): Meerdere arrays verwerken

return "Het getal $n in het Spaans is $m";
}
function map_Spanish($n, $m) (
retourarray ($n => $m);
}

$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$c = array_map("show_Spanish", $a, $b);
print_r($c);

$d = array_map("map_Spanish", $a, $b);
print_r($d);
?>

Het gegeven voorbeeld levert het volgende op:

// afdruk van $cArray(
=> Nummer 1 in het Spaans - uno
=> Nummer 2 in het Spaans - dos
=> Nummer 3 in het Spaans - tres
=> Nummer 4 in het Spaans - cuatro
=> Nummer 5 in het Spaans - cinco
)

// afdruk van $dArray(
=> Array
=> uno
)

=> Array
=> doen
)

=> Array
=> tres
)

=> Array
=> cuatro
)

=> Array
=> cinco
)

Normaal gesproken wordt de functie array_map() gebruikt op arrays met dezelfde grootte. Als arrays verschillende lengtes hebben, worden de kleinere opgevuld met elementen met lege waarden.
Opgemerkt moet worden dat als u null opgeeft in plaats van de naam van de verwerkingsfunctie, er een array van arrays wordt gemaakt.
Voorbeeld van het gebruik van de functie array_map(): Een array van arrays maken

$b = array("één", "twee", "drie", "vier", "vijf");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>

Het gegeven voorbeeld levert het volgende op:

Array(
=> Array
=> 1
=> één
=> uno
)

=> Array
=> 2
=> twee
=> doen
)

=> Array
=> 3
=> drie
=> tres
)

=> Array
=> 4
=> vier
=> cuatro
)

=> Array
=> 5
=> vijf
=> cinco
)

Functie ondersteund door PHP 4 >= 4.0.6, PHP 5

array_pop

Haalt de laatste elementen van een array op en verwijdert deze.
Syntaxis:

Gemengde array_pop(array arr);

De functie array_pop() haalt het laatste element uit de array arr tevoorschijn, retourneert het en verwijdert het daarna. Met deze functie kunnen we stapelachtige structuren bouwen. Als de array arr leeg was of geen array is, retourneert de functie de lege tekenreeks NULL.

Na gebruik van de functie array_pop() wordt de arraycursor op het begin gezet.
Voorbeeld van het gebruik van de functie array_pop():

$fruit = array_pop($stack);
print_r($stack);
print_r($fruit);
?>

Het voorbeeld levert het volgende op:

Array(
=> oranje
=> banaan
=> appel
)

Functie ondersteund door PHP 4, PHP 5

array_push

Voegt een of meer elementen toe aan het einde van de array.
Syntaxis:

Int array_push(array arr, gemengde var1 [, gemengde var2, ..])

De functie array_push() voegt elementen var1, var2, etc. toe aan de array arr. Het wijst er numerieke indexen aan toe, precies zoals het doet voor standaard.
Als u slechts één element hoeft toe te voegen, is het wellicht eenvoudiger om deze operator te gebruiken:

Array_push($Arr,1000); // roep de functie$Arr=100 aan; // hetzelfde, maar korter

Voorbeeld van het gebruik van de functie array_push():

array_push($stack, "appel", "framboos");
print_r($stack);
?>

Het voorbeeld levert het volgende op:

Array(
=> oranje
=> banaan
=> appel
=> framboos
)

Houd er rekening mee dat de functie array_push() de array als een stapel behandelt en altijd elementen aan het einde toevoegt.
Functie ondersteund door PHP 4, PHP 5

array_shift

Haalt het eerste element van een array op en verwijdert het.
Syntaxis:

Gemengde array_shift(array arr)

De functie array_shift() neemt het eerste element van de array arr en retourneert dit. Het lijkt erg op array_pop(),
maar het ontvangt alleen het initiële element, niet het laatste element, en produceert ook een vrij sterke "opschudding" van de hele array: bij het extraheren van het eerste element moet je immers alle numerieke indices van alle resterende elementen aanpassen, omdat alle volgende elementen van de array worden één positie naar voren verschoven. De stringarraysleutels worden niet gewijzigd.
Als arr leeg is of geen array is, retourneert de functie NULL.

Na gebruik van deze functie wordt de array-aanwijzer naar het begin verplaatst.
Voorbeeld van het gebruik van de functie array_shift():

$fruit = array_shift($stack);
print_r($stack);
?>

Dit voorbeeld levert het volgende op:

Array(
=> banaan
=> appel
=> framboos
)

en de variabele $fruit heeft de waarde "oranje"

Functie ondersteund door PHP 4, PHP 5

array_unshift

Voegt een of meer waarden toe aan het begin van de array.
Syntaxis:

Int array_unshift(lijst arr, gemengde var1 [,gemengde var2, ...])

De functie array_unshift() voegt de doorgegeven var-waarden toe aan het begin van de arr-array. De volgorde van nieuwe elementen in de array blijft behouden. Alle digitale indexen van de array worden gewijzigd zodat deze vanaf nul beginnen. Alle stringindexen van de array blijven ongewijzigd.
De functie retourneert het nieuwe aantal elementen in de array.
Een voorbeeld van het gebruik van de functie array_unshift():

array_unshift($queue, "appel", "framboos");
?>

Nu heeft de variabele $queue de volgende elementen:

Array(
=> appel
=> framboos
=> oranje
=> banaan
)

Functie ondersteund door PHP 4, PHP 5

array_uniek

Verwijdert dubbele waarden in een array.
Syntaxis:

Array array_unique(array arr)

De functie array_unique() retourneert een array die is samengesteld uit alle unieke waarden in de array arr samen met hun sleutels, door alle dubbele waarden te verwijderen. De eerste sleutel=>waardeparen die worden aangetroffen, worden in de resulterende array geplaatst. De indexen blijven behouden.
Een voorbeeld van het gebruik van de functie array_unique():

"groen", "rood", "b" =>
"groen", "blauw", "rood");

print_r($resultaat);
?>

Het voorbeeld levert het volgende op:

Array(
[a] => groen
=> rood
=> blauw
)

Voorbeeld van het gebruik van de functie array_unique(): Gegevenstypen vergelijken

$resultaat = array_unique($input);
var_dump($resultaat);
?>

Het voorbeeld levert het volgende op:

Array(2) (
=> int(4)
=> tekenreeks(1) "3"
}

Functie ondersteund door PHP 4 >= 4.0.1, PHP 5

array_chunk

De functie splitst de array in delen.
Syntaxis:

Array array_chunk(array arr, int-grootte [, bool bewaarsleutels])

De functie array_chunk() splitst de oorspronkelijke array arr in verschillende arrays, waarvan de lengte wordt gespecificeerd door de getalgrootte. Als de afmeting van de oorspronkelijke array niet precies deelbaar is door de grootte van de onderdelen, zal de uiteindelijke array een kleinere afmeting hebben.
De functie array_chunk() retourneert een multidimensionale array, waarvan de indices beginnen van 0 tot het aantal resulterende arrays, en de waarden zijn de arrays die zijn verkregen als gevolg van het splitsen.
De optionele parameter 'conserv_keys' specificeert of de sleutels van de originele array behouden moeten blijven of niet. Als deze parameter onwaar is (de standaardwaarde), worden de indices van de resulterende arrays gespecificeerd met getallen beginnend bij nul. Als de parameter waar is, blijven de sleutels van de oorspronkelijke array behouden.
Voorbeeld van het gebruik van de functie array_chunk():

$array = array("1e element",
"2e element"
"3e element"
"4e element"
"5e element");
print_r(array_chunk($array, 2));
print_r(array_chunk($array, 2, TRUE));

Het voorbeeld levert het volgende op:

Array(
=> Array
=> 1e element
=> 2e element
)

=> Array
=> 3e element
=> 4e element
)

=> Array
=> 5e element
)

)
Array(
=> Array
=> 1e element
=> 2e element
)

=> Array
=> 3e element
=> 4e element
)

=> Array
=> 5e element
)

Functie ondersteund door PHP 4 >= 4.2.0, PHP 5

array_fill

De functie vult de array met specifieke waarden.
Syntaxis:

Array array_fill(int start_index, int num, gemengde waarde)

De functie array_fill() retourneert een array met de waarden die zijn opgegeven in de waardeparameter size num, te beginnen met het element dat is opgegeven in de parameter start_index.
Voorbeeld van het gebruik van array_diff_uassoc():

print_r($a);
?>

Het voorbeeld levert het volgende op:

Array(
=> banaan
=> banaan
=> banaan
=> banaan
=> banaan
=> banaan
)

Functie ondersteund door PHP 4 >= 4.2.0, PHP 5

array_filter

De functie past een filter toe op een array met behulp van een aangepaste functie.
Syntaxis:

Array array_filter (array-invoer [, callback callback])

De functie array_filter() retourneert een array die de waarden bevat die aanwezig zijn in de invoerarray, gefilterd op basis van de resultaten van de callback-functie van de gebruiker.
Als de invoerarray een associatieve array is, blijven de indices behouden in de resulterende array.
Voorbeeld van het gebruik van de functie array_filter():

rendement ($var % 2 == 1);
}

functie even($var) (
rendement ($var % 2 == 0);
}

$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
echo "Oneven:n";
print_r(array_filter($array1, "oneven"));
echo "Even:n";
t_r(array_filter($array2, "even"));
?>

Het voorbeeld levert het volgende op:

Oneven:Matrix(
[een] => 1
[c] => 3
[e] => 5
Zelfs:Array(
=> 6
=> 8
=> 10
=> 12
)

Het is vermeldenswaard dat u in plaats van de naam van de filterfunctie een array kunt opgeven die een verwijzing naar het object en de naam van de methode bevat.
Het is ook vermeldenswaard dat bij het verwerken van een array met de functie array_filter() deze niet kan worden gewijzigd: elementen toevoegen, verwijderen of de array opnieuw instellen, omdat dit kan leiden tot een onjuiste werking van de functie.
Functie ondersteund door PHP 4 >= 4.0.6, PHP 5

PHP Ondersteunt scalaire en samengestelde gegevenstypen. In dit artikel bespreken we een van de samengestelde typen: arrays. Een array is een verzameling gegevenswaarden, georganiseerd als een geordende set sleutel-waardeparen.

In dit artikel wordt gesproken over het maken van een array, het toevoegen van elementen aan een array. Er zijn veel ingebouwde functies die met arrays werken PHP omdat arrays gebruikelijk en nuttig zijn om te gebruiken. Als u bijvoorbeeld een e-mail naar meer dan één e-mailadres wilt verzenden, kunt u de e-mailadressen in een array opslaan en vervolgens door de array doorlopen, waarbij u berichten verzendt naar het e-mailadres uit de array.

Geïndexeerde en associatieve arrays

Er zijn twee soorten arrays in PHP: index en associatief. De sleutels van een geïndexeerde array zijn gehele getallen, beginnend bij 0. Geïndexeerde arrays worden gebruikt wanneer u een specifieke positie in de array nodig heeft. Associatieve arrays gedragen zich als twee kolommen van een tabel. De eerste kolom is de sleutel die wordt gebruikt om toegang te krijgen tot de waarde (de tweede kolom).

PHP slaat intern alle arrays op als associatieve arrays, dus het enige verschil tussen associatieve en geïndexeerde arrays is dat de sleutels verschijnen. Sommige functies zijn voornamelijk bedoeld voor gebruik met geïndexeerde arrays, omdat ze ervan uitgaan dat uw sleutels opeenvolgende gehele getallen zijn, beginnend bij 0. In beide gevallen zijn de sleutels uniek, dat wil zeggen dat u niet twee elementen met dezelfde sleutel kunt hebben, ongeacht of de sleutel is een string of een geheel getal.

IN PHP arrays hebben een interne volgorde van hun elementen die onafhankelijk is van sleutels en waarden, en er zijn functies die kunnen worden gebruikt om arrays te doorlopen op basis van deze interne volgorde.

Elementen in een array definiëren

U kunt toegang krijgen tot specifieke waarden uit een array door de arraynaam te gebruiken, gevolgd door de elementsleutel (ook wel index genoemd) tussen vierkante haken:

$leeftijd["Fred"]; $shows;

De sleutel kan een string of een geheel getal zijn. Tekenreekswaarden als getallen (zonder voorloopnullen) worden behandeld als gehele getallen. Dus, $matrix En $matrix['3'] verwijzen naar hetzelfde element, maar $matrix[’03’] verwijst naar een ander element. Negatieve getallen kunnen ook als sleutels worden gebruikt, maar ze specificeren geen posities vanaf het einde van de array, zoals in Perl.

Het is niet nodig om de sleutel tussen aanhalingstekens te schrijven. Bijvoorbeeld, $array['Fred'] leuk vinden $arrat. Het wordt echter als een goede stijl beschouwd PHP gebruik altijd aanhalingstekens. Als de index zonder aanhalingstekens staat, gebruikt PHP de waarde van de constante als index:

Definieer("index",5); echo $array; // retourneert $array, niet $array["index"];

Als u een getal in de index wilt vervangen, gaat u als volgt te werk:

$leeftijd["Kloon$nummer"]; // retourneert bijvoorbeeld $age["Clone5"];

In het volgende geval mag u de sleutel echter niet citeren:

// onjuiste afdruk "Hallo, $person["naam"]"; print "Hallo, $persoon["naam"]"; // correcte afdruk "Hallo, $person";

Gegevens opslaan in arrays

Wanneer u een waarde in een array probeert op te slaan, wordt de array automatisch gemaakt als deze nog niet eerder bestond, maar wanneer u probeert een waarde op te halen uit een array die niet is gedefinieerd, wordt de array niet gemaakt. Bijvoorbeeld:

// $addresses is tot nu toe niet gedefinieerd echo $addresses; // niets echo $addresses; // niets $addresses = " [e-mailadres beveiligd]"; echo $adressen; // print "Array"

U kunt een eenvoudige opdracht gebruiken om een ​​array in een programma te initialiseren:

$adressen = " [e-mailadres beveiligd]"; $adressen = " [e-mailadres beveiligd]"; $adressen = " [e-mailadres beveiligd]"; // ...

We hebben een indexarray gedeclareerd met gehele indices die beginnen bij 0.

Associatieve array:

$prijs["Pakking"] = 15,29; $prijs["Wiel"] = 75,25; $prijs["Band"] = 50,00; // ...

Een eenvoudigere manier om een ​​array te initialiseren is door de constructie te gebruiken Array(), die een array bouwt op basis van zijn argumenten:

$adressen = array(" [e-mailadres beveiligd]", "[e-mailadres beveiligd]", "[e-mailadres beveiligd]");

Om een ​​associatieve array te maken met behulp van Array(), gebruik => symbool dat indices scheidt van waarden:

$price = array("Pakking" => 15,29, "Wiel" => 75,25, "Band" => 50,00);

Let op het gebruik van spaties en uitlijning. We zouden de code kunnen groeperen, maar het zou minder duidelijk zijn:

$price = array("Pakking"=>15,29,"Wiel"=>75,25,"Band"=>50,00);

Om een ​​lege array te maken, moet je de constructie aanroepen Array() zonder argumenten:

$adressen = Array();

U kunt een startsleutel in een array opgeven en vervolgens een lijst met waarden. Waarden worden in de array ingevoerd, beginnend met de sleutel en vervolgens oplopend:

$days = array(1 => "maandag", "dinsdag", "woensdag", "donderdag", "vrijdag", "zaterdag", "zondag"); // 2 is dinsdag, 3 is woensdag, enz.

Als de startindex een string is, worden de daaropvolgende indexen gehele getallen, beginnend bij 0. De volgende code is dus waarschijnlijk een fout:

$whoops = array("Vrijdag" => "Zwart", "Bruin", "Groen"); // hetzelfde als $whoops = array("Vrijdag" => "Zwart", 0 => "Bruin", 1 => "Groen");

Een nieuw element toevoegen aan het einde van een array

Om meerdere waarden aan het einde van een bestaande geïndexeerde array in te voegen, gebruikt u de syntaxis:

$family = array("Fred", "Wilma"); // $family = "Fred" $family = "Kiezels"; // $family = "Kiezels"

Deze constructie gaat ervan uit dat array-indices getallen zijn en wijst het element de volgende beschikbare numerieke index toe, beginnend bij 0. Een element proberen toe te voegen aan een associatieve array is bijna altijd een programmeerfout, maar PHP zal nieuwe elementen toevoegen met numerieke indexen (beginnend bij 0) zonder een waarschuwing te geven:

$person = array("naam" => "Fred"); // $person["naam"] = "Fred"; $persoon = "Wilma"; // $person = "Wilma"

In deze fase ronden we het inleidende deel van het werken met arrays in PHP af. Ik zie je graag terug in het volgende artikel.

Er zijn veel functies en operatoren voor het converteren van arrays in PHP: Verzameling van functies voor het werken met arrays

Er zijn verschillende manieren om een ​​array aan een array toe te voegen met behulp van PHP en ze kunnen allemaal nuttig zijn in bepaalde gevallen.

"Bediener +"

Dit is een eenvoudige maar verraderlijke manier:

$c = $a + $b

Op deze manier worden alleen die sleutels toegevoegd die nog niet in de $a array staan. In dit geval worden de elementen aan het einde van de array toegevoegd.

Dat wil zeggen, als de sleutel uit de array $b niet aanwezig is in de array $a, dan wordt een element met deze sleutel toegevoegd aan de resulterende array.
Als de array $a al een element met een dergelijke sleutel bevat, blijft de waarde ervan ongewijzigd.

Met andere woorden, het veranderen van de plaats van de termen verandert de som: $a + $b != $b + $a - dit is de moeite waard om te onthouden.

Hier is een gedetailleerder voorbeeld om dit te illustreren:

$arr1 = ["a" => 1, "b" => 2]; $arr2 = ["b" => 3, "c" => 4]; var_export($arr1 + $arr2); //array (// "a" => 1, // "b" => 2, // "c" => 4, //) var_export($arr2 + $arr1); //matrix (// "b" => 3, // "c" => 4, // "a" => 1, //)

array_merge() functie

U kunt deze functie als volgt gebruiken:

$resultaat = array_merge($arr1, $arr2)

Het reset numerieke indexen en vervangt stringindexen. Ideaal voor het aaneenschakelen van twee of meer arrays met numerieke indexen:

Als de invoerarrays dezelfde tekenreekssleutels hebben, vervangt elke volgende waarde de vorige. Als de arrays echter dezelfde numerieke toetsen hebben, zal de laatst genoemde waarde niet de oorspronkelijke waarde vervangen, maar aan het einde van de array worden toegevoegd.

array_merge_recursieve functie

Doet hetzelfde als array_merge, behalve dat het recursief door elke tak van de array gaat en hetzelfde doet met de kinderen.

array_replace() functie

Vervangt array-elementen door elementen van andere doorgegeven arrays.

array_replace_recursive() functie

Hetzelfde als array_replace, maar verwerkt alle takken van de array.

Elementen toevoegen aan een array

Als de array bestaat, kunt u er extra elementen aan toevoegen.

Dit gebeurt rechtstreeks met behulp van de toewijzingsoperator (gelijkteken) op dezelfde manier als het toekennen van een waarde aan een tekenreeks of getal. In dit geval hoeft u de sleutel van het toegevoegde element niet op te geven, maar zijn in ieder geval vierkante haakjes vereist bij toegang tot de array. Door twee nieuwe elementen aan $List toe te voegen, schrijven we:
$Lijst = "peren";

$Lijst = "tomaten";

Dit gebeurt rechtstreeks met behulp van de toewijzingsoperator (gelijkteken) op dezelfde manier als het toekennen van een waarde aan een tekenreeks of getal. In dit geval hoeft u de sleutel van het toegevoegde element niet op te geven, maar zijn in ieder geval vierkante haakjes vereist bij toegang tot de array. Door twee nieuwe elementen aan $List toe te voegen, schrijven we:
$Lijst = "peren";

Nu is de waarde van het element met index 4 “tomaten”, en het element “sinaasappelen” is er niet meer. Ik zou adviseren om geen sleutel op te geven bij het toevoegen van elementen aan een array, tenzij je specifiek bestaande gegevens wilt overschrijven. Als tekenreeksen echter als indexen worden gebruikt, moeten de sleutels worden opgegeven om te voorkomen dat er waarden verloren gaan.

We zullen proberen nieuwe elementen aan de array toe te voegen door het soups.php-script te herschrijven. Door eerst de originele elementen van de array af te drukken, en vervolgens de originele elementen samen met de toegevoegde elementen, kunnen we gemakkelijk de veranderingen zien die hebben plaatsgevonden.

Net zoals je de lengte van een string (het aantal tekens die de string bevat) kunt achterhalen met de functie strlen(), is het ook eenvoudig om het aantal elementen in een array te bepalen met behulp van de count()-functie:

1. $HowMany = aantal($Array);
2. Open het soups.php-bestand in een teksteditor.
Nadat u de array hebt geïnitialiseerd met behulp van de functie array(), voegt u de volgende vermelding toe:
$HowMany = count($Soepen);

print("De array bevat $HowMany-elementen.

\N");

3. De functie count() bepaalt hoeveel elementen zich in de array $Soups bevinden. Door deze waarde aan een variabele toe te wijzen, kan deze worden afgedrukt.
Voeg drie extra elementen toe aan de array.
$Soups["Donderdag"] = "Kipnoedel";
$Soups["Vrijdag"] = "Tomaat";
4. $Soups["Zaterdag"] = "Crème van Broccoli";
Tel de elementen in de array en druk deze waarde af.
$HowManyNow = count($Soepen);

print("De array bevat nu $HowManyNow-elementen.

5. \N");

Sla het script op (Listing 7.2), upload het naar de server en test het in de browser (Fig.).

1
2
3