Object-georiënteerd programmeren in WordPress Types

Voor degenen die net met deze serie beginnen, merk op dat we object-georiënteerd programmeren bekijken met behulp van PHP in de context van WordPress.

De doelgroep

We doen dit vanuit het perspectief van de heel Beginner, dus als je een ervaren ontwikkelaar bent, of bekend bent met veel van de aspecten van objectgeoriënteerd programmeren, dan is deze serie waarschijnlijk niet voor jou.

Met dat gezegd, als jij zijn ben je geïnteresseerd in het leren van objectgeoriënteerd programmeren in PHP en beschouw je jezelf als een beginner, dan gaan we door met de serie in dit artikel door te praten over enkele gegevenstypen die PHP aanbiedt.

Maar eerst moet u ervoor zorgen dat u de vorige artikelen in de serie hebt overgenomen terwijl ze op elkaar zijn gebaseerd:

1. Invoering
2. Klassen

Als je eenmaal helemaal bent ingepakt, kunnen we beginnen te praten over typen.

Wat zijn typen?

We sloten het laatste artikel af met het volgende:

We komen daar aan, maar eerst moeten we enkele van de meer primitieve aspecten van programmeren bespreken, zoals strings, arrays, loops en conditionals..

Nu zijn strings, arrays, enzovoort, wat we typen beschouwen. Lussen en conditionals zijn zogenaamde controlestructuren die we in het volgende artikel zullen behandelen.

Laten we in de tussentijd een eenvoudige term bedenken voor wat een gegevenstype vertegenwoordigt, zodat we kunnen bepalen hoe ze conceptueel moeten worden gemodelleerd, niet alleen met dit artikel, maar ook met de rest van de inhoud in de serie.

Voor iedereen die heeft geschreven ieder code die variabelen bevat, dan heb je waarschijnlijk ongeveer het volgende geleken:

• $ name = 'Tuts + WordPress';
• $ is_active = true;
• $ leeftijd = 42;
• … enzovoorts.

In de meest eenvoudige vorm zul je de bovenstaande code waarschijnlijk horen definiëren als variabelen met definities, en dat klopt, maar het is een zeer algemene definitie.

Zie je, wanneer je een variabele definieert in PHP, dan doe je dat door de variabele vooraf in te voeren $. Hiermee weet PHP dat u een variabele definieert en dat deze een typische waarde vertegenwoordigt.

Makkelijk genoeg, toch?

Het ding is, er zijn verschillende types in PHP. Voor degenen die afkomstig zijn van zogenaamde 'sterk getypeerde talen', zullen we daar nu kortstondig over praten, maar weten dat PHP de volgende gegevenstypen biedt:

• booleans
• integers
• drijvende-kommawaarden
• strings
• arrays
• voorwerpen
• … en meer

Alles van booleans via strings kan worden beschouwd als een eenvoudig gegevenstype waarbij arrays en objecten als complexere gegevenstypen kunnen worden beschouwd.

Eenvoudige gegevenstypen

Eenvoudige gegevenstypen worden als zodanig gedefinieerd omdat de gegevens die zij vertegenwoordigen, weet u, eenvoudig. Dat wil zeggen dat het normaal onder de vlag van waar, onwaar, decimalen en woorden en / of zinnen valt.

Om concrete voorbeelden te geven van elk van de bovenstaande:

• Booleaanse waarden zijn bedoeld om de waarde van te behouden waar of vals.
• Gehele getallen verwijzen naar hele getallen. Dat wil zeggen dat het geen fractionele of decimale componenten bevat. Dit omvat nummers zoals -12, -2, 1, 100, 5000, enzovoorts.
• Drijvende-komma-getallen zijn het tegenovergestelde van Integers in die zin do vertegenwoordig waarden met gebroken delen. U zou het bijvoorbeeld kunnen zien 3,1459, 2.5, 100.25, enzovoorts. Als je probeert de waarde van bijvoorbeeld te redden, 3/4 dan zou je eigenlijk redden .75 tenzij je hebt het als een string bewaard. Dat wil zeggen, je moest redden '3/4'. Let op de subtiele scheiding tussen de twee? De ene heeft aanhalingstekens en de andere niet.
• Spreken van strings, tekenreeksen vertegenwoordigen elk afzonderlijk woord of reeks van alfanumerieke tekens waaruit een reeks letters en cijfers bestaat. Dit kan een enkel woord zijn, het kan een zin zijn, het kunnen zinnen zijn en het kan een willekeurige reeks tekens zijn, zoals een gecodeerde reeks. Voorbeelden van strings zijn onder meer: 'uitdrukkingen als deze' of een single 'woord' of zelfs iets complexer zoals 'E952098vjdkw94kd'. 

Dit is echter de valstrik: elk van de bovenstaande gegevenstypen kan worden omgezet in reeksen door ze tussen aanhalingstekens te wikkelen.

Maar er is een vangst

Bijvoorbeeld, als u zou werken met de booleaanse waarde van zeg, waar, maar u zou het in een variabele als deze moeten opslaan: $ is_active = 'waar'; dan heb je eigenlijk zojuist een string gemaakt die leest waar.

Evenzo, als u een gelezen reeks zou schrijven $ age = '42'; dan heb je een string gemaakt met het nummer 42, niet een geheel getal.

Logisch?

De reden dat dit van belang is, is dat wanneer het tijd is om met controlestructuren te werken - die we in het volgende artikel zullen bespreken - is dat een lopende vergelijking onbedoelde gevolgen kan hebben als u niet zeker weet welke gegevenstype waarmee u werkt.

Complexe gegevenstypen

Naast eenvoudige gegevenstypen hebben we ook complexe gegevenstypen die naar mijn mening niet echt zijn dat ingewikkeld. In feite vind ik het een mooie manier om te zeggen dat we manieren hebben om te bewaren meerdere stukjes informatie in een enkele variabele; terwijl we met eenvoudige typen een manier hebben om afzonderlijke stukjes informatie op te slaan in één enkele variabele.

Best gemakkelijk te onthouden, toch? Dus wat zijn enkele van de meer complexe gegevenstypen?

De twee primaire complexe datatypes waar we ons in deze reeks op zullen richten als arrays en objecten. Er zijn er meer, maar ze vallen buiten het bereik van deze serie, dus als je geïnteresseerd bent, neem dan gerust een kijkje in de PHP-handleiding, maar ik waarschuw je: als je een absolute beginner bent, kan de inhoud aanvoelen een beetje overweldigend.

• Arrays zijn manieren om meerdere stukjes informatie in een verzameling op te slaan. Overweeg even dat je een reeks namen hebt die je wilt opslaan in een verzameling die toepasselijk $ namen heet. In PHP definieert u een array en wijst u deze toe aan een variabele als deze: $ names = ['John', 'Paul', 'Ringo', 'George']; Merk op dat we een array van strings hebben, maar een ander aspect van PHP-arrays is dat ze meerdere gegevenstypen kunnen bevatten. Dat betekent dat je een array kunt hebben die eruit ziet $ various_types = [42, TRUE, 'Star Wars', .007];. Nogal cool, toch??
• Associatieve reeksen zijn net als standaard arrays die we zien, behalve dat ze zijn gemaakt van sleutelwaardeparen. Dit betekent dat elke waarde door een sleutel wordt opgehaald, dus als we de eerste array in een associatieve array zouden converteren, ziet het er ongeveer zo uit: array ('ritmegitaar' => 'John', 'bas' = > 'Paul', 'lead-gitarist' => 'George', 'drums' => 'Ringo'); Als het formaat er nu raar uitziet, maak je er dan geen zorgen over! We zullen deze later in de serie in meer detail bekijken. De primaire wegname is dat standaardarrays index numeriek zijn - dat wil zeggen, 0, 1, 2, 3, enzovoort, en bijbehorende arrays worden geïndexeerd door hun toetsen, zoals 'Rhythm-gitaar', 'Drums', enzovoorts.
• Objecten, die we de vorige keer hebben aangeraakt, zijn misschien wel de meest complexe van de gegevenstypen die door PHP worden aangeboden, omdat ze een combinatie zijn van alles. Hun kenmerken bestaan ​​uit gegevenstypen of zelfs andere objecten, het zijn functies en ze voeren bewerkingen uit, niet alleen op andere eenvoudige gegevenstypen, maar ook op complexe gegevenstypen.

Voor zover het objecten betreft, is de beste manier om te zien hoe complex ze kunnen zijn, door ze in actie te zien, wat we zeker zullen doen wanneer we een plug-in bouwen.

Een opmerking over arrays

Merk op dat in sommige talen de grootte van de array moet worden gedeclareerd voordat u deze daadwerkelijk kunt gebruiken. In C moet je bijvoorbeeld aan de compiler zeggen dat de array exact, zeg, 10 waarden bevat.

In het geval van PHP is dit niet de zaak. De array van PHP is dynamisch, wat inhoudt dat u gegevens aan de array kunt blijven toevoegen zonder de grootte ervan te hoeven vergroten. Ja, zoals met alles, er zijn limieten, maar het is meestal gerelateerd aan de grootte van de gegevens die worden opgeslagen, of de hoeveelheid geheugen die een machine beschikbaar heeft.

Laat de zinnen je niet intimideren!

Maar laat de woorden voorlopig niet liggen eenvoudig en complex intimideer je. Toegegeven, "eenvoudig" is relatief eenvoudig, toch? Maar "complex" heeft deze connotatie dat het moeilijk te begrijpen zal zijn, en dat is niet waar - hopelijk wordt in dit artikel aangetoond dat.

Complexe gegevenstypen kunnen eenvoudig meerdere gegevensstukken bevatten. Eenvoudige gegevenstypen kunnen dit niet.

Zijn er meer?

Ja er zijn. Namelijk resources, callbacks en pseudo-types. De meeste hiervan vallen buiten het bereik van deze specifieke serie; Echter, wij mei Uiteindelijk gebruiken we callbacks (een bepaald soort functies) als we onze plug-in gaan bouwen.

Neem deze gerust zo veel mogelijk door, maar weet dat ze buiten het bereik vallen van de inhoud die we in deze specifieke serie zullen behandelen, dus als je je overweldigd voelt, kun je ze misschien opnieuw bekijken zodra de serie compleet is.

Een woord over sterk typerende talen

Sommige programmeertalen zijn bekend wat dynamisch getypt (of zwak getypt) is, terwijl anderen bekend staan ​​als sterk getypeerde talen.

Dit is een ander geval waarin de terminologie vaak nieuwe programmeurs intimideert in plaats van ze te machtigen om te weten hoe de beschikbare tools te gebruiken, maar de onderscheidende factoren tussen de twee zijn eigenlijk vrij eenvoudig:

• Sterk getypeerde talen betekent dat de variabelen eerst als een bepaald type moeten worden verklaard en dat ze dat kunnen enkel en alleen een bepaald type gegevens bewaren. Als ik bijvoorbeeld een string zou willen behouden, zou ik de variabele als declareren string sMyName; Dan zou ik een string opslaan in de variabele. sMyName = 'Tom McFarlin';. Dit betekent dat de sMyName variabele kan enkel en alleen houd reeksen vast. Als u probeert een ander gegevenstype in die variabele op te slaan, geeft de compiler een foutmelding.
• Dynamisch getypeerde talen, zoals PHP, zorgen ervoor dat een enkele variabele meerdere typen kan bevatten op elk willekeurig punt van uitvoering. Door het bovenstaande voorbeeld te gebruiken, zou ik het gemakkelijk kunnen zeggen$ my_name = 'Tom McFarlin'; zoals ik kon $ my_name = false.  Als u probeert een ander gegevenstype in die variabele op te slaan, dan werkt het prima. Je kunt zien dat dit zowel voordelen als nadelen heeft.

Waar nu heen?

Voordat we terugkeren naar de wereld van objectgeoriënteerd programmeren, moeten we het hebben over een paar extra basisstructuren van programmeren, zoals controlestructuren. 

Deze omvatten dingen zoals loops, conditionals, enzovoort, die van invloed kunnen zijn op de stroom van code tijdens de levensduur van het programma. Bovendien werken ze hand in hand met de gegevenstypen die we hier hebben beschreven.

Dus voordat we naar het volgende artikel gaan, moet u controleren of alles wat hier gebeurt, opmerkingen, vragen en feedback achterlaten in de reactiefeed..

 Ik zie je in het volgende artikel!