JavaScript : la signification du chapitre Héritage et du chapitre Pièces dans The Good Parts

Question

J'ai lu JavaScript : The Good Parts récemment. Cela a été relaxant et agréable jusqu'à présent, et le contenu est très bon. Mais quand je suis arrivé au chapitre Pièces sur l'héritage
, j'étais complètement abasourdi et je n'avais aucune idée de ce dont il parlait. Veuillez me donner quelques conseils ou exemples. Voici le contenu du chapitre

.

Parts
Nous pouvons composer des objets à partir d'ensembles de parties. Par exemple, nous pouvons créer une fonction
qui peut ajouter des fonctionnalités de traitement d'événements simples à n'importe quel objet. Elle ajoute une méthode on, une méthode
fire et un registre d'événements privé :

var eventuality = function (that) {
    var registry = {};
    that.fire = function (event) {
    // Fire an event on an object. The event can be either
    // a string containing the name of the event or an
    // object containing a type property containing the
    // name of the event. Handlers registered by the 'on'
    // method that match the event name will be invoked.
        var array,
        func,
        handler,
        i,
        type = typeof event === 'string' ?
        event : event.type;
        // If an array of handlers exist for this event, then
        // loop through it and execute the handlers in order.
        if (registry.hasOwnProperty(type)) {
            array = registry[type];
            for (i = 0; i < array.length; i += 1) {
                handler = array[i];
                // A handler record contains a method and an optional
                // array of parameters. If the method is a name, look
                // up the function.
                func = handler.method;
                if (typeof func === 'string') {
                    func = this[func];
                }
                // Invoke a handler. If the record contained
                // parameters, then pass them. Otherwise, pass the
                // event object.
                func.apply(this,
                handler.parameters || [event]);
                }
            }
            return this;
        };
        that.on = function (type, method, parameters) {
        // Register an event. Make a handler record. Put it
        // in a handler array, making one if it doesn't yet
        // exist for this type.
        var handler = {
            method: method,
            parameters: parameters
        };
        if (registry.hasOwnProperty(type)) {
            registry[type].push(handler);
        } else {
            registry[type] = [handler];
        }
        return this;
    };
    return that;
};

Nous pourrions appeler l'éventualité sur n'importe quel objet individuel, en lui conférant la gestion des événements

1. Nous pourrions également l'appeler dans une fonction constructeur avant qu'elle ne soit renvoyée :

eventuality(that)

De cette façon, un constructeur pourrait assembler des objets à partir d'un ensemble de parties. Le typage lâche de JavaScript est un gros avantage ici car nous ne sommes pas surchargés par un système de types
qui se soucie de la lignée des classes, nous pouvons plutôt nous concentrer sur. le caractère
de leur contenu.
Si nous voulions éventuellement avoir accès à l'état privé de l'objet, nous pourrions le transmettre
le mon paquet

Answer 1

L'anglais "parts" signifie parties. Je ne sais pas comment décrire avec précision sa signification ici. En gros, plusieurs "parties" peuvent être combinées sur l'objet grâce à certaines méthodes. Dans la fonction de construction, bien sûr, elles sont combinées en this 上。比如 eventuality, pour le simplifier

.

var eventuality = function(that) {
    // 用于保存注册到 that 上的事件，闭包实现
    var registry = {};

    // 注册事件，将事件注册到 registry 中
    that.on = function() {};

    // 从 registry 中搜索对应的事情处理函数来执行
    that.fire = function() {};
};

Ce sera l'objet transmis that 添加 on() 和 fire() 两个方法用于事件的注册和触发，而闭包变量 registry Utilisé pour sauvegarder les événements enregistrés (fonctions de gestion). Bien entendu, cette fonction ajoute une fonctionnalité de gestion d’événements à l’objet.

Supposons que nous ayons une autre fonction qui doit être ajoutée à l'objet, telle que la sérialisation en JSON, c'est-à-dire l'ajout d'une méthode toJson() pour sérialiser l'objet actuel dans une chaîne JSON, telle que

function jsonlity(that) {
    that.toJson = function() {};
}

Ensuite, nous avons une classe Boo qui, en plus de certaines de ses propres fonctionnalités, a également besoin d'événements et de fonctionnalités JSON, cela peut donc être fait dans son constructeur

function Boo() {
    // Boo 自身的构造内容
    // ......

    eventuality(this);  // 添加事件功能
    jsonlity(this);     // 添加 JSON 支持
}

Les deux dernières phrases devraient être ce qu'on appelle les parties de composition

Supplément

Cette méthode définira une copie de la fonction de méthode pertinente pour chaque objet et ne pourra pas réutiliser la méthode définie, elle reste donc relativement gourmande en ressources. Cependant, ce paragraphe doit être introduit dans le didacticiel pour introduire le point de connaissance suivant sur l'héritage.

En parlant d'héritage, la syntaxe ES2015 prend déjà en charge les classes et les extensions, ce qui est plus strict et plus pratique que la méthode de constructeur précédente. Donc, dans cette partie, je vous suggère d'en apprendre davantage sur la nouvelle syntaxe de classe et de ne pas trop vous emmêler dans l'ancienne. syntaxe de classe. À l'avenir, lorsque vous aurez une certaine base et que vous aurez le temps, si vous êtes intéressé, vous pourrez étudier le mécanisme prototype de JS et l'implémentation OO basée sur le mécanisme prototype.