Object-georiënteerd programmeren in WordPress Controlestructuren I

Voor degenen onder jullie die de reeks tot nu toe gevolgd hebben, dan weet je dat we object-georiënteerd programmeren specifiek vanuit het perspectief van een beginner bekijken.

Dit betekent dat we het onderwerp benaderen, niet alleen voor degenen die kijken naar hoe je aan de slag kunt met het paradigma, maar we kijken naar alle verschillende functies van PHP die de taal vormen en die uiteindelijk worden gebruikt binnen de context van objectgeoriënteerd programmeren.

Bovendien doen we dit allemaal binnen de context van WordPress, zodat we aan het einde van de serie kunnen zien hoe een praktische toepassing van hoe dit allemaal kan worden gebruikt in een echt wereldvoorbeeld.

Als dit de eerste keer is dat u een artikel in de serie leest, raad ik u aan de vorige artikelen te bekijken, aangezien elk artikel in deze serie is gebaseerd op het vorige artikel.

Tot nu toe hebben we het volgende behandeld:

Een introductie
Klassen
Types

In dit artikel gaan we praten over controlestructuren.

Wat zijn controlestructuren?

"Controlestructuren" is een fraaie term die beschrijft hoe we dat kunnen, ahum, bepaal hoe de code door ons programma stroomt op basis van een aantal factoren.

Laten we zeggen dat we bijvoorbeeld een aantal instructies willen doorlopen, maar u wilt het doen iets als een variabele is ingesteld of een andere set instructies van een andere variabele is ingesteld.

Of laten we zeggen dat je een set gegevens hebt die je doorloopt door elke waarde te lezen, elke bepaalde waarde in te stellen of zelfs bepaalde waarden te creëren.

Hoe het ook zij, de manier waarop u dit doet is door het gebruik van controlestructuren. In de rest van dit artikel gaan we twee soorten controlestructuren behandelen: voorwaardelijkheid en loops.

Hoewel conditionals en loops de typen besturingsstructuren zijn die we gaan beoordelen, zijn er subsets van elk.

Bijvoorbeeld, conditionals hebben:

als dan statements
switch / case statements

Loops, aan de andere kant, hebben nog een paar andere variaties:

voor
foreach
do
terwijl

Hoewel dit misschien nieuwe constructies zijn voor sommigen van jullie, hebben we de basisprincipes in de vorige artikelen al behandeld, dus we hebben alles dat we nodig hebben om verder te gaan.

Voorwaardelijke stellingen

Naar mijn mening zijn voorwaardelijke uitspraken enkele van de gemakkelijkst te begrijpen omdat ze meer als zinnen lezen dan veel andere soorten programmeerinstructies. Als je bijvoorbeeld letterlijk zegt 'als deze voorwaarde waar is, voer dan deze actie uit, anders doe je deze actie.'

Natuurlijk krijgt het een weinig ingewikkelder dan dat, als je bijvoorbeeld een paar andere voorwaarden moet controleren voordat je een koers kiest, maar de kern blijft hetzelfde.

Dus met dat gezegd, laten we beginnen met het bekijken van een van de twee variaties van conditionals die worden aangeboden door PHP.

`als dan` verklaringen

Zoals eerder vermeld, is de meest elementaire voorwaardelijke verklaring van de vorm if / else, en je zult het over het algemeen zo zien geschreven:

Natuurlijk verklaart dit nog steeds niet echt hoe de controlestructuur werkt, toch? Ik bedoel, natuurlijk, het biedt een beetje een skelet om er naar te kijken, maar het laat meer te wensen over.

Namelijk, wat is dit staat lijn? Ten tweede, wat zijn de handelwijzen die de controlestructuur kan nemen?

Eerst de staat verwijst naar elke instructie die kan worden geëvalueerd als een Booleaanse uitdrukking. Heb je zin? Simpel gezegd, staat vertegenwoordigt elke verklaring die kan worden geëvalueerd als waar of vals.

Laten we dus zeggen dat we twee waarden hebben:

$ is_active
$ TOTAL_COUNT

Dit zijn duidelijk enigszins generieke waarden, maar laten we zeggen dat als $ is_active is ingesteld op true, dan verhogen we de $ TOTAL_COUNT bij een; anders trekken we de $ TOTAL_COUNT bij een.

Dit is hoe het er in de code uitziet:

In het bovenstaande voorbeeld, $ TOTAL_COUNT wordt met één verhoogd omdat $ is_active evalueert naar waar.

Of laten we zeggen $ is_active ingesteld op vals.

In deze voorbeeld, $ TOTAL_COUNT wordt met één verlaagd omdat $ is_active evalueert naar false.

Voordat we naar het volgende voorbeeld kijken, is het belangrijk om te begrijpen dat dit buitengewoon triviale voorbeelden zijn. Het doel van deze voorbeelden is niet om te laten zien hoe complexe operaties moeten worden uitgevoerd en om ze te combineren in de voorwaardelijke constructies, maar in plaats daarvan hoe gebruik de voorwaardelijke constructies.

Wanneer we bij het deel van de serie komen dat begint met het schrijven van een plug-in, dan zul je zien hoe we meer uitgebreide uitdrukkingen kunnen gebruiken in een praktische toepassing.

Met dat gezegd, laten we nog een voorbeeld van if / then-statements bekijken. In dit voorbeeld nemen we een kijkje op if / elseif / else. Laten we aannemen dat we aan de slag gaan $ is_active is ingesteld op waar en $ TOTAL_COUNT is ingesteld op 10.

= 10) $ total_count = $ total_count + 1 else $ total_count = $ total_count - 1;

De bovenstaande code kan als volgt gelezen worden:

Als $ is_active is ingesteld op true en stelt u de waarde in $ TOTAL_COUNT tot een. $ is_active is niet waar.
Anders, als de $ TOTAL_COUNT is groter dan of gelijk aan 10, verhoog dan de $ TOTAL_COUNT door 1. Het $ TOTAL_COUNT is gelijk aan 10, dus we verhogen de $ TOTAL_COUNT tot 11.
Als $ TOTAL_COUNT was niet groter dan of gelijk aan 10, dan zouden we de $ TOTAL_COUNT bij een.

Tegen de tijd dat het codeblok is voltooid in het bovenstaande voorbeeld, $ TOTAL_COUNT zal gelijk zijn aan 11.

Logisch?

Dit is de reden waarom we deze controlestructuren noemen: deze verklaringen (of evaluaties) stellen ons in staat om te bepalen welke code moet worden uitgevoerd op basis van bepaalde voorwaarden.

Voor degenen die al een tijdje programmeren, bent u bekend met complexere expressies met operators zoals && en || enzovoorts. Uiteindelijk komen we daar aan, maar niet in dit artikel.

Dat alles, het is een onderwerp dat ik me bewust ben en dat we zullen behandelen, maar niet vandaag.

Nog iets anders?

Voor degenen onder u die meer ervaring hebben met programmeren, dan bent u waarschijnlijk bekend met de ternaire operator.

We gaan hier niet naar kijken in deze specifieke serie artikelen omdat het buiten het bereik valt van wat we willen behandelen; echter, als je avontuurlijk bent en op zoek bent naar een meer beknopte manier om een eenvoudig te schrijven if / else en controleer vervolgens de ternaire operator in de PHP-handleiding.

`switch / case` verklaringen

Met dat gezegd, is er nog een soort van voorwaardelijke die we moeten bekijken voordat we verder gaan met het volgende onderwerp.

Dit specifieke construct valt nog steeds onder voorwaardelijke verklaringen; ik zou echter beweren dat je het minder vaak zou gebruiken dan het if / else tegenhanger.

Zoals de titel aangeeft, wordt dit het switch / case uitspraak. Hoewel ik persoonlijk vind dat de taal het een beetje ingewikkelder maakt om te volgen, verschilt de manier waarop controle door de evaluaties stroomt niet veel van wat we al hebben gezien.

Zoals we deden met de if / else statements, laten we eerst kijken hoe het switch / case is gestructureerd en dan zullen we een paar triviale voorbeelden bekijken.

Het eerste dat opvalt aan dit specifieke type conditionele, is dat de evaluatie gebeurt op één plek: bovenaan het codeblok pal naast de schakelaar uitspraak.

Hier gebeurt de evaluatie eenmaal en vervolgens elk van de volgende geval uitspraken is wat dicteert welke actie wordt ondernomen. Er is ook een breken verklaring opgenomen bij elk van de verklaringen die we zullen bespreken, en er is ook een standaard blok code onderaan dat we aan het eind van het artikel zullen bespreken.

Maar voordat we een van die dingen gaan doen, laten we een iets praktischer voorbeeld van een standaard instellen switch / case verklaring ziet eruit als.

Laten we aannemen dat we een waarde hebben, $ first_name, en dan willen we een bepaalde gedragslijn volgen op basis van de voornaam van de persoon. In dit voorbeeld stellen we het e-mailadres van een persoon in op basis van zijn voornaam. Als we de voornaam van de persoon niet herkennen, stellen we de waarde gelijk aan nul.

Natuurlijk, het is een beetje een gekunsteld voorbeeld, maar het zal het punt laten zien:

Laten we kijken naar de stroom van controle in het bovenstaande voorbeeld:

We definiëren een $ persons_name als 'Tom' en we initialiseren de $ email_address als een lege string.
We passeren dan de $ persons_name naar de switch-instructie voor evaluatie.
De besturingsstructuur zal de $ persons_name tegen elke waarde die is opgegeven in de case-statement.
Omdat 'Tom' de waarde is van de $ persons_name, dan de $ email_address wordt ingesteld op '[email protected]'

Als we 'David' zouden doorgeven als de $ persons_name dan $ email_address zou worden ingesteld op '[email protected]'.

Vervolgens, als we zouden passeren ieder andere naam dan 'Tom' of 'David', dan de $ email_address zou worden ingesteld op NUL. Het is ook belangrijk om dat op te merken switch / case is hoofdlettergevoelig. Dit betekent dat als je 'tom' zou doorgeven in plaats van 'Tom', ze dan als verschillende gevallen behandeld zouden worden.

Merk tot slot op dat elk geval eindigt met een breken uitspraak. Dit is belangrijk omdat breken instrueert de code om uit de switch / case verklaring en ga verder met het werken aan welke code dan ook.

Het is buitengewoon belangrijk om te begrijpen dat als je een break-statement vergeet, deze meteen naar de volgende case-statement die uiteraard grillige resultaten kan hebben (zoals verkeerd instellen $ email_address).

Een voorbeeld van waar u dit in uw voordeel kunt gebruiken, is als volgt:

In het bovenstaande voorbeeld hebben we gevallen gedefinieerd voor zowel 'Tom' als het kleine letters zijn of als de eerste letter met een hoofdletter is geschreven en wordt getoond hoe de code door zal vallen naar de volgende geval uitspraak.

Maar er is een nog betere manier om dit kogelvrij te maken:

Merk op dat dit de PHP-functie vereist strtolower om de inkomende te forceren $ persons_name om volledig te worden verlaagd. Dit stelt ons in staat onze case statements nog verder te verfijnen.

What's Up Next?

In dit artikel hebben we gekeken naar de eerste van twee groepen besturingsstructuren die voor ons beschikbaar zijn in PHP. Nee, deze maken niet expliciet deel uit van objectgeoriënteerd programmeren, maar voordat we daadwerkelijk over meer fundamentele aspecten van het paradigma gaan praten, moeten we alle fijne punten begrijpen die ons in staat stellen objectgeoriënteerde code te schrijven.

Daarom gaan we deze discussie over besturingsstructuren in het volgende artikel voortzetten door naar loops te kijken.

Daarna zijn we klaar om onze aandacht op functies te richten. Voor degenen die vertrouwd zijn met procedureel programmeren, zijn functies niet nieuw; Als u echter nog niet bekend bent met objectgeoriënteerde programmering, zijn er een aantal factoren die hen onderscheiden van hoe ze worden gebruikt bij procedureel programmeren..

Dus dat is de routekaart voor de volgende reeks artikelen. Zoals altijd is feedback altijd welkom en ik zie ernaar uit om verder te praten in het volgende artikel.

Code