Använda klasser i CoffeeScript

En av de viktigaste sakerna som hjälper oss att definiera vår applikation är användningen av klasser, eftersom vi med dem kan definiera objekt modellerade från det verkliga livet och deras passage till den digitala världen blir mycket lättare.
I CoffeeScript att bygga en klass och instansera den är väldigt enkel, i själva verket är dess syntax så minimalistisk att det är mycket lätt för oss att komma ihåg den, istället för att göra en definition av klasser direkt i JavaScript Det är något lite mer besvärligt och som kan ta oss längre tid än väntat.
KravFör att slutföra denna handledning måste vi ha en funktionell installation av CoffeeScript, vi behöver också behörigheter för att skriva filer och köra CoffeeScript på datorn där vi gör handledningen. Vi behöver en textredigerare för att kunna skriva koden som vi ska utföra så att vi har något ihållande och inte allt i konsolen.
En klass är inget annat än ett namn och några egenskaper som definierar dess beteende, baserat på det konceptet kan vi definiera en klass i CoffeeScript som följer:

 klass Student

Det är allt vi behöver göra, på ett enkelt sätt har vi redan byggt in vår första klass CoffeeScriptVad händer nu om vi vill inkludera en egenskap för att kunna använda den, eftersom vi helt enkelt gör en instans och lägger till den egenskapen, låt oss se:

 student = ny Student () student.name = "Carolina"

Låt oss nu se hur i följande bild som CoffeeScript förvandla all vår kod till JavaScript ren vid kompilering, låt oss komma ihåg kommandot för detta som skulle vara kaffe -c filnamn. kaffe:

Vi märker sedan hur syntaxen för JavaScript ren är mycket mer omfattande och komplex än de tre kodraderna vi gjorde i CoffeeScript, detta är kraften i detta språk som låter oss verkligen ägna oss åt vår applikation.
En av de saker som används mest i Objektorienterad programmering är att lägga till metoder för klasser, eftersom dessa, förutom egenskaperna, kommer att ge oss en uppfattning om vad vårt objekt kan eller inte kan göra, till exempel om vi fortsätter med Studentklass Vi kan skapa en metod för det där dess objekt uttrycker ett budskap, låt oss se hur vi uppnår det:

 klass Studenttal: -> console.log "Hej världen!"

Om vi ​​sedan skapar ett objekt av samma klass kan vi redan använda samma metod. Till exempel:

 student = ny Studentstudent.talk ()

Med detta ser vi till att vår metod kan användas många gånger, så länge vi gör flera instanser, vilket ger vår kod en av egenskaperna för objektorientering, vilket är återanvändning. Nu ska vi omdefiniera vår kod så att den accepterar argument, med detta kan vi göra mycket mer än en enkel utskrift per konsol, låt oss se:

 klass Studentprat: (namn) -> console.log "Hej # {namn}!" student = ny Studentstudent.talk ("Carolina")

Låt oss se hur allt detta översätts till kod JavaScript när vi sammanställer:

Något viktigt som vi kan göra när vi konstruerar objekt som härrör från klasser är att behålla deras värde under deras liv i vår applikation, med detta kan vi göra komponenter som kan komma åt deras egenskaper genom metoder och därmed använda dem i olika delar av vår applikation.
För att manipulera en egendom inom CoffeeScript vi måste bara använda @ operatör följt av namnet på den egendom som ska användas, som kan kodas enligt följande:

 klass Studenttal: () -> console.log “Hej # {@ name}!” student = ny Student () student.name = “Carolina” -student. speak ()

Låt oss se hur det ser ut när det körs direkt i konsolen:

När detta är gjort, låt oss se hur vår kompilerade kod ser ut JavaScript ren:

Skillnaden i mängden kod är anmärkningsvärd och bara för att göra något så enkelt som att definiera en klass med en metod, sedan instansera den och ringa den skapade metoden.
Det finns tillfällen som definitionen av vår klass leder oss till att skapa metoder som måste kallas inom andra, detta för att uppnå en mindre repetitiv och mer funktionell programmering, låt oss se hur vi kan göra det genom att använda följande kod skriven i CoffeeScript.

 klass Studenttal: () -> console.log "Hej jag heter: # {@ name}!" @knowAge () knowAge: () -> console.log "Min ålder är: # {@ age}" student = ny Student () student.name = "Vanessa" student.age = “23” student.talk ()

Låt oss se hur vi i konsolen kan se resultatet av körningen av den tidigare koden:

Hittills har vi definierat objektets egenskaper efter att ha initierat det, även om det är en livskraftig praxis, när vi måste skapa objekt med många egenskaper kan det vara svårt att underhålla.
Det bästa i de fall där vi måste arbeta med många objekt och många egenskaper är att kunna använda kraften i byggareMed dem kan vi ge liv åt vårt objekt direkt utan att behöva definiera de olika egenskaperna på ett "manuellt" sätt. För att definiera en konstruktör, använd en struktur som liknar följande:

 klass Studentkonstruktör: (namn, ålder) -> @namn = namn @ålder = ålder tala: () -> console.log "Hej jag heter: # { @namn}!" @saberEdad () saberEdad: () -> console.log "Min ålder är: # {@ age}"

Om vi ​​tittar på klassens definition är konstruktören inget annat än en metod, det intressanta är att när den kallas byggare redan CoffeeScript den vet att det är en speciell metod för vår klass och den kommer att behandla den som sådan, det är därför vi inte behöver kalla det uttryckligen när vi ska skapa instanser av vår klass. Låt oss se ett exempel på hur vi nu kan definiera våra objekt:

 student = ny Student ("Carolina", "26") student.speaking ()

Vi ser att vi inte behövde definiera egendomen namn inte heller fastigheten ålder, vi skickar helt enkelt värdena till konstruktören i den ordning vi definierar dem i vår klass och det gör resten av arbetet för oss. Naturligtvis är detta exempel mycket förenklat, men låt oss föreställa oss att vi måste instansera hundratals objekt med värden som kommer från en uthållighetskälla som en databas.
Låt oss se i följande bild hur vår nya kod ser ut när den väl har sammanställts och översatts till JavaScript ren:

I det här fallet ser vi det JavaScript använder inte sökordet byggare när vi konstruerar metoden som vi definierar i CoffeeScript, vid denna tidpunkt börjar vi se på ett mer direkt sätt skillnaden mellan språken, förutom vad vi löste i cirka 12 eller 13 kodrader, i JavaScript bli mer än 20 rader, något att ta hänsyn till när vi gör stora applikationer.
En av fördelarna med att arbeta med objektorienterad programmering är att vi kan arv av klasser betyder det att kunna skapa nya klasser och ta funktionerna i klasser föräldrar, med detta minskar vi antalet element som vi måste skapa från grunden, eftersom när vi ärver tar vi alla metoder och egenskaper för föräldraklassen, i barnklassen eller den nya klassen behöver vi bara definiera de metoder och egenskaper som är exklusiva för det.
Kanske för dem som är nya inom programmering är detta koncept lite förvirrande eller komplext, men genom att titta på följande exempel kommer vi säkert att vara lite tydligare om vad vi kan uppnå.

 klass Person att känna Ålder: () -> console.log "Min ålder är: # {@ age}" klass Student utökar Person att tala: () -> console.log "Hej # {@ name}!" student = ny Student () student.age = "30" student.name = "Jon" student.knowAge ()

När vi analyserar ser vi hur vi har en klass Person och den här har en metod knowAge () med vilken vi skriver ut efter konsol åldern på instansen när vi skapar klassen Studerande vi berättar för honom att han ärver från Person så implicit har vår nya klass redan metoden knowAge () även om det inte är definierat i klassen.
Låt oss se i följande bild hur vår nya kod ser ut när den väl har sammanställts och översatts till JavaScript ren:

Vi kan då se att vår kod JavaScript är ganska komplext för att definiera arv, men vid användning CoffeeScript dess optimering är extremt hög. Om vi ​​ser verktyget, låt oss föreställa oss mycket komplexa klasser som applikationskomponenter som kan ge oss flera funktioner i våra nya klasser, utan att behöva skriva mer än den specifika koden som vi verkligen behöver.
Med detta har vi avslutat den här handledningen, eftersom vi ser klassernas värld i CoffeeScript Det är inte så komplext som det verkade vid första anblicken, allt ligger i att känna till grunderna och filosofin för objektorienterad programmering. Vad vi kan försäkra är att användningen av CoffeeScript som ett språk, gör komplexiteten att använda klasser i JavaScript sjunka avsevärt eftersom dess syntax mycket närmare språk som Pytonorm eller Rubin de gör det mycket mer elegant och mindre förvirrande när man läser den utvecklade koden.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng