Utilizzo delle classi in CoffeeScript

Una delle cose più importanti che ci aiuta a definire la nostra applicazione è l'uso delle classi, poiché con esse possiamo definire oggetti modellati dalla vita reale e il loro passaggio al mondo digitale diventa molto più semplice.
Nel CoffeeScript costruire una classe e istanziarla è molto semplice, infatti la sua sintassi è così minimalista che è molto facile per noi ricordarla, invece facendo una definizione di classi direttamente in JavaScript È qualcosa di un po' più ingombrante e potrebbe richiedere più tempo del previsto.
RequisitiPer completare questo tutorial dobbiamo avere un'installazione funzionale di CoffeeScript, abbiamo anche bisogno delle autorizzazioni per scrivere file ed eseguire CoffeeScript sul computer dove stiamo facendo il tutorial. Abbiamo bisogno di un editor di testo per poter scrivere il codice che andremo a eseguire in modo da avere qualcosa di persistente e non tutto nella console.
Una classe non è altro che un nome e alcune proprietà che ne definiscono il comportamento, in base a quel concetto possiamo definire una classe in CoffeeScript come segue:

 classe studente

Questo è tutto ciò che dobbiamo fare, in modo semplice abbiamo già costruito la nostra prima classe in CoffeeScriptOra cosa succede se vogliamo includere una proprietà per poterla usare, perché semplicemente creiamo un'istanza e aggiungiamo quella proprietà, vediamo:

 studente = nuovo Studente () studente.nome = "Carolina"

Ora vediamo come nell'immagine seguente come CoffeeScript trasforma tutto il nostro codice in JavaScript pure durante la compilazione, ricordiamo il comando per questo che sarebbe caffè -c nomefile.caffè:

Notiamo poi come la sintassi di JavaScript pure è molto più esteso e complesso delle tre righe di codice che abbiamo fatto CoffeeScript, questa è la potenza di questo linguaggio che ci permette di dedicarci davvero alla nostra applicazione.
Una delle cose più usate nel Programmazione orientata agli oggetti consiste nell'aggiungere metodi alle classi, poiché questi, oltre alle proprietà, ci daranno un'idea di cosa può o non può fare il nostro oggetto, ad esempio se continuiamo con il Classe studentesca Possiamo creare un metodo per esso in cui il suo oggetto esprime un messaggio, vediamo come realizzarlo:

 class Studente parla: -> console.log "Hello World!"

Se poi creiamo un oggetto di questa stessa classe potremmo già usare questo stesso metodo. Ad esempio:

 studente = nuovo Studentestudente.talk ()

Con questo ci assicuriamo che il nostro metodo possa essere utilizzato molte volte, purché creiamo più istanze, il che conferisce al nostro codice una delle caratteristiche dell'orientamento agli oggetti, che è riutilizzare. Ora andiamo a ridefinire il nostro codice in modo che accetti argomenti, con questo possiamo fare molto di più di una semplice stampa da console, vediamo:

 class Student talk: (name) -> console.log "Hello # {name}!" student = new Studentstudent.talk ("Carolina")

Vediamo come tutto questo si traduce in codice JavaScript quando compiliamo:

Qualcosa di importante che possiamo fare quando costruiamo oggetti derivati ​​da classi è mantenere il loro valore durante la loro vita nella nostra applicazione, con questo possiamo creare componenti che possono accedere alle loro proprietà attraverso metodi e quindi usarli in diverse parti della nostra applicazione.
Al fine di manipolare una proprietà all'interno CoffeeScript dobbiamo solo usare il @operatore seguito dal nome della proprietà da utilizzare, che può essere codificato come segue:

 class Studente parla: () -> console.log “Hello # {@ name}!” studente = nuovo Studente () studente.nome = “Carolina” studente. parla ()

Vediamo come appare quando viene eseguito direttamente nella console:

Fatto ciò, vediamo come appare il nostro codice compilato JavaScript puro:

La differenza nella quantità di codice è notevole e solo per fare qualcosa di semplice come definire una classe con un metodo, quindi crearne un'istanza e chiamare il metodo creato.
Ci sono occasioni in cui la definizione della nostra classe ci porta a creare metodi che devono essere chiamati all'interno di altri, questo per ottenere una programmazione meno ripetitiva e più funzionale, vediamo come possiamo farlo usando il seguente codice scritto in CoffeeScript.

 class Lo studente parla: () -> console.log "Ciao mi chiamo: # {@ name}!" @knowAge () knowAge: () -> console.log "La mia età è: # {@ age}" studente = nuovo Studente () studente.nome = "Vanessa" studente.età = “23” studente.talk ()

Vediamo come nella console possiamo vedere il risultato dell'esecuzione del codice precedente:

Finora abbiamo definito le proprietà dell'oggetto dopo averlo inizializzato, sebbene sia una pratica praticabile, quando dobbiamo creare oggetti con molte proprietà questo può essere difficile da mantenere.
La cosa migliore nei casi in cui dobbiamo lavorare con molti oggetti e molte proprietà è poter utilizzare il potere di costruttoriCon loro possiamo dare vita direttamente al nostro oggetto senza dover definire le diverse proprietà in modo "manuale". Per definire un costruttore, utilizzare una struttura simile alla seguente:

 class Costruttore studente: (nome, età) -> @nome = nome @età = età speak: () -> console.log "Ciao mi chiamo: # {@ nome}!" @saberEdad () saberEdad: () -> console.log "La mia età è: # {@ age}"

Se guardiamo la definizione della classe, il costruttore non è altro che un metodo, la cosa interessante è che quando viene chiamato costruttore già CoffeeScript sa che è un metodo speciale per la nostra classe e lo tratterà come tale, ecco perché quando creeremo le istanze della nostra classe non dobbiamo chiamarlo esplicitamente. Vediamo un esempio di come possiamo ora definire i nostri oggetti:

 studente = nuovo studente ("Carolina", "26") studente.speaking ()

Vediamo che non dovevamo definire la proprietà Nome né la proprietà età, passiamo semplicemente i valori al costruttore nell'ordine in cui li definiamo nella nostra classe e fa il resto del lavoro per noi. Ovviamente questo esempio è molto semplicistico, ma immaginiamo di dover istanziare centinaia di oggetti con valori che provengono da una sorgente di persistenza come un Database.
Vediamo nell'immagine seguente come si presenta il nostro nuovo codice una volta compilato e tradotto in JavaScript puro:

In questo caso vediamo che JavaScript non usa la parola chiave costruttore quando costruiamo il metodo che definiamo in CoffeeScript, a questo punto iniziamo a vedere in modo più diretto la differenza tra i linguaggi, oltre a quanto abbiamo risolto in circa 12 o 13 righe di codice, in JavaScript diventare più di 20 linee, qualcosa da tenere in considerazione quando si creano applicazioni di grandi dimensioni.
Uno dei vantaggi di lavorare con la programmazione orientata agli oggetti è che possiamo fare eredità di classi, questo significa poter creare nuove classi e prendere le funzionalità delle classi genitori, con questo riduciamo il numero di elementi che dobbiamo creare da zero, poiché quando ereditiamo prendiamo tutti i metodi e le proprietà della classe genitore, nella classe figlia o nella nuova classe dobbiamo solo definire i metodi e le proprietà che ne sono esclusivi.
Forse per coloro che sono nuovi alla programmazione questo concetto è un po' confuso o complesso, tuttavia guardando l'esempio seguente saremo sicuramente un po' più chiari su ciò che possiamo ottenere.

 class Persona da conoscere Età: () -> console.log "La mia età è: # {@ età}" class Lo studente estende Persona da parlare: () -> console.log "Ciao # {@ nome}!" studente = nuovo Student () student.age = "30" student.name = "Jon" student.knowAge ()

Analizzando vediamo come abbiamo una classe Persona e questo ha un metodo sapereEtà () con cui stampiamo da console l'età dell'istanza, quando creiamo la classe Alunno gli diciamo che eredita da Persona quindi implicitamente la nostra nuova classe ha già il metodo sapereEtà () anche se non è definito nella classe.
Vediamo nell'immagine seguente come si presenta il nostro nuovo codice una volta compilato e tradotto in JavaScript puro:

Possiamo quindi vedere che il nostro codice JavaScript è abbastanza complesso per definire l'ereditarietà, ma quando si usa CoffeeScript la sua ottimizzazione è estremamente elevata. Se vediamo l'utilità, immaginiamo classi molto complesse come componenti dell'applicazione che possono darci più funzionalità nelle nostre nuove classi, senza dover scrivere più del codice specifico di cui abbiamo veramente bisogno.
Con questo abbiamo finito questo tutorial, come vediamo il mondo delle classi in CoffeeScript Non è così complesso come sembrava a prima vista, sta tutto nel conoscere i fondamenti e la filosofia della programmazione orientata agli oggetti. Quello che possiamo assicurare è che l'uso di CoffeeScript come linguaggio, rende la complessità dell'uso delle classi in JavaScript diminuire considerevolmente poiché la sua sintassi è molto più vicina a linguaggi come Pitone o Rubino lo rendono molto più elegante e meno confuso durante la lettura del codice sviluppato.Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo