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 $aFruits-array, 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 het verwijderen geen invloed heeft op indexen en dat verschillende elementen tegelijkertijd kunnen worden verwijderd.

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 een zo klein mogelijke lengte hebben en het aantal afmetingen 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, de kleine letters blijven ongewijzigd.

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 met elke bewerking rekening houden op 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.

PHP is veelbelovend en modern: syntaxis van hoge kwaliteit en de mogelijkheid om semantiek te doen die verder gaat dan toegestaan. De implementatie van objectgeoriënteerde programmeerideeën en de vrijheid om het type van een variabele te veranderen, laten uw wildste fantasieën uitkomen.

Arrays zijn een eeuwenoud ontwerp, en associatieve arrays zijn meer een eerbetoon aan de tijd dan een vereiste voor de praktijk. Hoewel er een voldoende aantal taken is waarbij gegevensverzamelingen met een niet-vooraf bepaalde inhoud (hoeveelheid, waarden, typen en indexen) worden gemaakt, die beschikbaar zijn voor weergave en gebruik in lussen. Het laatste element van de array is beschikbaar met behulp van elke creatiemethode. Met arrays - regulier en associatief - kun je lijsten maken, maar in de normale PHP-syntaxis heeft dit beperkt nut.

Huidige arraywaarde

Als we abstraheren van indexen en de constructie gebruiken

$arData = nieuw scField(); // scNumber, scString, scParagraph, ...

waarbij scField() de constructor is van een abstract object - een “informatie-element” dat nakomelingen heeft: getallen (scNumber), strings (scString), zinnen (scParagraph), ... we krijgen in PHP: het laatste element = een array van objecten die zijn eigenschappen als feitelijk element vertonen.

In wezen maakt het niet uit welk element als relevant wordt beschouwd, maar in dit geval moet u de aanwijzer (in PHP - een cursor) in de array in de gaten houden. Vaker heeft u een eigen elementaanwijzer nodig. Er is geen cursor nodig in PHP's "laatste element = array" -idee. Het laatste element is toegankelijk via de functies end() en array_pop() en delegeert zijn eigenschappen aan de array. Als u bovendien array_pop() gebruikt, wordt de array automatisch naar het vorige element verplaatst en veranderen de eigenschappen ervan dienovereenkomstig. Hierdoor is het mogelijk om door de elementen te bewegen.

Dus als je de PHP-syntaxis in context plaatst, betekent het ophalen van het laatste element van een array feitelijk het gebruik van de eigenschappen ervan. Door elementen te plaatsen en te verwijderen, verkrijgen we consequent de dynamiek van eigenschappen, de dynamiek van een nieuwe gevormd binnen de grenzen van de beschikbare syntaxis.

Eerste en andere elementen

Er zijn functies voor het werken met het eerste element van de array en het verplaatsen van de interne aanwijzer. In de normale syntaxis die de klassieke programmeerpraktijk implementeert, zijn ze van toepassing. Wat betreft het creëren van arrays met dynamisch veranderende betekenis - nee.

Bij het programmeren hebben we het altijd over het nemen van beslissingen: variabelen nemen waarden aan, voorwaardelijke uitspraken veranderen de loop van het algoritme, lussen analyseren iets en uiteindelijk ontstaat er een resultaat.

Als je het zwaartepunt verlegt naar het element zelf en het zijn eigen beslissingen laat nemen, krijgt de implementatie van het programma een heel andere, betekenisvolle uitstraling. Meestal is dit de methode waarmee u het doel kunt bereiken, vooral als het bijvoorbeeld gaat om het gebruik van talloze *.docx-documenttags die zijn geschreven in de Open XML-standaard.

In PHP heeft het verkrijgen van het laatste element van een array een nieuwe betekenis en goede mogelijkheden.

Bestanden laden en dynamiek van array-eigenschappen

Wanneer een site de mogelijkheid biedt om bestanden te downloaden, is het handig om het idee van een abstract object te gebruiken, bijvoorbeeld scFile en zijn nakomelingen scImage, scDocument, scTabe, die dezelfde eigenschappen zullen hebben, maar hun manifestatie en betekenis (inhoud) zal anders zijn. In de context van de PHP-syntaxis (laatste element = array) kunt u met behulp van de functie end() deze gebruiken zoals het laatste element definieert. Deze oplossing is interessant omdat het de gebruikelijke representaties omkeert en u in staat stelt door de datastructuur te navigeren zoals deze werd gevormd.

Dit gebruik van arrays geeft ze volledig nieuwe inhoud. Dit wordt mogelijk gemaakt door de PHP-syntaxis, maar als je het op deze manier gebruikt, ontstaan ​​er veel mogelijkheden.

Nadat u methoden voor visualisatie heeft aangereikt, in een database opslaat en de werkomstandigheden herstelt (bijvoorbeeld), hoeft u niet na te denken over wat u in een bepaald geval moet doen. Alle gedownloade bestanden worden opeenvolgend in de array geplaatst en wanneer deze wordt verwerkt, worden altijd dezelfde methoden aangeroepen volgens hetzelfde schema, maar het afbeeldingsbestand wordt weergegeven zoals het is, het spreadsheetbestand als een tabel en het document als het bijbehorende tekst. Het laatste element van de array is toegankelijk via de PHP-syntaxis en is uitgerust met zijn eigenschappen en specifieke inhoud.

In het laatste geval bevat het document altijd tekens, regels, cijfers en vooral opmaak. Het is moeilijk om elk element bij te houden, maar door voor elk formaatelement het juiste object op te geven, kunt u zonder nadenken het document krijgen zoals het is.

Stapel en recursie binnen syntaxis

Als je alleen met het laatste element werkt, is de stapel de belangrijkste voorwaarde, maar als dit element wordt uitgevoerd en dezelfde constructie erin wordt gebruikt, en vooral zichzelf, is er sprake van recursie. Je kunt veel goede dingen zeggen over PHPOffice-bibliotheken, bijvoorbeeld PHPWord, maar het is onmogelijk om te zeggen dat ze een volwaardig mechanisme implementeren dat de originele documentopmaak vertaalt naar het resultaat.

Met PHPOffice\PHPWord kunt u inderdaad eenvoudig elk Word-document (*.docx) openen, maar dit is slechts een archief van veel gestructureerde XML-bestanden, afbeeldingen, objecten, enz.

Tegelijkertijd, als u alleen XML-bestanden neemt, ook al zijn ze met elkaar verbonden (in termen van stijlen, tabellen, afbeeldingen), zal het niet mogelijk zijn om een ​​nieuw document te maken op basis van het oude en eenvoudigweg de gewenste wijzigingen ernaar over te brengen (wijzig bijvoorbeeld het lettertype, de kleuren, de opmaak). Er zijn veel opties voor het gebruik van Open XML-tags, en zelfs een goed functionerend product als MS Word kan niet altijd omgaan met de ideeën van de gebruiker en maakt fouten.

Eigenlijk is een *.docx-bestand een zip-archief, met een duidelijke en begrijpelijke structuur. Met behulp van een klein aantal objecten kun je het formeel beschrijven en op het moment van lezen een volwaardige, onafhankelijke datastructuur verkrijgen die semantisch kan worden gemanipuleerd.

In dit geval is de informatie in het document een formele gegevensstructuur. Door er dynamiek aan te geven, kun je gemakkelijk naar het betekenisniveau gaan en abstractie maken van de syntaxis.

Reg.ru: domeinen en hosting

De grootste registrar en hostingprovider in Rusland.

Meer dan 2 miljoen domeinnamen in gebruik.

Promotie, domeinmail, zakelijke oplossingen.

Meer dan 700.000 klanten over de hele wereld hebben hun keuze al gemaakt.

Bootstrap-framework: snel adaptieve lay-out

Stapsgewijze videocursus over de basisprincipes van adaptieve lay-out in het Bootstrap-framework.

Leer eenvoudig, snel en efficiënt zetten met behulp van een krachtig en praktisch hulpmiddel.

Lay-out om te bestellen en betaald te krijgen.

*Beweeg de muis over om het scrollen te pauzeren.

Terug Vooruit

PHP: Array-elementen verwijderen

We worden geconfronteerd met een schijnbaar triviale taak: het verwijderen van een array-element. Of meerdere elementen.

Ondanks al zijn eenvoud zijn er opties die niet helemaal voor de hand liggen en die de moeite waard zijn om te weten als je PHP iets verder wilt brengen dan "Hallo wereld!"

Laten we beginnen met de basis zelf: om één element te verwijderen, moet je de functie gebruiken uitgeschakeld():

Uitgezet($array); unset($array["foo"]);

Niet ingesteld($array, $array); unset($array["foo"], $array["bar"]);

De volgende logische vraag is: hoe verwijder je meerdere elementen die elkaar opvolgen (d.w.z. aangrenzend)? Gebruik de functie om meerdere aangrenzende elementen te verwijderen array_splice():

Array_splice($array, $offset, $lengte);

Houd er rekening mee dat bij gebruik van deze functies alle verwijzingen naar deze elementen verdwijnen. Als u een sleutel in de array wilt laten staan, maar deze aan een lege waarde wilt koppelen, wijst u het gewenste element toe aan een lege string:

$array = $array["foo"] = "";

Het is belangrijk om te begrijpen dat de functie uitgeschakeld() verwijdert het element, terwijl het toewijzen van "" aan het element het element niet verwijdert, maar de waarde ervan gelijk maakt aan de lege string.

Als je met cijfers werkt, is het waarschijnlijk beter om de waarde 0 aan zo’n sleutel te koppelen.

Laten we zeggen dat als een bedrijf is gestopt met het produceren van onderdelen voor het HBL-568-model, er een wijziging kan worden aangebracht in de onderdelenreeks:

Niet ingesteld($products["HBL-568"]);

Als het HBL-568 onderdeel niet slechts tijdelijk op voorraad is en naar verwachting vanuit de fabriek zal arriveren, kunt u het beter anders doen:

$producten["HBL-568"] = 0;

Het volgende punt dat u moet begrijpen, is dat u een functie aanroept uitgeschakeld() voor een array-element past PHP de array aan zodat de lus nog steeds correct werkt.

Met andere woorden: de array wordt niet gecomprimeerd om de resulterende “gaten” op te vullen. In wezen betekent dit dat alle arrays associatief zijn, zelfs als ze op het eerste gezicht numeriek lijken. Laten we eens kijken naar duidelijke voorbeelden om dit gedrag te illustreren:

// Maak een "numerieke" array $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); print $dieren; // Print "bij" print $animals; // Drukt het aantal "katten" af ($animals); // Geeft 6 terug // unset() unset($animals); // Verwijdert een element $animals = "bij" print $animals; // Voert niets uit en geeft een foutmelding E_NOTICE print $animals; // Drukt het aantal "katten" af ($animals); // Geeft 5 terug terwijl het element $array op zijn plaats blijft en "fox" bevat // Een nieuw element toevoegen $animals = "gnu"; // Voegt een nieuw element toe print $animals; // Voert niets uit, geeft ook een foutmelding E_NOTICE print $animals; // Drukt het aantal "gnu" af ($animals); // Retourneert 6 // Toekennen van "" (lege tekenreeks) $animals = ""; // Stel in op "lege string" print $animals; // Print "" count($animals); // Geeft 6 terug, d.w.z. houdt bij het tellen rekening met het lege array-element

Gebruik de functie om naar een dichtbevolkte numerieke array te gaan array_values():

$dieren = array_values($dieren);

Bovendien herindexeert de functie array_splice() automatisch arrays om “gaten” te elimineren:

// Maak een "numerieke" array $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($dieren, 2, 2); print_r($dieren);

Bij de uitvoer krijgen we:

Array ( => mier => bij => eland => vos)

Waar kan deze functie van pas komen?

Stel dat u met een array als wachtrij werkt en elementen uit deze wachtrij wilt verwijderen zonder de mogelijkheid van willekeurige toegang te verliezen, terwijl u per ongeluk in een van de resulterende "gaten" zou kunnen vallen.

En tot slot, om het eerste of laatste element veilig uit een array te verwijderen, de functies array_shift() En array_pop() respectievelijk.

Alles is heel eenvoudig bij hen:

$stack = array("oranje", "banaan", "appel", "framboos"); $fruit = array_shift($stack); print_r($stack);

Als gevolg van het uitvoeren van de bovenstaande code krijgen we de volgende uitvoer:

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

Gebruik de functie om het laatste element te verwijderen array_pop():

$stack = array("oranje", "banaan", "appel", "framboos"); $fruit = array_pop($stack); print_r($stack);

De uitvoer is de volgende array-afdruk:

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

Dat is alles. We hebben de belangrijkste punten over het verwijderen van array-elementen in PHP besproken. Als er iets gebeurt, is de officiële documentatie altijd nuttig.

Vond je het materiaal leuk en wil je mij bedanken?
Deel het gewoon met je vrienden en collega's!

Zie ook: