Share
Als je in deze serie met ons hebt gevolgd, weet je ongetwijfeld dat we de concepten van objectgeoriënteerd programmeren vanuit het perspectief van de beginner bekijken.
Concreet kijken we naar het onderwerp voor diegenen die zich vertrouwd willen maken met het paradigma, maar ook met hoe de concepten in de context van WordPress toe te passen; echter voordat we aan het werk gaan met objectgeoriënteerd programmeren en WordPress, we moeten de basis leggen met de basisfuncties die PHP biedt.
Uiteindelijk werken we aan het creëren van een praktisch voorbeeld van objectgeoriënteerd programmeren door een WordPress-plug-in te maken. Maar voordat we dat doen, zijn er nog een paar dingen die we moeten bespreken.
Als dit de eerste keer is dat u deze serie leest, raad ik u aan de vorige artikelen te bekijken, aangezien elk artikel in deze serie is gebaseerd op het vorige artikel. Als u aan de andere kant iemand bent die meer vertrouwd is met objectgeoriënteerd programmeren, dan wilt u misschien de serie opnieuw bekijken als we eenmaal bezig zijn met de praktische toepassing van de ideeën..
Tot nu toe hebben we de volgende onderwerpen behandeld.
In dit artikel gaan we onze discussie over besturingsstructuren afronden door te kijken naar de verschillende soorten lussen die PHP biedt.
Als u het vorige artikel hebt gelezen, herinnert u zich dat 'besturingsstructuren' refereren naar constructies die worden geleverd door de taal (in ons geval PHP), die ons in staat stellen om de code in het hele programma te wijzigen op basis van een aantal voorwaarden.
In het laatste artikel hebben we gekeken hoe we dit kunnen doen door het gebruik van voorwaardelijke verklaringen die uitspraken zijn die het programma een uitvoeringstraject afdwingen op basis van een voorwaardelijke (zoals als een variabele is ingesteld, als een voorwaarde waar is , enzovoorts).
Maar dat is niet het enige type controle dat we hebben. Naast conditionals hebben we de mogelijkheid om sets met gegevens te herhalen (of herhalen), zodat we actie kunnen ondernemen voor elk item in een set gegevens. We kunnen gegevens toevoegen, gegevens verwijderen, gegevens weergeven, de gegevens sorteren en nog veel meer.
Laten we bijvoorbeeld aannemen dat we een set gegevens hebben, misschien een reeks van 10 berichten, en dat we de titel en de datum van elk bericht willen doorlopen en afdrukken. Loops stellen ons in staat om dit te doen.
Wat je ook wilt doen, er zijn vier soorten loops die PHP ons biedt om door reeksen gegevens te bladeren. In dit artikel gaan we er een paar voorbeelden van bekijken, plus enkele nuances van elk, zodat we een nieuwe set controlestructuren hebben die we kunnen gebruiken als het tijd is om te beginnen met het schrijven van object-georiënteerde code.
Accentsconagua
voor LoopsDe voor loop wordt vaak beschouwd als de meest gecompliceerde van de loops vanwege de aard van hoe je de code schrijft. De stroom ervan leest een beetje onnatuurlijk.
Normaal gesproken zijn we gewend om code regel voor regel te schrijven, zodat elke instructie op één regel wordt ingesteld; echter met voor loops, we hebben een iets andere benadering. Eerst zal ik een eenvoudig voorbeeld delen, we zullen de aspecten ervan bespreken en dan zullen we kijken naar een meer gedetailleerde aanpak.
Hier is een eenvoudig voorbeeld dat tot 10 zal tellen en elk nummer op het scherm zal weergeven als dit gebeurt:
voor ($ i = 0; $ i < 10; $i++ ) echo $i;
In de eerste regel van de lus (tussen de haakjes na de voor verklaring), doen we het volgende:
$ i en instellen gelijk aan nul$ i < 10 $ i met de waarde van 1 (met behulp van de post-increment operator) na elke iteratieIn de body van de lus gebruiken we gewoon PHP's echo functie om de huidige waarde van af te drukken $ i. Terwijl de lus de instructies verwerkt, zien we 0 - 9 op het scherm afgedrukt (aangezien we beginnen bij nul en terwijl we bezig zijn $ i is minder dan 10).
Verschillende mensen hebben verschillende technieken voor het lezen van code, dus de strategie die ik aanbeveel, is misschien niet de beste voor jou, maar als ik dit soort lussen lees, lees ik ze normaal gesproken zo:
Met $ i begint bij nul, en terwijl $ i kleiner is dan 10, voer je de body van de lus uit, verhoog dan $ i met 1.
De vangst is dat $ i kan beginnen bij elke waarde, kan oplopen tot een willekeurig bedrag en kan met elke waarde worden verhoogd.
Hoe meer werk we doen voor loops, hoe groter de kans dat je een paar dingen gaat vangen die de prestaties kunnen optimaliseren. Voor nu echter, zijn de basisprincipes van de for-lus gedekt en zijn de geavanceerde technieken een beetje buiten het bereik van dit specifieke artikel.
foreach Loopsforeach loops lijken op for-lussen terwijl ze door een dataset heengaan, maar ze doen dit sequentieel. Dit betekent dat er geen gemakkelijke manier is om door elke, bijvoorbeeld, twee items in een lijst te bladeren (zoals je kunt met bijvoorbeeld zeggen, $ i + 2 in voor loops).
Dit type lus is aantoonbaar het meest leesbaar. Laten we voor ons voorbeeld aannemen dat we een array hebben en dat de array met de volgende namen: Alpha, Bravo, Charlie, Delta, Echo en Foxtrot. De naam van de array wordt opgeslagen in een variabele genaamd $ namen.
In dit geval kunnen we een instellen foreach lus om de namen te doorlopen en ze allemaal op het scherm weer te geven als volgt:
$ names = array ('Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot'); foreach ($ namen als $ naam) echo $ naam; Vrij eenvoudig in te stellen, nietwaar?
Net zoals we de ene manier deelden om de initiaal te lezen voor loop in het vorige gedeelte, kunt u de foreach loop op de volgende manier:
Voor elke naam in de verzameling met namen, geef deze op het scherm weer.
Of, misschien meer in het algemeen:
Voor elk element in de verzameling, geef het op het scherm weer.
Er is nog een ander aspect aan de foreach loop die we later in de serie gedetailleerder kunnen bespreken, maar het hoofdidee is dat als u bekend bent met associatieve array, dat wil zeggen, arrays die zijn geïndexeerd met een sleutel en een bijbehorende waarde hebben, u een foreach lus om elke sleutel en waarde voor elke iteratie van de lus op te halen.
Laten we zeggen dat we de volgende associatieve array hebben:
$ heroes = array ('alien' => 'Superman', 'human' => 'Batman');Wanneer u een dergelijke associatieve array gebruikt, kunt u ook a instellen foreach loop als volgt:
foreach ($ heroes als $ type => $ naam) echo $ naam. ' is een ' . Type $;
Dit zal ertoe leiden dat de uitvoer iets leest zoals 'Superman is een alien' omdat 'Superman' de waarde is en 'alien' zijn type is (of zijn sleutel).
De meer generieke vorm van deze lus is als volgt:
foreach ($ collection as $ key => value) // Work goes here
Niks vreselijk gecompliceerd.
terwijl LoopsMet de variaties van de voor loops bedekt, het is tijd om onze aandacht op te richten terwijl loops waarvan er twee variaties zijn (hoewel ze iets anders worden genoemd: terwijl loops en do loops), maar ze verschillen slechts op een minder belangrijke manier.
Maar voordat we kijken naar hoe ze verschillen, laten we eens kijken naar de terwijl loop, het basisformaat, hoe het te gebruiken en hoe het zich verhoudt tot het vorige voor loops.
Ten eerste, het basisformaat van een terwijl loop is als volgt:
while (voorwaarde) // werk
Merk op dat deze loop verschilt van onze vorige loops in die zin dat deze een conditional accepteert als onderdeel van de initiële verklaring (vandaar de reden dat we conditionals in ons laatste artikel behandelden).
De lus werkt door eerst te controleren of de voorwaarde waar is, het codeblok uit te voeren in het luslichaam en vervolgens de voorwaarde opnieuw te controleren. Dit betekent dat terwijl loops kunnen doen ieder werkeenheid zolang de opgegeven voorwaarde evolueert naar waar.
U kunt dus zeker een lijst met getallen doorlopen, een verzameling gegevens doorlopen, maar u kunt ook bepaalde dingen doen, terwijl bijvoorbeeld een booleaanse waarde nog steeds waar is. En als de vlag eenmaal false is, wordt de while-lus beëindigd.
Laten we een voorbeeld bekijken waarin we elementen van een array verwijderen. Laten we aannemen dat de eerste array 100 elementen heeft en dat we dit doen totdat de array nog 50 elementen over heeft:
while (50! == count ($ elements)) array_pop ($ elements);
Hier blijft de voorwaarde doorgaan met het evalueren van waar tot het aantal items in de $ elementen array is teruggebracht tot 50 items.
Zoals we hebben gedaan met eerdere loops, is dit een manier waarop u a kunt lezen terwijl lus:
Terwijl deze voorwaarde waar is, voert u de volgende code uit.
Natuurlijk ziet dat er hoe dan ook in code eruit, is het niet?
do LoopsTenslotte, do loops zijn bijna precies net zoals terwijl loops behalve dat er minstens één keer wordt herhaald voordat de voorwaarde wordt gecontroleerd.
Voordat u naar een voorbeeld gaat kijken, hier is de basisstructuur van de do lus:
doe // werk terwijl (conditie);
Relatief helder, toch?
Laten we dus een heel eenvoudig voorbeeld opzetten waarbij we een array maken en deze vullen met alleen even nummers. Om dit te doen, hebben we nodig:
Met dat gezegd, kan men de code instellen om er als volgt uit te zien:
$ i = 1; $ even_numbers = array (); do if (0 === ($ i% 2)) $ even_numbers [] = $ i; $ i ++; while ($ i <= 100 );
En tenslotte, zoals bij de rest van de loops, kun je dit soort loops op de volgende manier lezen:
Voer het volgende blok werk uit en controleer vervolgens of de volgende voorwaarde waar is. Als dat zo is, ga dan door met het werk.
Als het aankomt op do loops, als je met een verzameling werkt, wil je zeker weten dat de verzameling is niet leeg voordat er aan wordt gewerkt, omdat het de code in het blok van de lus zal uitvoeren voordat wordt gecontroleerd of de voorwaarde waar is. Dit kan leiden tot fouten als u probeert te werken aan een gegevensset die leeg is.
Natuurlijk, als dat is wat je van plan bent te doen, dan is een van de andere loops beter geoptimaliseerd voor dat soort operaties.
Alleen gebruiken do loops wanneer u een set gegevens hebt of u een procedure gaat uitvoeren die u weten moet ten minste één keer worden uitgevoerd voordat wordt gecontroleerd op welke voorwaarde het aantal uitvoeringen dat moet worden uitgevoerd, wordt bepaald.
Met deze dekking hebben we alles uiteengezet wat we moeten doen om een begin te maken met een bespreking van functies, attributen, reikwijdte en andere basisaspecten van objectgeoriënteerd programmeren..
.
