Object-georiënteerd programmeren in WordPress bereik

Als we onze discussie over objectgeoriënteerd programmeren in WordPress voortzetten, moeten we beginnen te praten over het idee van bereik. In het kort: dit verwijst naar het idee dat klassen kunnen bepalen hoe hun attributen en functies worden benaderd (of ze al dan niet toegankelijk zijn).

Dit is nog een ander kernidee van objectgeoriënteerd programmeren, waarna we in goede vorm moeten zijn om aan een echte WordPress plug-in te werken..

Houd er rekening mee dat elk artikel in deze serie vóór het begin van de reeks is gebaseerd op het vorige artikel, dus als u net met ons meedoet, moet u de eerdere artikelen in de serie bekijken:

1. Een introductie
2. Klassen
3. Types
4. Controlestructuren: voorwaardelijke overzichten
5. Besturingsstructuren: lussen
6. Functies en kenmerken

Laten we, als jullie allemaal zijn ingehaald, verder gaan met onze discussie over het laatste stukje van het paradigma dat we nodig hebben voordat we de praktische toepassing van objectgeoriënteerd programmeren in WordPress gaan begrijpen..

Scope definiëren

Volgens de Wikipedia is de eerste definitie van de reikwijdte als volgt:

Bij computerprogrammering is de reikwijdte van een naambinding - een associatie van een naam met een entiteit, zoals een variabele - het deel van een computerprogramma waar de binding geldig is: waar de naam kan worden gebruikt om naar de entiteit te verwijzen. In andere delen van het programma kan de naam verwijzen naar een andere entiteit (het kan een andere binding hebben), of helemaal niets (het kan ongebonden zijn).

Tenzij je een ervaren programmeur bent, is dit een beetje verwarrend, toch? In feite kan het zelfs lezen als een beetje jargon.

Maar dat is goed, want het doel van dit artikel is om een ​​werkdefinitie van de reikwijdte te geven, evenals enkele praktische voorbeelden over hoe het eruit ziet in de context van een programma.

Dus, voordat we kijken naar de drie verschillende aspecten van bereik in objectgeoriënteerd programmeren, laten we een schonere definitie formuleren. 

Kort gezegd, scope verwijst naar hoe variabelen en functies toegang kunnen krijgen van objecten van derden of onderliggende objecten binnen het programma. 

Stel bijvoorbeeld dat u een Blogpost object en een Schrijver voorwerp. Laten we vervolgens stellen dat de auteur attributen heeft voor Voornaam en achternaam en de Blogpost wil toegang krijgen om ze bijvoorbeeld op het scherm te tonen.

Misschien zou een illustratie op hoog niveau helpen:

In deze post, de Blogpost vraagt ​​naaminformatie aan bij de Schrijver klasse. Merk op dat in het bovenstaande diagram de klassennaam in de eerste blog staat, de attributen in het tweede blok, en dat de lege derde blokken meestal gereserveerd zijn voor functies.

Maar dat gaat verder dan het, ahum, reikwijdte van dit artikel.

Let op: klassen vertegenwoordigen meestal zelfstandige naamwoorden, attributen vertegenwoordigen bijvoeglijke naamwoorden en functies vertegenwoordigen werkwoorden of acties die het object kan uitvoeren. Daartoe bevatten klassen gewoonlijk hun informatie op strategische manieren zodanig dat hoe ze werken wordt verborgen gehouden en wat ze kunnen doen, wordt aangetoond door hun publiekelijk beschikbare functies.

Hiertoe moeten variabelen en functies een bepaalde scope krijgen die andere objecten toegang geeft tot hun informatie. Dit type objecten omvat objecten van derden die gebruik willen maken van de gegevens die worden vertegenwoordigd door een klasse, en een ander type object vertegenwoordigt een object dat erft informatie uit die klasse.

Overerving gaat verder dan wat we in dit specifieke artikel gaan behandelen; we zullen dit echter een beetje later in de serie behandelen voor degenen die helemaal nieuw zijn in objectgeoriënteerd programmeren.

Dus, met dat gezegd, zijn we klaar om een ​​kijkje te nemen naar een praktisch voorbeeld van de reikwijdte, inclusief hoe we het tot nu toe in de serie hebben gebruikt en hoe het ontwerpbeslissingen beïnvloedt..

Alles over openbaar, privé en beschermd

De bovenstaande primer had op zijn minst een hoog niveau moeten uitleggen wat de reikwijdte is en hoe het ertoe doet, maar als dat niet het geval is, zullen de volgende paragrafen misschien.

We gaan specifiek kijken naar elk type bereik dat variabelen en functies kunnen hebben, we gaan uitleggen wat elk bereik inhoudt, en we gaan uitleggen wanneer je wilt gebruiken elke.

Voordat we verder gaan, merk op dat het openbaar, beschermde, en privaat sleutelwoorden kunnen worden gebruikt om beide kenmerken in te vullen en functies. Dit is van belang omdat de regels die van toepassing zijn op kenmerken ook van toepassing zijn op functies.

Met dat gezegd, laten we een kijkje nemen op elk van de zoekwoorden.

Openbaar

Simpel gezegd, openbaar attributen en functies zijn beschikbaar voor elk type object dat probeert toegang te krijgen tot de variabele of de functie.

Bijvoorbeeld:

first_name = $ naam;  public function set_last_name ($ name) $ this-> last_name = $ name;  openbare functie get_first_name () return $ this-> first_name;  public function get_last_name () return $ this-> last_name;  // Overige klassegegevens ...

Met deze opstelling kan elk object dat een instantie van dit object aanroept, niet alleen toegang krijgen tot het $ first_name en $ last_name attributen, maar kan ook verandering hen. Evenzo kan elk object dat een instantie van een object aanroept, toegang krijgen tot de functies om de naam op te halen en de naam te wijzigen.

Dus werpt het de vraag op: Wat heeft het voor zin om deze functies te hebben als het attribuut openbaar wordt gemaakt? Ik bedoel, het is overbodig, toch? Ja. En we zullen het later in het artikel beantwoorden zodra we het hebben over de privaat trefwoord.

beschermde

volgende, beschermde attributen en functies zijn beschikbaar binnen de context van de klasse waarin ze zijn gedefinieerd, maar niet voor objecten van derden. Dat gezegd hebbende, zij kan vanuit hun eigen klas worden aangeroepen, maar niet van externe klassen.

first_name = $ naam;  beschermde functie set_last_name ($ naam) $ this-> last_name = $ name;  beschermde functie get_first_name () return $ this-> first_name;  beschermde functie get_last_name () return $ this-> last_name;  // Overige klassegegevens ...

Maar er is een uitzondering: subklassen. 

Laten we zeggen dat u bijvoorbeeld een klasse met de naam definieert Bijdrager welke een subklasse is van Schrijver, dit betekent dat de Bijdrager heeft toegang tot allemaal van de beschermde (en openbaar) attributen en functies van de bovenliggende klasse.

Gegeven de bovenstaande code betekent dit dat je methoden zoals kunt aanroepen get_first_name () van binnen de Schrijver klas of binnen de Bijdrager klasse maar niet van externe klassen.
Toegegeven, subklassen hebben meer te maken met overerving, iets waar we later in de serie over zullen praten; nochtans, breng ik dit omhoog om een ​​belangrijke verduidelijking tussen te verstrekken openbaar attributen en functies en privaat attributen en functies.
Privaat
Kortom, privaat attributen en functies vergrendelen de attributen en functies in de klasse waarin ze zijn gedefinieerd. Dit betekent dat geen enkel extern object of subklassen toegang heeft ieder van de informatie.
Het is duidelijk dat dit de striktste vorm van bereik is, maar dat moet niet worden gelezen alsof het een slechte zaak (of een goede zaak) is. In plaats daarvan is het bedoeld om een ​​manier te bieden waarop bepaalde informatie verborgen (of geabstraheerd) kan blijven binnen de context van de klasse waarin deze is gedefinieerd.
Om terug te keren naar ons eerste voorbeeld, laten we eens kijken hoe we de klasse zodanig kunnen refactoren dat deze de maximale hoeveelheid hulpprogramma biedt voor zowel externe klassen als subklassen..
first_name = $ naam;  persoonlijke functie set_last_name ($ naam) $ this-> last_name = $ name;  private function get_first_name () return $ this-> first_name;  private function get_last_name () return $ this-> last_name;  // Overige klassegegevens ...
Ten eerste toont dit voorbeeld een slecht gebruik van de privaat trefwoord. 
In dit voorbeeld zijn niet alleen de kenmerken ontoegankelijk, maar zijn de functies ook niet toegankelijk. Met andere woorden, voor andere objecten in 'de buitenwereld' lijkt deze klasse niets beschikbaar te hebben. Erger nog, zelfs subklassen hebben geen toegang tot deze informatie.
Kortom, de code is niet echt logisch.
Dus, laten we dit een beetje refactiveren maar meer zodanig dat het attribuut verborgen blijft (en dus niet toegankelijk is voor objecten van derden), en we zullen een manier specificeren voor objecten van derden om de namen op te halen, maar zullen enkel en alleen laat de feitelijke klasse en zijn subklassen deze veranderen:
Voornaam;  public function get_last_name () return $ this-> last_name;  // Overige klassegegevens ...
Dit is natuurlijk slechts een voorbeeld. Het is duidelijk dat we sommige implementatiedetails weglaten, zodat we dat niet doen weet welke details kunnen vragen om bijvoorbeeld de namen die moeten worden bijgewerkt. 
Maar het doet er niet toe: dit toont een volledig voorbeeld van hoe privaat, beschermde, en openbaar scopedische aspecten van een klas kunnen in combinatie met elkaar werken om een ​​veilige, strategische manier voor toegang tot informatie te bieden.
Abstractie en informatie verbergen
Wat de reikwijdte betreft, kun je het argument verdedigen dat het allemaal neerkomt op abstractie en informatie verbergen. 
Dat wil zeggen dat klassen (die blauwdrukken zijn voor objecten, als je je herinnert uit onze eerdere artikelen) hun informatie strategisch moeten organiseren, zodat:
 
informatie die zou moeten enkel en alleen toegankelijk zijn en relevant zijn voor het moet blijven privaat 
 
informatie die alleen toegankelijk zou moeten zijn en de subklassen daarvan, moeten worden beschermd
 
informatie die toegankelijk zou moeten zijn voor objecten van derden moet openbaar zijn
 
Sterker nog, ik zal een stap verder gaan en zeggen dat het niet waarschijnlijk is dat veel kenmerken worden gemarkeerd als openbaar. In plaats daarvan ziet u eerder de kenmerken die zijn gemarkeerd met beschermde - voor subdoelen - of privaat, zodat hun gegevens kunnen worden beheerd door functies die op de juiste manier worden ingevuld. 
In eerste instantie klinkt dit relatief eenvoudig, toch? En het concept zelf is niet erg ingewikkeld, maar als het gaat om het bouwen van systemen die afhankelijk zijn van een aantal verschillende objecten die allemaal samenwerken om solide abstractie te bieden, schone interfaces waarop klassen en subklassen van derden ermee kunnen werken, en efficiënte manieren van het organiseren van informatie, kan het een grotere uitdaging worden - er zijn veel bewegende delen om te overwegen.
Dat gezegd hebbende, dit is een van die dingen die het schrijven van code, interactie met andere ontwikkelaars en het lezen van code ervaring kan kweken. 
Voor wat het waard is, ben ik niet bang om toe te geven dat dit nog steeds strategieën zijn waarmee ik niet worstel, omdat ik de concepten niet begrijp, maar omdat het moeilijk kan zijn om de schoonste klasse-implementatie te bieden, vooral in een systeem dat is geneigd te veranderen.
Maar dat is inhoud voor een andere post.
Als u vragen of opmerkingen heeft over iets over het onderwerp, aarzel dan niet om ze in de opmerkingen achter te laten.
Wat is het volgende?
Vanaf het volgende artikel gaan we beginnen met het opnemen van een deel van deze informatie in een praktische toepassing van het bouwen van een WordPress-plug-in.
Dus voor degenen onder u die hebben gewacht om te zien hoe deze serie werkt in combinatie met WordPress, moet het volgende artikel beginnen alle concepten samen te brengen terwijl we de serie voortzetten met onze eigen WordPress plug-in met behulp van het concept van objectgeoriënteerd programmeren.



		
			
	   
	




Code