Brug af klasser i CoffeeScript

En af de vigtigste ting, der hjælper os med at definere vores applikation, er brugen af ​​klasser, da vi med dem kan definere objekter modelleret fra det virkelige liv, og deres passage til den digitale verden bliver meget lettere.
I CoffeeScript opbygning af en klasse og instantiating den er meget enkel, faktisk er syntaksen så minimalistisk, at det er meget let for os at huske den, i stedet lave en definition af klasser direkte i JavaScript Det er noget lidt mere besværligt, og det kan tage os længere tid end forventet.
KravFor at fuldføre denne vejledning skal vi have en funktionel installation af CoffeeScript, vi har også brug for tilladelser til at skrive filer og udføre CoffeeScript på computeren, hvor vi laver selvstudiet. Vi har brug for en tekstredigerer for at kunne skrive den kode, som vi skal udføre, så vi har noget vedholdende og ikke alt i konsollen.
En klasse er ikke andet end et navn og nogle egenskaber, der definerer dens adfærd, baseret på det koncept, vi kan definere en klasse i CoffeeScript som følger:

 klasse elev

Det er alt, hvad vi skal gøre, på en enkel måde har vi allerede bygget vores første klasse ind CoffeeScriptHvad sker der nu, hvis vi vil inkludere en ejendom for at kunne bruge den, fordi vi simpelthen laver en forekomst og tilføjer den egenskab, lad os se:

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

Lad os nu se, hvordan i det følgende billede som CoffeeScript forvandle al vores kode til JavaScript ren, når vi kompilerer, lad os huske kommandoen til dette, som ville være kaffe -c filnavn. kaffe:

Vi bemærker derefter, hvordan syntaksen for JavaScript ren er meget mere omfattende og kompleks end de tre kodelinjer, vi gjorde i CoffeeScript, dette er magten i dette sprog, der lader os virkelig dedikere os til vores applikation.
En af de ting, der er mest brugt i Objektorienteret programmering er at tilføje metoder til klasser, da disse ud over egenskaberne vil give os en idé om, hvad vores objekt kan eller ikke kan gøre, for eksempel hvis vi fortsætter med Elevklasse Vi kan oprette en metode til det, hvor dens objekt udtrykker et budskab, lad os se, hvordan vi opnår det:

 klasse Elev taler: -> console.log "Hej verden!"

Hvis vi derefter opretter et objekt af samme klasse, kunne vi allerede bruge den samme metode. For eksempel:

 student = ny Studentstudent.talk ()

Med dette sikrer vi, at vores metode kan bruges mange gange, så længe vi laver flere instanser, hvilket giver vores kode et af egenskaberne ved objektorientering, hvilket er genbruge. Nu skal vi omdefinere vores kode, så den accepterer argumenter, med dette kan vi gøre meget mere end et simpelt print pr. Konsol, lad os se:

 klasse Elevsnak: (navn) -> console.log "Hej # {navn}!" student = ny Studentstudent.talk ("Carolina")

Lad os se, hvordan alt dette oversættes til kode JavaScript når vi kompilerer:

Noget vigtigt, som vi kan gøre, når vi konstruerer objekter, der stammer fra klasser, er at bevare deres værdi i løbet af deres liv i vores applikation, med dette kan vi lave komponenter, der kan få adgang til deres egenskaber gennem metoder og dermed bruge dem i forskellige dele af vores applikation.
For at manipulere en ejendom inden for CoffeeScript vi skal bare bruge @ operatør efterfulgt af navnet på den ejendom, der skal bruges, som kan kodes som følger:

 klasse Elev tale: () -> console.log “Hej # {@ name}!” elev = ny Student () student.name = “Carolina” elev. speak ()

Lad os se, hvordan dette ser ud, når det køres direkte i konsollen:

Når dette er gjort, lad os se, hvordan vores kompilerede kode ser ud JavaScript ren:

Forskellen i mængden af ​​kode er bemærkelsesværdig og kun for at gøre noget så simpelt som at definere en klasse med en metode, derefter instantiere den og kalde den oprettede metode.
Der er lejligheder, hvor definitionen af ​​vores klasse fører os til at skabe metoder, der skal kaldes inden for andre, for at opnå en mindre gentagen og mere funktionel programmering, lad os se, hvordan vi kan gøre det ved at bruge følgende kode skrevet i CoffeeScript.

 klasse Elev tale: () -> console.log "Hej mit navn er: # {@ name}!" @knowAge () knowAge: () -> console.log "Min alder er: # {@ age}" student = ny Student () student.name = "Vanessa" student.age = “23” student.talk ()

Lad os se, hvordan vi i konsollen kan se resultatet af udførelsen af ​​den tidligere kode:

Hidtil har vi defineret objektets egenskaber efter at have initialiseret det, selvom det er en levedygtig praksis, når vi skal oprette objekter med mange egenskaber, kan det være svært at vedligeholde.
Det bedste i tilfælde, hvor vi skal arbejde med mange objekter og mange egenskaber, er at kunne bruge magten til bygherrerMed dem kan vi give liv til vores objekt direkte uden at skulle definere de forskellige egenskaber på en "manuel" måde. For at definere en konstruktør skal du bruge en struktur, der ligner følgende:

 klasse Elevkonstruktør: (navn, alder) -> @navn = navn @alder = alder tal: () -> console.log "Hej mit navn er: # { @navn}!" @saberEdad () saberEdad: () -> console.log "Min alder er: # {@ age}"

Hvis vi ser på klassens definition, er konstruktøren intet andet end en metode, det interessante er, at når den kaldes Bygger allerede CoffeeScript den ved, at det er en særlig metode for vores klasse, og den vil behandle den som sådan, det er derfor, når vi skal oprette instanser af vores klasse, vi ikke behøver at kalde det eksplicit. Lad os se et eksempel på, hvordan vi nu kan definere vores objekter:

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

Vi ser, at vi ikke behøvede at definere ejendommen Navn ejendommen heller ikke alder, vi sender simpelthen værdierne til konstruktøren i den rækkefølge, vi definerer dem i vores klasse, og det gør resten af ​​arbejdet for os. Selvfølgelig er dette eksempel meget forenklet, men lad os forestille os, at vi skal instantiere hundredvis af objekter med værdier, der stammer fra en persistenskilde som en database.
Lad os se i det følgende billede, hvordan vores nye kode ser ud, når den først er samlet og oversat til JavaScript ren:

I dette tilfælde ser vi det JavaScript bruger ikke søgeordet Bygger når vi konstruerer den metode, vi definerer i CoffeeScript, på dette tidspunkt begynder vi på en mere direkte måde at se forskellen mellem sprogene, ud over hvad vi løste i omkring 12 eller 13 linjer kode, i JavaScript blive mere end 20 linjer, noget at tage højde for, når vi laver store applikationer.
En af fordelene ved at arbejde med objektorienteret programmering er, at vi kan arv af klasser, betyder det at kunne oprette nye klasser og tage funktionaliteten af ​​klasser forældre, med dette reducerer vi antallet af elementer, som vi skal oprette fra bunden, da vi ved arv tager alle forældreklassens metoder og egenskaber, i barneklassen eller den nye klasse skal vi kun definere de metoder og egenskaber, der er eksklusive til det.
Måske er det for dem, der er nye inden for programmering, lidt forvirrende eller komplekst, men ved at se på følgende eksempel vil vi helt sikkert være lidt klarere over, hvad vi kan opnå.

 klasse Person at kende Alder: () -> console.log "Min alder er: # {@ age}" klasse Elev udvider Person til at tale: () -> console.log "Hej # {@ name}!" student = ny Student () student.age = "30" student.name = "Jon" student.knowAge ()

Når vi analyserer, ser vi, hvordan vi har en klasse Person og denne har en metode knowAge () som vi udskriver efter konsol alderen på forekomsten, når vi opretter klassen Studerende vi fortæller ham, at han arver fra Person så implicit har vores nye klasse allerede metoden knowAge () selvom det ikke er defineret i klassen.
Lad os se i det følgende billede, hvordan vores nye kode ser ud, når den først er samlet og oversat til JavaScript ren:

Vi kan derefter se, at vores kode JavaScript er ret kompleks til at definere arv, men når man bruger CoffeeScript dens optimering er ekstremt høj. Hvis vi ser værktøjet, lad os forestille os meget komplekse klasser som applikationskomponenter, der kan give os flere funktioner i vores nye klasser uden at skulle skrive mere end den specifikke kode, vi virkelig har brug for.
Med dette har vi afsluttet denne vejledning, da vi ser klassenes verden i CoffeeScript Det er ikke så komplekst, som det virkede ved første øjekast, det hele ligger i at kende det grundlæggende og filosofiske i objektorienteret programmering. Hvad vi kan forsikre er, at brugen af CoffeeScript som sprog, gør kompleksiteten ved at bruge klasser i JavaScript falde betydeligt, da syntaksen er meget tættere på sprog som Python eller Rubin de gør det meget mere elegant og mindre forvirrende, når man læser den udviklede kode.Kan du lide og hjælpe denne vejledning?Du kan belønne forfatteren ved at trykke på denne knap for at give ham et positivt punkt