Code d'implémentation du mode observateur en ruby, javascript, php

2020-05-23

L'intervieweur a été interrogé sur le modèle d'observateur en js. Cette chose est connue depuis longtemps. On peut dire que c'est un modèle de conception très utile dans les langages dynamiques. Il est très honteux qu'il n'y ait pas de recherche systématique. Mais peu importe, où il ne sera pas rempli, commencez immédiatement à le faire dans toutes les langues que vous connaissez.

Mode observateur

Concernant le mode observateur, "Matsumoto's Procedural World" est très clair: le mode observateur est que lorsque l'état d'un objet change, tous les objets qui dépendent de l'état sont automatiquement notifiés, l'observateur et l'observateur Ils sont une relation un-à-plusieurs. Le livre a également donné un exemple très facile à comprendre: obtenir l'heure actuelle du système et l'afficher sur la ligne de commande. Si vous voulez coder en dur, c'est aussi très simple, définissez une méthode, obtenez d'abord l'heure, puis traitez l'affichage. De cette façon, la fonction d'obtention du temps ne peut pas être réutilisée fondamentalement, car il existe une bouteille d'huile de traînée pour traiter l'affichage.

Si vous utilisez le mode observateur, vous pouvez le faire: définir deux classes, l'une pour le chronométrage pour obtenir l'heure actuelle, l'autre pour l'affichage de l'heure. La classe de temps d'affichage est l'observateur, et l'avantage de le faire est de réduire la dépendance mutuelle. Il n'est pas nécessaire de traiter quoi que ce soit après le changement de la première classe. Il suffit d'envoyer une notification pour informer ses observateurs que des choses spécifiques sont gérées par eux. Par exemple, un jour, nous voulons afficher l'heure sous une autre forme, ou afficher l'heure de plusieurs façons, sans impliquer la première catégorie du tout.

PS: "Procedure World of Matsumoto Hiroki" est vraiment un bon livre. Au début, je voulais lire ce livre comme un tutoriel rubis, mais j'ai trouvé que ce n'était pas du tout le cas. Le livre expliquait beaucoup d'idées philosophiques profondes dans un langage très facile à comprendre. Bien que ce livre n'ait pratiquement aucune valeur pratique pour une recrue comme moi qui ne fait que commencer, mais après l'avoir lu, j'ai un sentiment d'optimisme et d'ouverture, c'est une très bonne expérience de lecture.

implémentation ruby ​​

Utiliser Ruby pour implémenter le mode Observer est simple et clair, c'est scandaleux, le code ci-dessus:


copiez le code le code est le suivant:


nécessite "observateur"
# 被 personne observée
Sujet de classe
     inclure Observable
     def notifier
         #do sth
         l'indicateur #Update modifié est vrai
         notify_observers (* args) #Si le drapeau de mise à jour est vrai, appelez la méthode observateur avec le paramètre args
     fin
fin
#Observer
classe Obs
     Fonction #Callback, il semble qu'elle ne peut être appelée que comme ça
     mise à jour def
         #do sth
     fin
fin
#Exemple
sub = Subject.new
sub.add_observer (Obs.new)
sub.notify

Oui, c'est aussi simple que cela. . .
Il dépend principalement du module Observer. En plus de ceux utilisés ci-dessus, ce module possède également les interfaces suivantes:

1.delete_observer (obj) supprime un observateur spécifique
2.delete_observers supprimer tous les observateurs
3.count_observers obtient le nombre d'observateurs
4. changé? Vérifiez le logo de mise à jour

implémentation php

PHP n'est pas gênant à implémenter:

copiez le code le code est le suivant:


// personne observée
Sujet de classe
{
     $ _observers privés;
     fonction publique __construct () {
         $ this-> _ observers = array ();
     }
     fonction publique add_observer ($ obs) {
         $ this-> _ observers [] = $ obs;
     }
     fonction publique delete_observer ($ bos) {
         $ index = array_search ($ bos, $ this-> _ observers);
         unset ($ this-> _ observers [$ index]);
     }
     fonction publique notify_observers () {
         foreach ($ this-> _ observateurs as $ v) {
             $ v-> update ();
         }
     }
}
// Observateur
Observateur de classe
{
     fonction publique __construct () {
         faire qch;
     }
     mise à jour de la fonction publique () {
         faire qch;
     }
}
// Exemple
$ sub = new Subject ();
$ obs = new Observer ();
$ sub-> add_observer ($ obs);
$ sub-> notify_observers ();

implémentation js

js n'est pas gênant à implémenter, il est nécessaire d'écrire certaines fonctions utilitaires, telles que la suppression des éléments spécifiés du tableau. Seule la méthode d'implémentation la plus simple est utilisée ci-dessous.

copiez le code le code est le suivant:


// personne observée
fonction Subject () {
     var _this = this;
     this.observers = [];
     this.addObserver = function (obj) {
         _this.observers.push (obj);
     }
     this.deleteObserver = function (obj) {
         var length = _this.observers.length;
         pour (var i = 0; i              if (_this.observers [i] === obj) {
                 _this.obserers.splice (i, 1);
             }
         }
     }
     this.notifyObservers = function () {
         var length = _this.observers.length;
         console.log (longueur)
         pour (var i = 0; i              _this.observers [i] .update ();
         }
     }
}
// Observateur
fonction Observer () {
     this.update = function () {
         alerte (1)
     }
}
var sub = new Subject ();
var obs = new Observer ();
sub.addObserver (obs);
sub.notifyObservers ();
var sub = new Subject ();

Conclusion: ruby ​​nous permet de nous concentrer sur la programmation elle-même, pas sur la syntaxe et les fonctionnalités du programme. js est flexible et modifiable. C'est un langage de programmation complet qui peut tout faire sauf avoir des enfants. C'est un peu amusant à jouer. Bon, php, assez satisfaisant, il n'y a rien à dire.

Après l'exécution de tous ces programmes, il s'agit d'une compréhension complète de ce modèle de conception.

www.xd1998.com@2001-2030Partage De Technologie