Utiliser des classes dans CoffeeScript

L'une des choses les plus importantes qui nous aident à définir notre application est l'utilisation de classes, car avec elles, nous pouvons définir des objets modélisés à partir de la vie réelle et leur passage au monde numérique devient beaucoup plus facile.
Dans CoffeeScript construire une classe et l'instancier est très simple, en fait sa syntaxe est si minimaliste qu'il nous est très facile de s'en souvenir, au lieu de faire une définition de classes directement dans JavaScript C'est quelque chose d'un peu plus lourd et qui peut nous prendre plus de temps que prévu.
ExigencesPour terminer ce tutoriel, nous devons avoir une installation fonctionnelle de CoffeeScript, nous avons également besoin d'autorisations pour écrire des fichiers et exécuter CoffeeScript sur l'ordinateur où nous faisons le tutoriel. Nous avons besoin d'un éditeur de texte pour pouvoir écrire le code que nous allons exécuter afin que nous ayons quelque chose de persistant et pas tout dans la console.
Une classe n'est rien de plus qu'un nom et quelques propriétés qui définissent son comportement, sur la base de ce concept, nous pouvons définir une classe dans CoffeeScript comme suit:

 classe Étudiant

C'est tout ce que nous devons faire, d'une manière simple, nous avons déjà construit notre première classe en CoffeeScriptMaintenant, que se passe-t-il si nous voulons inclure une propriété pour pouvoir l'utiliser, car nous créons simplement une instance et ajoutons cette propriété, voyons :

 student = new Student () student.name = "Caroline"

Voyons maintenant comment dans l'image suivante comme CoffeeScript transformer tout notre code en JavaScript pure lors de la compilation, rappelons-nous la commande pour ce qui serait coffee -c nom_fichier.coffee:

On remarque alors comment la syntaxe de JavaScript pure est beaucoup plus vaste et complexe que les trois lignes de code que nous avons faites dans CoffeeScript, c'est la puissance de ce langage qui nous permet de vraiment nous consacrer à notre application.
L'une des choses les plus utilisées dans le programation orientée aux objets est d'ajouter des méthodes aux classes, car celles-ci, en plus des propriétés, nous donneront une idée de ce que notre objet peut ou ne peut pas faire, par exemple si nous continuons avec le Classe d'étudiants On peut lui créer une méthode dans laquelle son objet exprime un message, voyons comment y parvenir :

 classe L'élève parle : -> console.log "Hello World!"

Si nous créons ensuite un objet de cette même classe, nous pourrions déjà utiliser cette même méthode. Par exemple:

 étudiant = nouveau Studentstudent.talk ()

Avec cela, nous nous assurons que notre méthode peut être utilisée plusieurs fois, tant que nous faisons plusieurs instances, ce qui donne à notre code l'une des caractéristiques de l'orientation objet, qui est réutilisation. Maintenant nous allons redéfinir notre code pour qu'il accepte les arguments, avec cela nous pouvons faire bien plus qu'une simple impression par console, voyons :

 classe Discussion de l'étudiant : (nom) -> console.log "Bonjour # {nom} !" student = new Studentstudent.talk ("Caroline")

Voyons comment tout cela se traduit en code JavaScript quand on compile :

Une chose importante que nous pouvons faire lors de la construction d'objets dérivés de classes est de maintenir leur valeur pendant leur vie dans notre application, avec cela nous pouvons créer des composants qui peuvent accéder à leurs propriétés via des méthodes et ainsi les utiliser dans différentes parties de notre application.
Afin de manipuler une propriété dans CoffeeScript nous n'avons qu'à utiliser le @ opérateur suivi du nom de la propriété à utiliser, qui peut être encodé comme suit :

 classe Étudiant parle : () -> console.log « Bonjour # {@ nom} ! » étudiant = nouvel étudiant () étudiant.nom = « Caroline » étudiant. parle ()

Voyons à quoi cela ressemble lorsqu'il est exécuté directement dans la console :

Une fois cela fait, voyons à quoi ressemble notre code compilé JavaScript pur:

La différence dans la quantité de code est remarquable et ne consiste qu'à faire quelque chose d'aussi simple que de définir une classe avec une méthode, puis de l'instancier et d'appeler la méthode créée.
Il y a des occasions où la définition de notre classe nous amène à créer des méthodes qui doivent être appelées au sein d'autres, ceci afin de réaliser une programmation moins répétitive et plus fonctionnelle, voyons comment nous pouvons le faire en utilisant le code suivant écrit en CoffeeScript.

 classe L'élève parle : () -> console.log "Bonjour, je m'appelle : # {@ name} !" @knowAge () knowAge: () -> console.log "Mon âge est : # {@ age}" student = new Student () student.name = "Vanessa" student.age = "23" student.talk ()

Voyons comment dans la console on peut voir le résultat de l'exécution du code précédent :

Jusqu'à présent, nous avons défini les propriétés de l'objet après l'avoir initialisé, bien que ce soit une pratique viable, lorsque nous devons créer des objets avec de nombreuses propriétés, cela peut être difficile à maintenir.
La meilleure chose dans les cas où nous devons travailler avec de nombreux objets et de nombreuses propriétés est de pouvoir utiliser la puissance de constructeursAvec eux, nous pouvons donner vie à notre objet directement sans avoir à définir les différentes propriétés de manière "manuelle". Pour définir un constructeur, utilisez une structure similaire à la suivante :

 class Constructeur étudiant : (nom, âge) -> @name = nom @age = age speak : () -> console.log "Bonjour, je m'appelle : # {@ nom} !" @saberEdad () saberEdad : () -> console.log "Mon âge est : # {@ age}"

Si on regarde la définition de la classe, le constructeur n'est rien de plus qu'une méthode, ce qui est intéressant c'est que lorsqu'on l'appelle constructeur déjà CoffeeScript il sait que c'est une méthode spéciale pour notre classe et il la traitera comme telle, c'est pourquoi lorsque nous allons créer les instances de notre classe, nous n'avons pas à l'appeler explicitement. Voyons un exemple de la façon dont nous pouvons maintenant définir nos objets :

 étudiant = nouvel étudiant ("Caroline", "26") étudiant.parlant ()

On voit qu'on n'a pas eu à définir la propriété nom ni la propriété âge, nous passons simplement les valeurs au constructeur dans l'ordre où nous les définissons dans notre classe et il fait le reste du travail pour nous. Bien sûr cet exemple est très simpliste, mais imaginons que l'on doive instancier des centaines d'objets avec des valeurs qui proviennent d'une source de persistance comme une Database.
Voyons dans l'image suivante à quoi ressemble notre nouveau code une fois compilé et traduit en JavaScript pur:

Dans ce cas on voit que JavaScript n'utilise pas le mot-clé constructeur lors de la construction de la méthode que nous définissons dans CoffeeScript, à ce stade, nous commençons à voir de manière plus directe la différence entre les langues, en plus de ce que nous avons résolu en environ 12 ou 13 lignes de code, en JavaScript devenir plus que 20 lignes, quelque chose à prendre en compte lorsque nous faisons de grandes applications.
L'un des avantages de travailler avec la programmation orientée objet est que nous pouvons faire patrimoine des classes, cela signifie pouvoir créer de nouvelles classes et prendre la fonctionnalité des classes Parents, avec cela, nous réduisons le nombre d'éléments que nous devons créer à partir de zéro, car lors de l'héritage, nous prenons toutes les méthodes et propriétés de la classe parent, dans la classe enfant ou la nouvelle classe, nous n'avons qu'à définir les méthodes et propriétés qui lui sont exclusifs.
Peut-être que pour ceux qui débutent dans la programmation, ce concept est un peu déroutant ou complexe, mais en regardant l'exemple suivant, nous serons sûrement un peu plus clairs sur ce que nous pouvons réaliser.

 class Personne à connaître Âge : () -> console.log "Mon âge est : # {@ age}" classe L'étudiant étend Personne à parler : () -> console.log "Bonjour # {@ nom} !" étudiant = nouveau Student () student.age = "30" student.name = "Jon" student.knowAge ()

En analysant, nous voyons comment nous avons une classe Personne et celui-ci a une méthode savoirÂge () avec laquelle on imprime par console l'âge de l'instance, lors de la création de la classe Étudiant on lui dit qu'il hérite de Personne donc implicitement notre nouvelle classe a déjà la méthode savoirÂge () même s'il n'est pas défini dans la classe.
Voyons dans l'image suivante à quoi ressemble notre nouveau code une fois compilé et traduit en JavaScript pur:

On voit alors que notre code JavaScript est assez complexe pour définir l'héritage, mais lors de l'utilisation CoffeeScript son optimisation est extrêmement élevée. Si nous voyons l'utilité, imaginons des classes très complexes comme des composants d'application qui peuvent nous donner de multiples fonctionnalités dans nos nouvelles classes, sans avoir à écrire plus que le code spécifique dont nous avons vraiment besoin.
Avec cela, nous avons terminé ce tutoriel, car nous voyons le monde des classes dans CoffeeScript Ce n'est pas aussi complexe qu'il y paraît à première vue, tout réside dans la connaissance des fondamentaux et de la philosophie de la programmation orientée objet. Ce que nous pouvons assurer, c'est que l'utilisation de CoffeeScript en tant que langage, rend la complexité de l'utilisation des classes dans JavaScript baisse considérablement puisque sa syntaxe beaucoup plus proche des langages comme Python ou alors Rubis ils le rendent beaucoup plus élégant et moins déroutant lors de la lecture du code développé.Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif