Un guide de programmation avec JavaScript à l'aide des composants AmplifyJS_Basics

Le rôle de la diffusion événementielle

Lors de l'ajout de diverses fonctions interactives à la page, le moyen le plus simple que nous connaissons est de lier des événements aux éléments de la page, puis d'effectuer les actions que nous souhaitons effectuer dans la fonction de gestion des événements. Codez comme ceci :

element.onclick = function(event){
  // Do anything.
};

Si l'action que nous voulons faire n'est pas compliquée, alors le code de la fonction logique réelle peut être placé ici. Si vous devez le modifier à l'avenir, rendez-vous à l'emplacement de cette fonction de gestion d'événements pour le modifier.

De plus, afin de parvenir à une réutilisation correcte du code, nous pouvons diviser une partie de la fonction logique en une fonction :

element.onclick = function(event){
  // Other code here.
  doSomethingElse();
};

La fonction correspondant à la fonction doSomethingElse ici peut être utilisée à d'autres endroits, elle sera donc divisée comme ceci. De plus, il peut y avoir une fonction telle que la définition des coordonnées (en supposant que la fonction s'appelle setPosition), et vous devez également utiliser des informations telles que la position du pointeur fournies par l'événement objet de l'événement du navigateur :

element.onclick = function(event){
  // Other code here.
  doSomethingElse();
  setPosition(event.clientX, event.clientY);
};

Une approche non recommandée ici consiste à transmettre l'objet événement directement à setPosition. En effet, c'est une bonne pratique de séparer les responsabilités des fonctions logiques et de l'écoute des événements. Permettre uniquement à la fonction de traitement des événements elle-même d'accéder à l'objet événement du navigateur permet de réduire le couplage de code et facilite les tests et la maintenance indépendants.

Alors, que se passera-t-il si les fonctions deviennent de plus en plus complexes ? Si vous suivez l'approche précédente, cela pourrait ressembler à ceci :

element.onclick = function(event){
  doMission1();
  doMission2(event.clientX, event.clientY);
  doMission3();
  // ...
  doMissionXX();
};

Bien qu'il soit acceptable de l'utiliser de cette façon, dans ce cas, vous pouvez en fait envisager une manière d'écrire plus élégante :

element.onclick = function(event){
  amplify.publish( "aya:clicked", {
    x: event.clientX,
    y: event.clientY
  });
};

Ce formulaire est une distribution d'événements. Veuillez noter que les événements ici ne font pas référence aux événements natifs du navigateur (objets d'événement), mais aux événements personnalisés au niveau logique. L'aya:cliqué ci-dessus est un nom d'événement personnalisé écrit avec désinvolture (vraiment ?).

Évidemment, ce n'est pas encore la fin. Afin de compléter les fonctions complexes précédentes, nous devons encore associer des événements personnalisés aux choses à faire :

amplify.subscribe( "aya:clicked", doMission1);
// ...
amplify.subscribe( "aya:clicked", doMission2);
// ...

On dirait que ça revient ? C'est vrai, mais ça marche. D'une part, l'écoute des événements natifs du navigateur a été séparée et solidifiée. Si les fonctions logiques changent dans le futur, par exemple, plusieurs fonctions sont réduites, il suffit de supprimer la partie code associée de l'événement personnalisé, et là. il n'y a plus lieu de s'inquiéter des événements autochtones. D'un autre côté, l'ajustement des fonctions logiques est devenu plus flexible. Les fonctions peuvent être ajoutées via un abonnement à n'importe quel emplacement de code, et la gestion de la classification (noms d'événements personnalisés) peut être effectuée par soi-même.

Pour faire simple, la distribution d'événements réduit le couplage entre les modules de code en ajoutant une couche de redondance d'événements personnalisés (quand il n'y a que des fonctions logiques simples, vous penserez que c'est redondant), rendant la logique Les fonctions sont plus claires et organisé, facilitant ainsi la maintenance ultérieure.

Attendez une minute, que fait ce fameux ampli devant moi qui a voyagé plusieurs fois à l'étranger ?

Bien, il est enfin temps de présenter ça.
AmplifyJS

La distribution d'événements nécessite la mise en œuvre de certaines méthodes. L'un des modèles de conception pour la distribution d'événements est la publication/l'abonnement.

AmplifyJS est une bibliothèque JavaScript simple qui fournit principalement trois fonctions : requête Ajax, stockage de données et publication/abonnement (chacune pouvant être utilisée indépendamment). Parmi elles, publier/s'abonner est la fonction principale et le nom correspondant est amplify.core.

amplify.core est une implémentation concise et claire du modèle de conception de publication/abonnement, avec plus de 100 lignes au total, y compris les commentaires. Après avoir lu le code source d'amplify, vous pourrez mieux comprendre comment implémenter un modèle de conception de publication/abonnement.
Aperçu du code

La structure globale du code source d'amplify.core est la suivante :

(function( global, undefined ) {

var slice = [].slice,
  subscriptions = {};

var amplify = global.amplify = {
  publish: function( topic ) {
    // ...
  },

  subscribe: function( topic, context, callback, priority ) {
    // ...
  },

  unsubscribe: function( topic, context, callback ) {
    // ...
  }
};

}( this ) );

Comme vous pouvez le voir, amplify définit une variable globale nommée amplify (en tant qu'attribut de global), qui dispose de trois méthodes de publication, d'abonnement et de désabonnement. De plus, les abonnements servent de variable locale qui enregistrera tous les noms d'événements personnalisés et les fonctions associées impliquées dans le mode publication/abonnement.
publier

publish est publié. Cela nécessite de spécifier un sujet, qui est un nom d'événement personnalisé (ou simplement appelé un sujet). Après l'appel, toutes les fonctions associées à un certain sujet seront appelées dans l'ordre :

publish: function( topic ) {
  // [1]
  if ( typeof topic !== "string" ) {
    throw new Error( "You must provide a valid topic to publish." );
  }
  // [2]
  var args = slice.call( arguments, 1 ),
    topicSubscriptions,
    subscription,
    length,
    i = 0,
    ret;

  if ( !subscriptions[ topic ] ) {
    return true;
  }
  // [3]
  topicSubscriptions = subscriptions[ topic ].slice();
  for ( length = topicSubscriptions.length; i < length; i++ ) {
    subscription = topicSubscriptions[ i ];
    ret = subscription.callback.apply( subscription.context, args );
    if ( ret === false ) {
      break;
    }
  }
  return ret !== false;
},

[1]，参数topic必须要求是字符串，否则抛出一个错误。

[2]，args将取得除topic之外的其他所有传递给publish函数的参数，并以数组形式保存。如果对应topic在subscriptions中没有找到，则直接返回。

[3]，topicSubscriptions作为一个数组，取得某一个topic下的所有关联元素，其中每一个元素都包括callback及context两部分。然后，遍历元素，调用每一个关联元素的callback，同时带入元素的context和前面的额外参数args。如果任意一个关联元素的回调函数返回false，则停止运行其他的并返回false。
subscribe

订阅，如这个词自己的含义那样（就像订本杂志什么的），是建立topic和callback的关联的步骤。比较特别的是，amplify在这里还加入了priority（优先级）的概念，优先级的值越小，优先级越高，默认是10。优先级高的callback，将会在publish的时候，被先调用。这个顺序的原理可以从前面的publish的源码中看到，其实就是预先按照优先级从高到低依次排列好了某一topic的所有关联元素。

subscribe: function( topic, context, callback, priority ) {
    if ( typeof topic !== "string" ) {
      throw new Error( "You must provide a valid topic to create a subscription." );
    }
    // [1]
    if ( arguments.length === 3 && typeof callback === "number" ) {
      priority = callback;
      callback = context;
      context = null;
    }
    if ( arguments.length === 2 ) {
      callback = context;
      context = null;
    }
    priority = priority || 10;
    // [2]
    var topicIndex = 0,
      topics = topic.split( /\s/ ),
      topicLength = topics.length,
      added;
    for ( ; topicIndex < topicLength; topicIndex++ ) {
      topic = topics[ topicIndex ];
      added = false;
      if ( !subscriptions[ topic ] ) {
        subscriptions[ topic ] = [];
      }
      // [3]
      var i = subscriptions[ topic ].length - 1,
        subscriptionInfo = {
          callback: callback,
          context: context,
          priority: priority
        };
      // [4]
      for ( ; i >= 0; i-- ) {
        if ( subscriptions[ topic ][ i ].priority <= priority ) {
          subscriptions[ topic ].splice( i + 1, 0, subscriptionInfo );
          added = true;
          break;
        }
      }
      // [5]
      if ( !added ) {
        subscriptions[ topic ].unshift( subscriptionInfo );
      }
    }

    return callback;
  },

[1]，要理解这一部分，请看amplify提供的API示意：

amplify.subscribe( string topic, function callback )
amplify.subscribe( string topic, object context, function callback )
amplify.subscribe( string topic, function callback, number priority )
amplify.subscribe(
  string topic, object context, function callback, number priority )

可以看到，amplify允许多种参数形式，而当参数数目和类型不同的时候，位于特定位置的参数可能会被当做不同的内容。这也在其他很多JavaScript库中可以见到。像这样，通过参数数目和类型的判断，就可以做到这种多参数形式的设计。

[2]，订阅的时候，topic是允许空格的，空白符将被当做分隔符，认为是将一个callback关联到多个topic上，所以会使用一个循环。added用作标识符，表明新加入的这个元素是否已经添加到数组内，初始为false。

[3]，每一个callback的保存，实际是一个对象，除callback外还带上了context（默认为null）和priority。

[4]，这个循环是在根据priority的值，找到关联元素应处的位置。任何topic的关联元素都是从无到有，且依照priority数值从小到大排列（已排序的）。因此，在比较的时候，是先假设新加入的元素的priority数值较大（优先级低），从数组尾端向前比较，只要原数组中有关联元素的priority数值比新加入元素的小，循环就可以中断，且可以确定地用数组的splice方法将新加入的元素添加在此。如果循环一直运行到完毕，则可以确定新加入的元素的priority数值是最小的，此时added将保持为初始值false。

[5]，如果到这个位置，元素还没有被添加，那么执行添加，切可以确定元素应该位于数组的最前面（或者是第一个元素）。
unsubscribe

虽然发布和订阅是最主要的，但也会有需要退订的时候（杂志不想看了果断退！）。所以，还会需要一个unsubscribe。

unsubscribe: function( topic, context, callback ) {
  if ( typeof topic !== "string" ) {
    throw new Error( "You must provide a valid topic to remove a subscription." );
  }

  if ( arguments.length === 2 ) {
    callback = context;
    context = null;
  }

  if ( !subscriptions[ topic ] ) {
    return;
  }

  var length = subscriptions[ topic ].length,
    i = 0;

  for ( ; i < length; i++ ) {
    if ( subscriptions[ topic ][ i ].callback === callback ) {
      if ( !context || subscriptions[ topic ][ i ].context === context ) {
        subscriptions[ topic ].splice( i, 1 );
        
        // Adjust counter and length for removed item
        i--;
        length--;
      }
    }
  }
}

读过前面的源码后，这部分看起来就很容易理解了。根据指定的topic遍历关联元素，找到callback一致的，然后删除它。由于使用的是splice方法，会直接修改原始数组，因此需要手工对i和length再做一次调整。
Amplify使用示例

官方提供的其中一个使用示例是：

amplify.subscribe( "dataexample", function( data ) {
  alert( data.foo ); // bar
});

//...

amplify.publish( "dataexample", { foo: "bar" } );

结合前面的源码部分，是否对发布/订阅这一设计模式有了更明确的体会呢？
补充说明

你可能也注意到了，AmplifyJS所实现的典型的发布/订阅是同步的（synchronous）。也就是说，在运行amplify.publish(topic)的时候，是会没有任何延迟地把某一个topic附带的所有回调，全部都运行一遍。
结语

Pub/Sub是一个比较容易理解的设计模式，但非常有用，可以应对大型应用的复杂逻辑。本文简析的AmplifyJS是我觉得写得比较有章法而且简明切题（针对单一功能）的JavaScript库，所以在此分享给大家。