JavaScript este un limbaj multi-paradigmă și poate fi scris urmând diferite paradigme de programare. O paradigmă de programare este în esență o grămadă de reguli pe care le urmați atunci când scrieți cod, pentru a vă ajuta să rezolvați o anumită problemă.

Asta sunt cei patru stâlpi. Sunt principii de proiectare software pentru a vă ajuta să scrieți un cod orientat obiect.

Cei patru piloni ai programării orientate pe obiecte sunt:

  • Abstracție
  • Incapsularea
  • Moştenire
  • Polimorfism

Să aruncăm o privire mai atentă la fiecare dintre ele.

Abstracție în programarea orientată pe obiecte

A abstra ceva departe înseamnă a ascunde detaliile implementării în interiorul a ceva – uneori un prototip, alteori o funcție. Deci, atunci când apelați funcția, nu trebuie să înțelegeți exact ce face.

Dacă ar fi să înțelegeți fiecare funcție dintr-o bază de cod mare, nu ați codifica niciodată nimic. Ar dura luni de zile pentru a termina de citit totul.

Puteți crea o bază de cod reutilizabilă, ușor de înțeles și ușor de modificat, abstractizând anumite detalii. Permiteți-mi să vă dau un exemplu:

function hitAPI(type){
	if (type instanceof InitialLoad) {
		// Implementation example
	} else if (type instanceof NavBar) {
		// Implementation example
	} else {
		// Implementation example
	}
}
Acest lucru nu este deloc abstractizat.

Puteți vedea în exemplu cum trebuie să implementați exact ceea ce aveți nevoie pentru cazul dvs. de utilizare personalizat?

Fiecare API nou pe care trebuie să îl atingeți are nevoie de un nou if bloc și este propriul cod personalizat. Acest lucru nu este abstractizat, deoarece trebuie să vă faceți griji cu privire la implementare pentru fiecare tip nou pe care îl adăugați. Nu este refolosibil și este un coșmar de întreținere.

Ce zici de ceva de genul de mai jos?

hitApi('www.kealanparr.com', HTTPMethod.Get)

Acum puteți doar să transmiteți o adresă URL funcției dvs. și ce metodă HTTP doriți să utilizați și ați terminat.

Nu trebuie să vă faceți griji cu privire la modul în care funcționează funcția. Este tratat. Acest lucru ajută masiv refolosirea codului! Și face codul dvs. mult mai ușor de întreținut.

Asta este Abstracție e totul despre. Găsirea lucrurilor similare în codul dvs. și furnizarea unei funcții sau a unui obiect generic pentru a servi mai multe locuri / cu preocupări multiple.

Iată un bun exemplu final de Abstracție: imaginați-vă dacă creați o mașină pentru a face cafea pentru utilizatorii dvs. Ar putea exista două abordări:

Cum să-l creați cu abstractizare

  • Aveți un buton cu titlul „Faceți cafea”

Cum să-l creați fără abstractizare

  • Aveți un buton cu titlul „Fierbeți apa”
  • Aveți un buton cu titlul „Adăugați apă rece în ceainic”
  • Aveți un buton cu titlul „Adăugați 1 lingură de cafea măcinată într-o ceașcă curată”
  • Aveți un buton cu titlul „Curățați cupele murdare”
  • Și toate celelalte butoane

Este un exemplu foarte simplu, dar prima abordare rezumate îndepărtează logica în mașină. Dar a doua abordare îl obligă pe utilizator să înțeleagă cum să facă cafea și, în esență, să-și facă propria lor.

Următorul pilon ne arată o modalitate prin care putem realiza Abstracție, prin utilizarea Incapsularea.

Incapsularea în programarea orientată pe obiecte

Definiția încapsulării este „acțiunea de a încadra ceva într-o capsulă sau parcă”. Îndepărtarea accesului la părți din codul dvs. și transformarea privată a lucrurilor este exact ceea ce Incapsularea este vorba despre (de multe ori, oamenii se referă la aceasta drept ascunderea datelor).

Incapsularea înseamnă că fiecare obiect din codul dvs. ar trebui să-și controleze propria stare. Starea este „instantaneul” actual al obiectului dvs. Cheile, metodele obiectului dvs., proprietățile booleene și așa mai departe. Dacă ar fi să resetați un Boolean sau să ștergeți o cheie din obiect, toate acestea vor fi modificări ale stării dvs.

Limitați la ce fragmente din codul dvs. poate accesa. Faceți mai multe lucruri inaccesibile, dacă nu sunt necesare.

Proprietățile private sunt realizate în JavaScript utilizând închideri. Iată un exemplu mai jos:

var Dog = (function () {

	// Private
	var play = function () {
		// play implementation
	};
    
	// Private
	var breed = "Dalmatian"
    
	// Public
	var name = "Rex";

	// Public
	var makeNoise = function () {
 		return 'Bark bark!';
	};

 	return {
		makeNoise: makeNoise,
		name: name
 	};
})();

Primul lucru pe care l-am făcut a fost să creăm o funcție care este numită imediat (numită an Expresia funcției invocată imediat, sau IIFE pe scurt). Aceasta a creat un obiect pe care oricine îl poate accesa, dar a ascuns unele dintre detalii. Nu poți suna play și nu puteți accesa breed deoarece nu l-am expus în obiectul final cu returnarea.

Acest model particular de mai sus se numește Model de modul revelator, dar este doar un exemplu al modului în care puteți realiza Incapsularea.

Vreau să mă concentrez mai mult pe ideea de Incapsularea (deoarece este mai important decât să înveți un singur model și să numeri Incapsularea ca total complet acum).

Reflectați și gândiți-vă mai multe despre cum puteți ascunde datele și codul și să le separați. Modularizarea și responsabilitățile clare sunt esențiale pentru Orientarea obiectelor.

De ce ar trebui să preferăm confidențialitatea? De ce nu avem totul global?

  • O mulțime de biți de cod fără legătură vor deveni dependenți / cuplați între ei prin intermediul variabilei globale.
  • Probabil că veți înlocui variabilele dacă numele este reutilizat, ceea ce poate duce la erori sau la un comportament imprevizibil.
  • Probabil vei ajunge cu Codul spaghetelor – cod greu de argumentat și de urmărit ceea ce citește și scrie în variabilele tale și starea în schimbare.

Incapsularea poate fi aplicată prin separarea liniilor lungi de cod în funcții separate mai mici. Separați aceste funcții în module. Ascundem datele într-un loc în care nu are nevoie altceva acces și expunem în mod curat ceea ce este necesar.

Acesta este Incapsularea este o coajă de nucă. Legarea datelor dvs. la ceva, indiferent dacă este vorba de o clasă, obiect, modul sau funcție și faceți tot posibilul pentru a le păstra cât mai private cât puteți în mod rezonabil.

Moștenirea în programarea orientată pe obiecte

Moștenirea permite unui obiect să dobândească proprietățile și metodele altui obiect. În JavaScript acest lucru este realizat de Moștenirea prototipală.

Reutilizarea este principalul beneficiu aici. Știm uneori că mai multe locuri trebuie să facă același lucru și trebuie să facă totul la fel, cu excepția unei părți mici. Aceasta este o problemă pe care moștenirea o poate rezolva.

Ori de câte ori folosim moștenirea, încercăm să o facem astfel încât părintele și copilul să aibă coeziune ridicată. Coeziune este cât de legat este codul dvs. De exemplu, face Bird tip extinde de la DieselEngine tip?

Păstrați moștenirea dvs. ușor de înțeles și previzibilă. Nu moșteniți de undeva complet fără legătură deoarece există o metodă sau o proprietate de care aveți nevoie. Moștenirea nu rezolvă bine această problemă.

Atunci când utilizați moștenirea, ar trebui să solicitați cea mai mare parte a funcționalității (nu întotdeauna aveți nevoie absolut de tot).

Dezvoltatorii au un principiu numit Principiul substituției Liskov. Se afirmă că, dacă puteți utiliza o clasă părinte (să o numim ParentType) oriunde folosiți un copil (să-l numim ChildType) – și ChildType moștenește din ParentType – apoi treci testul.

Principalul motiv pentru care ați eșua acest test este dacă ChildType îndepărtează lucrurile de la părinte. Dacă ChildType eliminat metodele pe care le-a moștenit de la părinte, ar duce la TypeErroracolo unde lucrurile sunt nedefinite pe care te aștepți să nu le fie.

Cei patru piloni ai programarii orientate pe obiecte
Săgețile par că merg pe un drum greșit. Dar Animalul este baza – părintele.

Lanțul de moștenire este termenul folosit pentru a descrie fluxul de moștenire de la prototipul obiectului de bază (cel din care moștenește orice altceva) până la „sfârșitul” lanțului de moștenire (ultimul tip care moștenește – Câine în exemplul de mai sus).

Faceți tot posibilul pentru a vă menține lanțurile de moștenire curate și sensibile. Puteți termina cu ușurință codificarea unui anti-tipare atunci când utilizați Moștenire (numit Anti-model de bază fragilă). Acest lucru se întâmplă în cazul în care prototipurile dvs. de bază sunt considerate „fragile” deoarece faceți o schimbare „sigură” a obiectului de bază și apoi începeți să vă rupeți toți copiii.

Polimorfismul în programarea orientată pe obiecte

Polimorfism înseamnă „condiția de a se produce în mai multe forme diferite”. Este exact ceea ce se referă la al patrulea și ultimul pilon – tipurile din aceleași lanțuri de moștenire fiind capabile să facă lucruri diferite.

Dacă ați folosit corect moștenirea, acum puteți folosi în mod fiabil părinți precum copiii lor. Când două tipuri partajează un lanț de moștenire, acestea pot fi utilizate în mod interschimbabil, fără erori sau afirmații în codul dvs.

Din ultima diagramă, am putea avea un prototip de bază numit Animal care definește makeNoise. Apoi, fiecare tip care se extinde de la acel prototip poate suprascrie pentru a-și face propria lucrare personalizată. Ceva de genul:

// Let's set up an Animal and Dog example
function Animal(){}
function Dog(){}

Animal.prototype.makeNoise = function(){
	console.log("Base noise");
};

// Most animals we code up have 4. This can be overridden if needed
Animal.prototype.legs = 4;

Dog.prototype = new Animal();

Dog.prototype.makeNoise = function(){
	console.log("Woof woof");  
};

var animal = new Animal();
var dog = new Dog();

animal.makeNoise(); // Base noise
dog.makeNoise();    // Woof woof- this was overridden
dog.legs;           // 4! This was inherited

Dog se extinde de la Animal și poate folosi valoarea implicită legs proprietate. Dar este, de asemenea, capabil să-și facă propria implementare pentru a-și face propriul zgomot.

Puterea reală a polimorfismului este împărtășirea comportamentelor și permiterea modificărilor personalizate.

Concluzie

Sper că acest lucru a explicat care sunt cei patru piloni ai programării orientate pe obiecte și modul în care acestea conduc la un cod mai curat și mai robust.

Îmi împărtășesc scrisul Stare de nervozitate dacă ți-a plăcut acest articol și vrei să vezi mai multe.