De waarde van het eerste element van de php-array. Hoe haal ik het eerste element uit een PHP-associatieve array? Basisprincipes van het gebruik van array_slice()

Als je niet genoeg weet over de array (je weet niet zeker of de eerste sleutel foo of bar is), dan kan de array misschien ook leeg.

Het is dus beter om dit te controleren, vooral als de mogelijkheid bestaat dat de geretourneerde waarde een booleaanse waarde FALSE is:

$waarde = leeg($arr) ? $standaard: reset($arr);

De bovenstaande code gebruikt reset en zo heeft bijwerkingen(het reset de interne array-aanwijzer), dus misschien gebruikt u liever array_slice om snel toegang te krijgen tot een kopie van het eerste element van de array:

$waarde = $standaard; foreach(array_slice($arr, 0, 1) als $waarde);

Ervan uitgaande dat je wilt krijgen sleutel en waarde afzonderlijk, moet je een vierde parameter toevoegen aan array_slice:

Foreach(array_slice($arr, 0, 1, true) as $key => $waarde);

Om het eerste element te krijgen als paar(sleutel => waarde):

$item = array_slice($arr, 0, 1, waar);

Eenvoudige wijziging te verkrijgen laatst element, sleutel en waarde afzonderlijk:

Foreach(array_slice($arr, -1, 1, true) as $key => $waarde);

toneelstuk

Als de array niet erg groot is, heb je array_slice niet echt nodig en kun je een kopie krijgen van de volledige sleutelarray en dan het eerste element krijgen:

$sleutel = aantal($arr) ? array_keys($arr) : null;

Als u echter een zeer grote array heeft, zal het aanroepen van array_keys veel tijd en meer geheugen vereisen dan array_slice (beide functies doorkruisen de array, maar de laatste wordt afgesloten zodra array_slice het vereiste aantal elementen heeft, dat wil zeggen één).

Een opmerkelijke uitzondering is wanneer je een eerste aanwijzing hebt die naar een heel groot en kronkelig object wijst. In dit geval zal array_slice dat eerste grote object dupliceren, en array_keys zal alleen de sleutels vastleggen.

PHP 7.3

PHP 7.3 implementeert array_key_first() en array_key_last() . Ze zijn expliciet bedoeld om efficiënt toegang te krijgen tot de eerste en laatste sleutel zonder als bijwerking de interne status van de array te resetten.

Dus in PHP 7.3 is de eerste waarde van $array toegankelijk

$matrix;

Je kunt nog steeds beter controleren of de array niet leeg is, anders krijg je een foutmelding:

$firstKey = array_key_first($array); if (null === $firstKey) ( $value = "Array is leeg"; // An error should be handled here } else { $value = $array[$firstKey]; }!}

vanaf de eerste (25)

Ik heb een array:

array(4 => "appel", 7 => "oranje", 13 => "pruim")

Ik zou graag het eerste element van deze array willen hebben. Verwacht resultaat: snaren appel

Eén vereiste: dit kan niet via een link dus array_shift is geen goede oplossing.

Hoe kan ik dit doen?

Antwoorden

De meeste werken! MAAR voor een snelle oproep van één lijn (weinig middelen):

$array = array(4 => "appel", 7 => "oranje", 13 => "pruim"); echo $array; // key($array) -> retourneert de eerste sleutel (die in dit voorbeeld 4 is)

Hoewel dit werkt en behoorlijk goed is, zie ook mijn aanvullende antwoord: https://stackoverflow.com/a/48410351/1804013

$first_value = reset($array); // Waarde van het eerste element $first_key = key($array); // De sleutel van het eerste element

Ik hoop dat dit helpt. :)

Oud bericht, maar hoe dan ook... ik vermoed dat de auteur gewoon op zoek was naar een manier om het eerste element van een array te krijgen nadat hij het uit een bepaalde functie had gehaald (zoals mysql_fetch_row) zonder STRIKT te genereren "Alleen variabelen mogen door verwijzing worden doorgegeven. " Als dat zo is, zullen bijna alle hier beschreven methoden dit bericht ontvangen... en sommige daarvan gebruiken veel extra geheugen bij het dupliceren van de array (of een deel ervan). Een eenvoudige manier om dit te voorkomen is door eenvoudigweg de waarde toe te wijzen aan inline voordat u een van deze functies aanroept:

$first_item_of_array = current($tmp_arr = mysql_fetch_row(...)); // of $first_item_of_array = reset($tmp_arr = func_get_my_huge_array());

Op deze manier krijgt u de STRICT-melding niet op het scherm of in de logs, en maakt u geen extra arrays aan. Het werkt met zowel geïndexeerd als associatief arrays

kan je het eerste element van de array bezorgen, volgens de PHP-handleiding

Elke array heeft een interne verwijzing naar het "huidige" element, die wordt geïnitialiseerd door het eerste element dat in de array wordt geplaatst.

Het werkt dus totdat u de array-aanwijzer opnieuw definieert, anders moet u de array opnieuw instellen.

Behalve dat ze semantisch betekenisvol zijn, verplaatsen deze functies de aanwijzer niet eens naar de array (zoals foreach deed).

Gezien de sleutels kunt u de waarden rechtstreeks verkrijgen met behulp van de sleutels.

Voorbeelden (ze vereisen allemaal PHP 7.3+)

Eerste/laatste sleutel en waarde ophalen:

$foo = array(4 => "appel", 7 => "oranje", 13 => "pruim"); functie get_first ($foo) ( foreach ($foo as $k=>$v)( return $v; ) ) print get_first($foo);

De eerste/laatste waarde als oneliner verkrijgen, ervan uitgaande dat de array niet leeg kan zijn :

$my_array = ["IT", "regels", "de", "wereld"]; $first_key = array_key_first($mijn_array); $first_value = $mijn_array[$first_key]; $last_key = array_key_last($mijn_array); $laatste_waarde = $mijn_array[$laatste_sleutel];

De eerste/laatste waarde ophalen als oneliner, met standaardinstellingen voor lege arrays:

$first_value = $mijn_array[ array_key_first($mijn_array) ]; $last_value = $mijn_array[ array_key_last($mijn_array) ];

$arr = array(9 => "appel", 7 => "oranje", 13 => "pruim"); echo-reset($arr); // echo "appel"

Als u de huidige pointerpositie niet wilt verliezen, maakt u gewoon een alias voor de array.

Sommige arrays werken niet met functies als list , reset of current . Misschien zijn het "kunstmatige" arrays, waarbij bijvoorbeeld ArrayIterator gedeeltelijk wordt geïmplementeerd.

Als u de eerste waarde ongeacht de array wilt uitvoeren, kunt u de iterator kortsluiten:

Foreach($array_with_unknown_keys als $value) break;

Dan is uw waarde beschikbaar in $value en wordt de lus na de eerste iteratie afgebroken. Dit is efficiënter dan het kopiëren van een potentieel grote array naar een functie als array_unshift(array_values($arr)).

Je kunt ook de sleutel gebruiken:

Foreach($array_with_unknown_keys als $key=>$value) break;

Als je dit vanuit een functie aanroept, keer dan gewoon terug voordat:

Functie grab_first($arr) ( foreach($arr as $value) retourneert $value; )

Ik hou er niet van om met de interne array-aanwijzer te rommelen, maar het is ook inefficiënt om een ​​tweede array te construeren met array_keys() of array_values() , dus ik definieer meestal dit:

Functie array_first(array $f) ( foreach ($f as $v) ( return $v; ) throw new Exception("array was leeg"); )

Verkrijg het eerste element:

Array_values($arr)

Haal het laatste element op

Array_reverse($arr)

$myArray = array (4 => "appel", 7 => "oranje", 13 => "pruim"); $arrayKeys = array_keys($mijnArray); // het eerste element van je array is: echo $myArray[$arrayKeys];

Je kunt het N-de element verkrijgen met een "lijst" van de taal:

// 1e itemlijst($firstItem) = $yourArray; // 1e item uit een array die wordt geretourneerd uit de functielijst($firstItem) = functionThatReturnsArray(); // 2e itemlijst(, $secondItem) = $yourArray;

met de functie array_keys kun je hetzelfde doen voor sleutels:

Lijst($firstKey) = array_keys($uwArray); list(, $secondKey) = array_keys($uwArray);

Ik vind het voorbeeld "lijst" leuk, maar "lijst" werkt alleen aan de linkerkant van de opdracht. Als we geen variabele willen toewijzen, zijn we genoodzaakt een tijdelijke naam te verzinnen, die in het beste geval onze reikwijdte vervuilt en in het slechtste geval de bestaande waarde overschrijft:

Lijst($x) = een_array(); var_dump($x);

Het bovenstaande zal elke bestaande waarde van $x overschrijven en de variabele $x zal blijven bestaan ​​zolang dat bereik actief is (einde van die functie/methode of voor altijd als we ons op het hoogste niveau bevinden). Dit kan worden gebruikt met call_user_func en een anonieme functie, maar het is onhandig:

Var_dump(call_user_func(function($arr) ( list($x) = $arr; return $x; ), some_array()));

Als we dit soort anonieme functies gebruiken, kunnen we wegkomen met reset en array_shift, ook al gebruiken ze pass-by-reference. Dit komt omdat het aanroepen van een functie de argumenten ervan zal binden, en deze argumenten kunnen door middel van verwijzing worden doorgegeven:

Var_dump(call_user_func(function($arr) ( return reset($arr); ), array_values(some_array())));

Dit is echter eigenlijk overbodig omdat call_user_func deze tijdelijke toewijzing intern zal uitvoeren. Hierdoor kunnen we pass-by-referentiefuncties behandelen alsof ze zijn doorgegeven, zonder waarschuwingen of fouten:

Var_dump(call_user_func("reset", array_values(sommige_array())));

Laten we aannemen dat:

$array = array(4 => "appel", 7 => "oranje", 13 => "pruim");

Gebruik gewoon:

$matrix

om het eerste element te krijgen of

Sleutel($array)

om de eerste sleutel te krijgen.

Of u kunt de eerste losmaken als u deze wilt verwijderen.

$array=array(4 => "appel", 7 => "oranje", 13 => "pruim"); $firstValue = elke($array);

Dit is veel efficiënter dan array_values() omdat de functie Each() niet de hele array kopieert.

Voor meer informatie zie http://www.php.net/manual/en/function.each.php

$arr = array(4 => "appel", 7 => "oranje", 13 => "pruim"); foreach($arr as $first) break; echo $eerst;

functie hoofd($array) ( return reset($array); )

Een array die door de waarde aan reset() wordt doorgegeven, heeft invloed op de interne kopieeraanwijzer van de array, maar heeft geen invloed op de originele array. (merk op dat het false retourneert als de array leeg is)

Gebruiksvoorbeeld:

$data = ["foo", "bar", "baz"]; huidig($data); // foo volgende($data); // staafkop($data); // foo volgende($data); //baz Hier is ook een alternatief. Dit erg langzaam

Functie head($array, $default = null) ( foreach ($array as $item) ( return $item; ) return $default; )

Array_waarden($array);

Dit is geen eenvoudig antwoord in de echte wereld. Het is gek dat we voorbeelden hebben van mogelijke antwoorden die je in sommige bibliotheken kunt vinden.

$array1 = array(); $array2 = array(1,2,3,4); $array3 = array("hello"=>"wereld", "foo"=>"bar"); $array4 = nul; var_dump("reset1", reset($array1)); var_dump("reset2", reset($array2)); var_dump("reset3", reset($array3)); var_dump("reset4", reset($array4)); // waarschuwing var_dump("array_shift1", array_shift($array1)); var_dump("array_shift2", array_shift($array2)); var_dump("array_shift3", array_shift($array3)); var_dump("array_shift4", array_shift($array4)); // waarschuwing var_dump("each1", every($array1)); var_dump("elke2", elke($array2)); var_dump("elke3", elke($array3)); var_dump("elke4", elke($array4)); // waarschuwing var_dump("array_values1", array_values($array1)); // Let op var_dump("array_values2", array_values($array2)); var_dump("array_waarden3", array_waarden($array3)); var_dump("array_waarden4", array_waarden($array4)); // waarschuwing var_dump("array_slice1", array_slice($array1, 0, 1)); var_dump("array_slice2", array_slice($array2, 0, 1)); var_dump("array_slice3", array_slice($array3, 0, 1)); var_dump("array_slice4", array_slice($array4, 0, 1)); // waarschuwingslijst($elm) = $array1; //Let op var_dump($elm); lijst($elm) = $array2; var_dump($elm); lijst($elm) = $array3; // Let op var_dump($elm); lijst($elm) = $array4; var_dump($elm);

Zoals u kunt zien, hebben we verschillende "éénlijns"-oplossingen die in sommige gevallen goed werken, maar niet in alle gevallen.

Naar mijn mening zou je deze handler alleen met arrays moeten hebben.

Nu we het over prestaties hebben, ervan uitgaande dat we altijd een array hebben, zoals deze:

$elm = leeg($array)? null: ...($array); ...je zou zonder fouten gebruiken: $array ; array_shift reset array_values ​​array_slice

array_shift is sneller dan reset, wat sneller is dan , en deze drie zijn sneller dan array_values ​​en array_slice

Doe gewoon:

Array_shift(array_slice($array,0,1));

Twee oplossingen voor u.

Oplossing 1: gebruik gewoon de sleutel. Je zei niet dat je het niet kon gebruiken. :)

"appel", 7 => "oranje", 13 => "pruim"); // haalt het eerste element op met de sleutel $result = $array; //Verwacht resultaat: string apple assert("$result === "apple" /* Verwacht resultaat: string apple. */"); ?>

Oplossing 2 - array_flip() + key()

"appel", 7 => "oranje", 13 => "pruim"); // verander waarden in sleutels $array = array_flip($array); // je zou een reset kunnen invoeren // gewoon om er zeker van te zijn dat de array-aanwijzer op het eerste element staat // reset ook het eerste element terug // reset($myArray); // return eerste sleutel $firstKey = key($array); assert("$firstKey === "appel" /* Verwacht resultaat: string appel. */"); ?>

Oplossing 3 - array_keys()

Echo $array;

Ik zou echo current($array) doen.

Gebruik:

$first = array_slice($array, 0, 1); $val= $eerste;

Standaard slaat array_slice geen sleutels op, dus we kunnen null veilig als index gebruiken.

ECMAScript5 (Javascript-versie) voor het werken met arrays.

voorElk- Herhaalt elk element van de array en doet met elk element wat je nodig hebt.

["C", "D", "E"].forEach(function(element, index) ( console.log(element + " is de #" + (index+1) + " in toonladder"); )) ; // Uitvoer // C is de #1 in muziekschaal // D is de #2 in muziekschaal // E is de #3 in muziekschaal

In het geval dat u meer geïnteresseerd bent in het werken aan een array met behulp van een ingebouwde functie.

kaart- Creëert een nieuwe array met het resultaat van de callback-functie. Deze methode is goed te gebruiken als u de elementen van uw array moet opmaken.

// Laten we de items in de array in hoofdletters zetten ["bob", "joe", "jen"].map(function(elem) ( return elem.toUpperCase(); ) // Output: ["BOB", "JOE", "JEN"]

afname. Zoals de naam al doet vermoeden, reduceert het de array tot een enkele waarde door ervoor te zorgen dat de gegeven functie wordt doorgegeven aan het huidige element en het resultaat van de vorige uitvoering.

Reduce(functie(vorige, huidige) ( retourneer vorige + huidige; )); // Uitvoer: 10 // 1e iteratie: vorige=1, huidige=2 => resultaat=3 // 2e iteratie: vorige=3, huidige=3 => resultaat=6 // 3e iteratie: vorige=6, huidige= 4 => resultaat=10

elk- Retourneert waar of onwaar als alle array-elementen de test in de callback-functie doorstaan.

// Controleer of iedereen 18 jaar of ouder is. var leeftijden = ; leeftijden.every(function(elem) ( retourneer elem >= 18; )); // Uitvoer: false

filter- zeer vergelijkbaar met elk, behalve dat het filter een array retourneert met elementen die waar retourneren voor de gegeven functie.

// De even getallen vinden .filter(function(elem)( return (elem % 2 == 0))); // Uitvoer:

Ik hoop dat dit nuttig is.

Soms moet u met een reeks array-elementen werken. U moet bijvoorbeeld een groot deel van een array verwerken, of u moet een array bestellen en daaruit de “top 10”-waarden vanaf het begin van de array extraheren.

In deze tutorial bekijken we de PHP-functie array_slice(), die kan worden gebruikt om een ​​reeks elementen uit een array te extraheren.

Basisprincipes van het gebruik van array_slice()

De volgende argumenten worden doorgegeven aan de functie array_slice():

  • Een array waaruit sommige elementen worden geëxtraheerd.
  • De positie van waaruit het geëxtraheerde deel van de array begint (het tellen van elementen in de array begint vanaf 0).
  • Aantal elementen/dat uit de array moet worden geëxtraheerd.

Array_slice() retourneert een array met de geëxtraheerde elementen. De oorspronkelijke array blijft ongewijzigd.

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

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Print "Array ( => Stanley Kubrick => Martin Scorsese)" print_r(array_slice($directors, 1, 2));

De bovenstaande code maakt een array met 4 elementen (de namen van de regisseurs) en gebruikt vervolgens de functie array_slice() om het tweede en derde element te extraheren.

Houd er rekening mee dat positie element in de array en zijn index niet altijd hetzelfde. Het eerste element van een array bevindt zich bijvoorbeeld altijd op positie 0, maar de index ervan kan 456 zijn. PHP-geïndexeerde arrays hoeven geen sequentiële indexen te hebben die beginnen bij nul (hoewel ontwikkelaars het indexnummer heel vaak zo instellen).

Indexen opslaan

In het bovenstaande voorbeeld kun je zien dat array_slice() de indexen van de elementen in de geretourneerde array heeft gewijzigd: Stanley Kubrick kreeg index 0 en Martin Scorsese kreeg index 1. Vaak veroorzaakt deze bewerking geen problemen, omdat de volgorde van de elementen in de resulterende array belangrijk is, en niet hun indices.

Soms is het echter belangrijk om de indexen van de opgehaalde elementen op te slaan. Indexen kunnen bijvoorbeeld sleutels zijn die records in een gegevenstabel identificeren, of ze kunnen voor een ander doel belangrijk zijn. In dit geval kunt u de indices van de elementen die worden opgehaald behouden door true als vierde argument door te geven aan de functie array_slice(). Bijvoorbeeld:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Print "Array ( => Stanley Kubrick => Martin Scorsese)" print_r(array_slice($directors, 1, 2, true));

Merk op dat de functie array_slice() in dit geval de indexen van de originele array voor de elementen behield: 1 voor Stanley Kubrick en 2 voor Martin Scorsese.

De functie array_slice() slaat indexen altijd op in bijbehorende arrays. Op deze manier is het niet nodig om true als vierde argument door te geven bij het werken met bijbehorende arrays.

Elementen ophalen aan het einde van een array

Als u het derde argument voor de functie array_slice() niet opgeeft, bevat de resultaatarray alle elementen van de originele array, beginnend bij de startpositie tot het einde van de array. Deze functionaliteit kan handig zijn als u de afmetingen van de originele array niet kent. Bijvoorbeeld:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Print "Array ( => Stanley Kubrick => Martin Scorsese => Fritz Lang)" print_r(array_slice($directors, 1));

Array_slice() gebruiken op geassocieerde arrays

u kunt array_slice() gebruiken om elementen uit een bijbehorende array te extraheren. Hieronder ziet u een voorbeeld van het ophalen van twee elementen uit een bijbehorende array, te beginnen met het tweede element:

$movie = array("title" => "Achterruit", "regisseur" => "Alfred Hitchcock", "jaar" => 1954, "minuten" => 112); // Print "Array ( => Alfred Hitchcock => 1954)" print_r(array_slice($movie, 1, 2));

Merk op dat de functie array_slice() de indexen "director" en "year" in de resultaatarray heeft opgeslagen.

Cv

In dit artikel hebben we het gebruik van de functie array_slice() besproken. Een handige PHP-functie die een reeks array-elementen retourneert. Je hebt geleerd:

  • Hoe u de functie array_slice() gebruikt met geïndexeerde en bijbehorende arrays.
  • Behoud originele indexen wanneer u met geïndexeerde arrays werkt.
  • Haal alle elementen op tot aan het einde van de originele array.

PHP-arrays worden overal gebruikt. Het toevoegen en wijzigen van waarden is meestal eenvoudig.

Het verwijderen van array-elementen is een speciale bewerking. U kunt het element eenvoudig verwijderen, of u kunt het verwijderen en gebruiken. Deze nuance biedt grote kansen.

PHP-arrays

PHP is een moderne programmeertaal, de functionaliteit wat betreft het werken met arrays wordt op een hoog niveau uitgevoerd. De programmeur heeft de mogelijkheid om reguliere en associatieve arrays te gebruiken, multidimensionale datastructuren te ontwerpen en een waarde van elk type als array-elementen te hebben.

Er is een ontwikkelde reeks functies voor het werken met arrays en speciale syntactische constructies. Het is mogelijk om de array te doorlopen met behulp van uw eigen algoritme en uw eigen verwerkingsfuncties toe te wijzen.

Voorbeelden van het maken en gebruiken van een array

De scPrint-functie is een hulpfunctie. Het schrijft recursief een array in een tekenreeks om de resultaten die het oplevert te demonstreren.

De $aFruits-array wordt op de gebruikelijke manier gemaakt: de waarden worden vermeld, de indexen worden automatisch helemaal opnieuw toegewezen. De laatste komma is niet relevant en creëert geen nieuw leeg element.

De $aData-array wordt leeg gemaakt en er worden waarden aan toegevoegd. Drie zijn automatisch en twee hebben associatieve indexen die geen invloed hebben op de algehele nummering van waarden. Zo hebben de elementen ‘pruim’ en ‘perzik’ respectievelijk de indices ‘nieuw’ en ‘vers’.

De $aInfo-array is multidimensionaal en associatief.

Drie verwijderingsbewerkingen laten zien hoe u een element in een PHP-array verwijdert.

De eerste bewerking verwijdert het tweede element uit de array $aFruits, de index is 1. Opgemerkt moet worden dat de volgende indices niet worden verschoven, wat betekent dat het bij cyclische bewerkingen met een dergelijke array noodzakelijk is om het bestaan ​​van het element te controleren .

De tweede bewerking verwijdert het laatste en eerste element in de $aData-array, wat bevestigt dat de verwijdering geen invloed heeft op de indexen en op de mogelijkheid om tegelijkertijd meerdere elementen te verwijderen.

De derde verwijdert een array binnen een array en een element binnen een array dat deel uitmaakt van een andere array.

Normale verwijdering van elementen - uitgeschakeld

De uitschakelfunctie verwijdert. Het maakt niet uit wat. Het kan gewoon een variabele of een array-element zijn. unset() wordt beschouwd als een taaloperator en niet als een functie. Deze operator retourneert geen enkele waarde en ‘vernietigt’ wat er als parameters aan wordt doorgegeven. De variabele of array verdwijnt alsof deze nooit heeft bestaan.

In PHP kun je lege array-elementen op verschillende manieren verwijderen; wat als een leeg element wordt beschouwd, hangt in feite af van de programmeur. Het is echter niet erg verstandig om voor dit doel meerdere parameters in de unset() operator te gebruiken. Het is praktischer om groepsbewerkingen naar groepsfuncties te verplaatsen.

Moderne computers zijn erg snel, en PHP is erg snel. Maar dit is geen reden om tonnen informatie te creëren en te verwerken met behulp van omslachtige algoritmen; dit is een objectieve reden om het proces van het verwijderen van array-elementen op progressieve manieren te benaderen.

Elementen verwijderen met behulp van stringmethoden

In PHP kun je lege array-elementen in bulk verwijderen door de array naar een string te converteren en deze terug te sturen. Maar dit geval is alleen geschikt voor echt lege elementen, ontbrekende indexen of voor het opnieuw indexeren van een array.

Het concept van een leeg element is afhankelijk van de taak. Vaak wordt een bestaand array-element dat bepaalde informatie bevat leeg. Een array registreert bijvoorbeeld bezoekers. Het array-element bevat:

  • aankomsttijd van de bezoeker;
  • huidige bedrijfsmodus;
  • actieve pagina;
  • laatste actietijd.

Indien het verschil tussen het tijdstip van aankomst en het tijdstip van de laatste actie meer dan 1 minuut (of een andere waarde) bedraagt, kunnen wij ervan uitgaan dat de opdrachtgever het terrein heeft verlaten. Records over dergelijke klanten kunnen worden verwijderd als het de taak is om de lijst met actieve bezoekers te controleren en geen geavanceerdere methoden te gebruiken met behulp van JavaScript.

De "lijn" -verwerking is echter goed. In PHP kun je bijvoorbeeld dubbele array-elementen als volgt verwijderen:

Snelle en betaalbare manier. Het is niet nodig om de symbolen "[" en "]" te gebruiken om elk element aan te duiden, maar onthoud dat wanneer u een array in een string transformeert, u ervoor moet zorgen dat elk element uniek is. De kaderkarakters moeten worden gekozen op basis van de karakters die in het element zijn toegestaan. Een onwankelbare regel: elk array-element in een rij is uniek en heeft zijn plaats (anders kan er niets worden teruggegeven).

Deze methode is handiger als het in PHP de taak is om een ​​array-element op waarde te verwijderen. U kunt de functie array_flip gebruiken en de waarden en sleutels omwisselen, en vervolgens een klassieke unset uitvoeren. U kunt de functie array_search gebruiken en de sleutel vinden van de waarde die u wilt verwijderen. Maar de kleine versie van de oplossing is duidelijker en eenvoudiger.

PHP beperkt de ontwikkelaar praktisch nergens in: noch in het aantal dimensies, noch in de grootte van elementen. Het heeft geen zin om hierin betrokken te raken. Elk element moet de minimaal mogelijke lengte hebben en het aantal dimensies moet de neiging hebben om één te zijn.

Als het aantal arraydimensies meer dan drie bedraagt, is dit een goede reden om de beslissing te heroverwegen. Als een array-element langer is dan 4000-8000 tekens, moeten er twijfels rijzen over de redelijkheid van het geconstrueerde gegevensbeeld.

Deze mening komt niet voort uit de context van de functionaliteit van een PHP-array: verwijder een element, voeg een object van een ander type toe, verander het ene in iets heel anders. Eenvoud is de sleutel tot succes, niet alleen in het leven, maar ook in het algoritme. Het programma zou moeten werken en niet moeten verrassen met zijn afmetingen, dimensies en schaal van ideeën. Het is het resultaat dat telt, niet het grote idee.

Als moderne programmeertaal negeert PHP recursie en de stack niet. Het is fundamenteel onbelangrijk wat de programmeur bedoelt als hij de functie array_pop() in PHP gebruikt: verwijder het laatste element van de array of plaats het eenvoudigweg in een variabele.

Maar houd er rekening mee dat in deze context de array_pop-functie een push & pop-functie is, dat wil zeggen dat het een stapeltool is en geen verwijdertool.

Hier is het gebruikelijk om niet "verwijderen", maar "uitpakken" te zeggen. De semantiek is aanzienlijk verschillend. De functie array_shift() in PHP – het verwijderen van het eerste element van een array of het extraheren ervan – heeft echter een andere connotatie. Ook hier wordt het element opgehaald in een externe variabele en komt het niet in de array terecht, maar worden de indices verschoven.

Wanneer het eerste element uit een array wordt geëxtraheerd, worden alle elementen die erop volgen naar voren geschoven, maar alleen de numerieke indices veranderen;

Verwijderen of wijzigen: transactiegeschiedenis

Een variabele is heel lang geleden, een array is lang geleden, een object is gisteren. Er wordt nog steeds alleen over objectgeoriënteerd programmeren gesproken, maar niets wordt ten volle benut. Het komt zelden voor dat oppervlakkige oplossingen het onderwerp werden van enthousiaste oplossingen en ‘wijze’ contentmanagementsystemen (CMS) met veel ‘body’.

Objectieve regel: het is niet de kwantiteit van de code die telt, maar de kwaliteit ervan! Maar nog geen enkel modern CMS heeft deze regel in acht genomen. De auteurs geloven dat ze het juiste doen en weten wat ze doen.

Resultaat (karakteristiek kenmerk): geen van de moderne CMS onderscheidt zich door een fatsoenlijk "figuur" (slankheid en lichtheid van ontwerpen), ze hebben allemaal een enorme volledigheid van code, elk vereist respect:

  • hooggekwalificeerde programmeur;
  • heeft installatie nodig;
  • legt hostingvereisten op;
  • creëert problemen bij het verhuizen naar een andere hosting;
  • vertraagt ​​het werk en de administratie enorm.

Programmeurs zijn al heel lang bezig met het concept van terugdraaien; moderne programmering kan zich niet voorstellen software te maken zonder twee functies:

  • ongedaan maken;
  • opnieuw doen.

Het is niet alleen de menselijke natuur om fouten te maken, maar in elke situatie moet er sprake zijn van een terugdraaiing. In moderne internetprogrammeertools doet dit punt er tot op de dag van vandaag niet alleen toe, maar wordt het ook op zeer beperkte schaal gebruikt.

PHP-bewerkingen op een array: een element verwijderen, het type ervan wijzigen of iets nieuws toevoegen zijn duidelijk. Maar voordat er variabelen waren, toen arrays en toen objecten. Is er geen reden om na te denken over het feit dat een array in de loop van de tijd slechts een variabele is?

Een array is een gegevensstructuur in de loop van de tijd. Geen enkele taal beschouwt tot op de dag van vandaag tijd als een factor in de syntaxis. Je hoeft niet eens over semantiek te praten: van de oudheid tot nu begrijpen programmeurs en gebruikers alleen bestanden en mappen. Het maximum dat de ontwikkeling heeft bereikt, bijvoorbeeld in PHP, wordt de naamruimte triviaal weerspiegeld in de structuur van mappen en bestanden.

In deze context vereisen banale acties in PHP op een array: een element verwijderen, wijzigen of toevoegen - aanvullende acties van de programmeur. Je kunt alles laten zoals het is, en het zal zoals altijd werken. U kunt bij elke bewerking rekening houden met gegevens en deze volledig vastleggen, een historie van bewerkingen creëren en opslaan.

Dit zal een heel ander werkniveau en een radicaal betere kwaliteit van het resultaat zijn.


Arrays worden veel gebruikt in PHP-scripts.


Een array is een verzameling elementen, die allemaal toegankelijk zijn via index of naam. Alle arrays in PHP zijn associatief, d.w.z. bestaan ​​uit "sleutel"="waarde"-paren.

De array $arr bevat één paar waarden. De sleutel daarin is de waarde "auto" en de waarde - "Seagull".

De waarde van de sleutels kan van tekst- of numeriek type zijn, en sleutels van verschillende typen kunnen in één array worden gebruikt. De volgende code werkt bijvoorbeeld redelijk goed:

Soms is het niet nodig om elementsleutels op te geven. In dit geval kunt u profiteren van het feit dat PHP automatisch sleutels kan maken bij het toevoegen van elementen aan een array. De toetsen zijn altijd numeriek en beginnen vanaf nul. Bijvoorbeeld:

"eerste", 1=>"tweede", 2=>"derde"); ?>

De combinatie "=>" wordt gebruikt om de sleutel te scheiden van de waarde in een element bij het declareren van een array.

Een individueel array-element is toegankelijk via de index of sleutel:

En met behulp van de foreach-constructie kunt u snel alle elementen van een array doorlopen:

$value) echo "Array-elementnummer $key is gelijk aan "$value""; ?>

Om met archieven te werken, biedt PHP een aantal functies waarmee u een reeks standaardbewerkingen kunt uitvoeren, zoals het sorteren, zoeken of roteren van een array. Laten we eens kijken naar de meest gebruikte functies.

array_chunk() Wordt gebruikt om een ​​array in delen van een bepaalde grootte te verdelen. De functie retourneert een array met fragmenten van de oorspronkelijke array.
array_combine() De functie combineert twee arrays zodat de elementen van de eerste de sleutels worden, en de elementen van de tweede de waarden van de resulterende associatieve array."a", 1=>"b", 2=>"c" ?>
array_count_values() Telt het aantal unieke waarden in een array en hoe vaak deze voorkomen3, "b" => 1, "c" => 2 ?>
array_diff() De functie benadrukt het verschil tussen twee arrays, d.w.z. elementen die zich in de eerste array bevinden en niet in de tweede.
array_fill() Vult een array met een bepaalde waarde"xxx" 3=>"xxx" 4=>"xxx" ?>
array_flip() Verwisselt de sleutels en waarden van een associatieve array"a", 1=>"b", 2=>"c");
$res = array_flip($arr); // $res bevat "a"=>0, "b"=>1, "c"=>2 ?>
array_intersect() De functie berekent het snijpunt van twee arrays, d.w.z. retourneert alle elementen die zich tegelijkertijd in beide arrays bevinden.array_key_exists()
De functie controleert of er een sleutel met dezelfde naam in de array aanwezig is. "a", 1=>"b", 2=>"c");if(array_key_exists(1, $arr) echo "Sleutel gevonden"; else echo "Sleutel niet gevonden"; ?>
array_keys() Retourneert een reeks sleutels"a", 1=>"b", 2=>"c");
$res = array_keys($arr); // $res bevat 0, 1, 2 ?>
array_merge() Combineert een of meer arrays. De waarden van elementen met dezelfde sleutels worden vervangen door elementen van de tweede array
"een", 1=>"een", 2=>"b"); $arr2 = array(3=>"a", 0=>"b", 4=>"c");$res = array_merge($arr1, $arr2);
// $res bevat 0=>"b", 1=>"a", 2=>"c", 3=>"a", 4=>"c" ?> array_rand()
Retourneert één willekeurig element uit een array array_reverse()
Retourneert de oorspronkelijke array, maar in omgekeerde volgorde, d.w.z. lees van begin tot eind. array_search()
De functie zoekt naar een array-element dat aan de opgegeven voorwaarden voldoet. Retourneert de naam van de overeenkomstige sleutel. "a", 22=>"b", 33=>"c");
$key = array_search("b", $arr); // $sleutel is 22 ?>
array_shift() Verschuift alle array-elementen naar het begin, waarbij het eerste array-element verloren gaat.array_slice()
Haalt een fragment van een array op array_som()De functie retourneert de som van alle arraywaarden
array_unique() Verwijdert dubbele waarden uit een array
array_unshift() De inverse functie van array_shift() verschuift alle elementen naar het einde van de array en voegt een element toe aan het begin.
array_values() Retourneert een array met waarden uit de oorspronkelijke array
"a", "y"=>"b", "z"=>"c"); $res = array_waarden($arr);

Zoals u kunt zien, is het gebruik van arrays heel eenvoudig en vooral uiterst handig. Geen enkel groot project kan zonder het gebruik van arrays. We hebben slechts enkele van de beschikbare functies bekeken, zonder in te gaan op de subtiliteiten van hun toepassing in verschillende situaties. Meer gedetailleerde informatie kunt u vinden in de officiële handleiding op de website www.php.net.



GERELATEERDE ARTIKELEN