CoffeeScript - Classes et héritage

JavaScript ne fournit pas le classmot-clé. Nous pouvons réaliser l'héritage en JavaScript en utilisant des objets et leurs prototypes. Chaque objet a son propre prototype et hérite des fonctions et propriétés de ses prototypes. Le prototype étant également un objet, il possède également son propre prototype.

Bien que l'héritage prototypique soit beaucoup plus puissant que l'héritage classique, il est difficile et déroutant pour les utilisateurs novices.

Cours dans CoffeeScript

Pour résoudre ce problème, CoffeeScript fournit une structure de base appelée classqui est construit en utilisant les prototypes de JavaScript. Vous pouvez définir une classe dans CoffeeScript en utilisant le mot clé class comme indiqué ci-dessous.

class Class_Name

Exemple

Prenons l'exemple suivant, ici nous avons créé une classe nommée Student en utilisant le mot-clé class.

class Student

Si vous compilez le code ci-dessus, il générera le JavaScript suivant.

var Student;

Student = (function() {
  function Student() {}

  return Student;

})();

Instancier une classe

Nous pouvons instancier une classe en utilisant le nouvel opérateur, tout comme les autres langages de programmation orientés objet comme indiqué ci-dessous.

new Class_Name

Vous pouvez instancier la classe (Student) créée ci-dessus en utilisant le new opérateur comme indiqué ci-dessous.

class Student
new  Student

Si vous compilez le code ci-dessus, il générera le JavaScript suivant.

var Student;

Student = (function() {
  function Student() {}

  return Student;

})();

new Student;

Définition d'un constructeur

Un constructeur est une fonction appelée lorsque nous instancions une classe, son objectif principal est d'initialiser les variables d'instance. Dans CoffeeScript, vous pouvez définir un constructeur simplement en créant une fonction avec le nomconstructor comme indiqué ci-dessous.

class Student
  constructor: (name)->
  @name = name

Ici, nous avons défini un constructeur et attribué le nom de la variable locale à la variable d'instance.

le @ opérateur est un alias du this mot-clé, il est utilisé pour pointer les variables d'instance d'une classe.

Si nous plaçons @avant un argument du constructeur, il sera automatiquement défini comme une variable d'instance. Par conséquent, le code ci-dessus peut être écrit simplement comme indiqué ci-dessous -

class Student
  constructor: (@name)->

Exemple

Voici un exemple de constructeur dans CoffeeScript. Enregistrez-le dans un fichier avec le nomconstructor_example.coffee

#Defining a class
class Student
  constructor: (@name)->

#instantiating a class by passing a string to constructor
student = new Student("Mohammed");
console.log "the name of the student is :"+student.name

Compiling the code

Ouvrez l'invite de commande et compilez l'exemple ci-dessus comme indiqué ci-dessous.

c:\>coffee -c constructor_example.coffee

En exécutant la commande ci-dessus, il produira le JavaScript suivant.

// Generated by CoffeeScript 1.10.0
(function() {
  var Student, student;

  Student = (function() {
    function Student(name) {
      this.name = name;
    }

    return Student;

  })();

  student = new Student("Mohammed");

  console.log("The name of the student is :"+student.name);

}).call(this);

Executing the Code

Exécutez l'exemple ci-dessus en exécutant la commande suivante sur l'invite de commande.

coffee constructor_example.coffee

Lors de l'exécution, l'exemple ci-dessus vous donne la sortie suivante.

The name of the student is :Mohammed

Propriétés de l'instance

Comme dans les objets, nous pouvons également avoir des propriétés au sein d'une classe. Et ceux-ci sont connus commeinstance properties.

Exemple

Prenons l'exemple suivant. Ici, nous avons créé des variables (nom, âge) et une fonction (message ()) au sein de la classe et y avons accédé en utilisant son objet. Enregistrez cet exemple dans un fichier nomméinstance_properties_example.coffee

#Defining a class
class Student
  name="Ravi"
  age=24
  message: ->
    "Hello "+name+" how are you" 

#instantiating a class by passing a string to constructor
student = new Student();
console.log student.message()

Lors de la compilation, le code ci-dessus génère la sortie suivante.

// Generated by CoffeeScript 1.10.0
(function() {
  var Student, student;

  Student = (function() {
    var age, name;

    function Student() {}

    name = "Ravi";

    age = 24;

    Student.prototype.message = function() {
      return "Hello " + name + " how are you";
    };

    return Student;

  })();

  student = new Student();

  console.log(student.message());

}).call(this);

Propriétés statiques

Nous pouvons définir des propriétés statiques dans la classe. La portée des propriétés statiques est restreinte au sein de la classe et nous créons des fonctions statiques en utilisant lethis keyword ou son alias @symbol et nous devons accéder à ces propriétés en utilisant le nom de classe comme Class_Name.property .

Exemple

Dans l'exemple suivant, nous avons créé une fonction statique nommée message. et y ai accédé. Enregistrez-le dans un fichier avec le nomstatic_properties_example.coffee.

#Defining a class
class Student
  @message:(name) ->
    "Hello "+name+" how are you" 
console.log Student.message("Raju")

Ouvrez l'invite de commande et compilez le fichier CoffeeScript ci-dessus à l'aide de la commande suivante.

c:\>coffee -c  static_properties_example.coffee

Lors de la compilation, il vous donne le JavaScript suivant.

// Generated by CoffeeScript 1.10.0
(function() {
  var Student;

  Student = (function() {
    function Student() {}

    Student.message = function(name) {
      return "Hello " + name + " how are you";
    };

    return Student;

  })();

  console.log(Student.message("Raju"));

}).call(this);

Exécutez le coffeeScript ci-dessus dans l'invite de commande comme indiqué ci-dessous.

c:\>coffee static_properties_example.coffee

Lors de l'exécution, l'exemple ci-dessus vous donne la sortie suivante.

Hello Raju how are you

Héritage

Dans CoffeeScript, nous pouvons hériter des propriétés d'une classe dans une autre classe en utilisant extends mot-clé.

Exemple

Voici un exemple d'héritage dans CoffeeScript. Ici, nous avons deux classes à savoirAdd et My_class. Nous avons hérité des propriétés de la classe nommée Add dans la classe My_class, et y avons accédé en utilisant leextends mot-clé.

#Defining a class
class Add
   a=20;b=30
   
   addition:->
     console.log "Sum of the two numbers is :"+(a+b) 

class My_class extends Add

my_class = new My_class()
my_class.addition()

CoffeeScript utilise l'héritage prototypique dans les coulisses. Dans CoffeeScript, chaque fois que nous créons des instances, le constructeur de la classe parente est appelé jusqu'à ce que nous le remplacions.

Nous pouvons invoquer le constructeur de la classe parente depuis la sous-classe, en utilisant le super() mot-clé comme indiqué dans l'exemple ci-dessous.

#Defining a class
class Add
   constructor:(@a,@b) ->
   
   addition:=>
     console.log "Sum of the two numbers is :"+(@[email protected]) 

class Mul extends Add
   constructor:(@a,@b) ->
     super(@a,@b)
   
   multiplication:->
     console.log "Product of the two numbers is :"+(@a*@b)

mul = new Mul(10,20)
mul.addition()
mul.multiplication()

Classes dynamiques

CoffeeScript utilise l'héritage prototypique pour hériter automatiquement de toutes les propriétés d'occurrence d'une classe. Cela garantit que les classes sont dynamiques; même si vous ajoutez des propriétés à une classe parent après la création d'un enfant, la propriété sera toujours propagée à tous ses enfants hérités.

class Animal
  constructor: (@name) ->

class Parrot extends Animal

Animal::rip = true

parrot = new Parrot("Macaw")
console.log "This parrot is no more" if parrot.rip

Lors de l'exécution, CoffeeScript ci-dessus génère le code JavaScript suivant.

// Generated by CoffeeScript 1.10.0
(function() {
  var Animal, Parrot, parrot,
    extend = function(child, parent) { for (var key in parent) {
      if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() {
      this.constructor = child; } ctor.prototype = parent.prototype;
      child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  Animal = (function() {
    function Animal(name) {
      this.name = name;
    }

    return Animal;

  })();

  Parrot = (function(superClass) {
    extend(Parrot, superClass);

    function Parrot() {
      return Parrot.__super__.constructor.apply(this, arguments);
    }

    return Parrot;

  })(Animal);

  Animal.prototype.rip = true;

  parrot = new Parrot("Macaw");

  if (parrot.rip) {
    console.log("This parrot is no more");
  }
  
}).call(this);