Human.js

File: Human.js

/**
* Cette fonction retourne un objet qui hérite des propriétés du
* prototype de l'objet paramètre p.
*
* Cette fonction contient un "fallback", c'est à dire une astuce qui
* permet à la fonction de fournir un résultat correct même dans le cas
* d'anciens navigateurs (n'implémentant pas le standard ECMAScript5).
*
* Cette fonction est extraite de l'ouvrage "Javascript, The Definitive
* Guide" par David Flanagan, édition O'Reilly, 6ème édition (2011).
*/
function inherit(p) {
    'use strict';

    // p doit être un objet non nul
    if (p == null) throw new TypeError();

    // --- Cas normal ---
    // Si Object.create() est défini (cas des navigateurs récents 
    // implémentant les fonctions ECMAScript5)...
    if (Object.create) return Object.create(p);


    // --- Fallback (pour les vilains navigateurs) ---
    // Type de l'objet passé en paramètre de la fonction
    var t = typeof p;
    // Otherwise do some more type checking
    if (t !== "object" && t !== "function") throw new TypeError();

    // On défini un prototype vide
    function F() {}

    // On applique p à ce prototype (héritage)
    F.prototype = p;

    // On crée un nouvel héritier de p, et on le retourne
    return new F();
}


/**
 * Modélisation d'un humain.
 *
 * Dans notre société, nous sommes bien souvent assimilables à des
 * robots... Nous allons donc étendre la classe Robot. Ainsi, un
 * Humain sera "une sorte" de Robot.
 *
 * @class Human
 * @extends Robot
 */
var Human = (function () {
    'use strict';

    // Le prototype des humains hérite du prototype des robots
    // Un humain sait donc marcher et parler
    Human.prototype = inherit(Robot.prototype);

    /**
     * Sexes possibles pour un humain
     * @property SEX
     * @static
     * @type Array
     */
    Human.SEX = ['MAN', 'WOMAN'];

    /**
     * Constructeur
     * @constructor
     * @param {String} name Nom de l'humain
     * @param {Number} age Age de l'humain
     */
    function Human(name, age) {
        this.age = age;

        // On appelle le constructeur de la classe mère afin de ne
        // pas avoir à réécrire du code (eg. this.name = name;)
        Robot.apply(this, arguments);
    }

    /**
    * Un humain peut boire (tandis que les robots ne peuvent pas car
    * ils rouilleraient...)
    * @method drink
    */
    Human.prototype.drink = function () {
        console.log('I am drinking');
    };

    /**
     * Les humains savent parler, mais ils sont plus intelligents que
     * les robots. Ils sont aussi plus bavards...
     *
     * On surcharge ici la méthode Robot.speak
     *
     * @method speak
     */
    Human.prototype.speak = function () {
        // Appel de la méthode de la classe mère
        Robot.prototype.speak.apply(this, arguments);

        // On ajoute un traitement spécifique après l'appel de la méthode héritée
        console.log('I am human and I am ' + this.age + ' years old.');
    };

    // La méthode Human.prototype.walk n'est pas définie. On hérite
    // simplement de celle de la classe mère, donc pas de surcharge.
    // En effet, un humain marche exactement comme un Robot, enfin en moins
    // saccadé quand même...

    // On pense à retouner le constructeur
    return Human;
}());


// ---
// Exemples d'utilisation

var corben = new Human('Corben', 38);
corben.speak();
corben.walk('south');
corben.walk('west');
corben.drink();
console.log(corben);

console.log('--- Fin fichier Human.js ------------------');

    (full-width)