Es6 a-t-il un mode usine ?

es6 a un mode usine ; le mode usine encapsule la logique dans une fonction. Dans es6, vous pouvez créer des objets sans utiliser de constructeur, mais utilisez la classe avec le mot-clé static pour encapsuler une usine simple dans une méthode statique de la classe User. La syntaxe est "class User{constructor}static static method(){}".

L'environnement d'exploitation de ce tutoriel : système Windows 10, ECMAScript version 6.0, ordinateur Dell G3.

Es6 a-t-il un modèle d'usine ? ES6 nous fournit la nouvelle syntaxe de classe. Bien que la classe soit essentiellement un sucre syntaxique, cela ne change rien au fait que JavaScript est un langage qui utilise l'héritage prototypique, mais il permet la création et l'héritage de. objets. Le processus devient plus clair et plus facile à lire. Réécrivons l'exemple ci-dessus en utilisant la nouvelle syntaxe d'ES6.

ES6 réécrit le modèle d'usine simple

Lors de la réécriture du modèle d'usine simple à l'aide d'ES6, nous n'utilisons plus le constructeur pour créer des objets, mais utilisons la nouvelle syntaxe de classe et utilisons le mot-clé static pour encapsuler l'usine simple dans le Classe d'utilisateurs Parmi les méthodes statiques :

//User类
class User {
  //构造器
  constructor(opt) {
    this.name = opt.name;
    this.viewPage = opt.viewPage;
  }
  //静态方法
  static getInstance(role) {
    switch (role) {
      case 'superAdmin':
      return new User({ name: '超级管理员', viewPage: ['首页', '通讯录', '发现页', '应用数据', '权限管理'] });
        break;
      case 'admin':
        return new User({ name: '管理员', viewPage: ['首页', '通讯录', '发现页', '应用数据'] });
        break;
      case 'user':
        return new User({ name: '普通用户', viewPage: ['首页', '通讯录', '发现页'] });
        break;
      default:
        throw new Error('参数错误, 可选参数:superAdmin、admin、user')
    }
  }
}

//调用
let superAdmin = User.getInstance('superAdmin');
let admin = User.getInstance('admin');
let normalUser = User.getInstance('user');

Le mode usine est le mode de développement le plus courant, qui encapsule la nouvelle opération séparément. Lors de la rencontre de nouvelles, le mode usine doit être pris en compte. Créez des objets sans exposer la logique du code et écrivez la logique dans des fonctions. Cette fonction est le modèle d'usine. Avantages : simplicité. L'inconvénient est qu'à chaque fois qu'un constructeur est ajouté, la logique du code dans la fonction doit être modifiée.

Le modèle d'usine est l'un des modèles de conception les plus couramment utilisés pour créer des objets. Nous n'exposons pas la logique spécifique de création d'objets, mais encapsulons la logique dans une fonction, cette fonction peut alors être considérée comme une usine. Les modèles d'usine peuvent être divisés en usines simples, méthodes d'usine et usines abstraites selon différents niveaux d'abstraction.

Si vous n'avez été exposé qu'au langage JavaScript, vous pourriez être un peu confus quant au concept d'abstrait, car JavaScript a toujours considéré l'abstrait comme un mot réservé et ne l'a pas implémenté. Si vous ne comprenez pas bien les concepts abstraits, il sera difficile de comprendre les similitudes et les différences entre les trois méthodes du modèle d'usine. Par conséquent, décrivons d’abord brièvement les concepts d’abstraction et d’usine avec un scénario.

Le modèle d'usine simple est également appelé modèle d'usine statique. Un objet d'usine détermine la création d'une instance d'une certaine classe d'objets de produit. Principalement utilisé pour créer des objets du même type.

Dans les projets réels, nous devons souvent afficher différentes pages en fonction des autorisations des utilisateurs. Certaines pages appartenant à des utilisateurs disposant d'autorisations de haut niveau ne peuvent pas être consultées par des utilisateurs disposant d'autorisations de bas niveau. Nous pouvons ainsi enregistrer les pages que l'utilisateur peut voir dans le constructeur d'utilisateurs avec différents niveaux d'autorisation. Instanciez les utilisateurs en fonction des autorisations.

Le code est le suivant :

class SuperAdmin{
  constructor(){
    this.name = "超级管理员";
    this.viewPage = ['首页', '通讯录', '发现页', '应用数据', '权限管理'];
  }
}
class Admin{
  constructor(){
    this.name = "管理员";
    this.viewPage = ['首页', '通讯录', '发现页', '应用数据', '权限管理'];
  }
}
class NormalUser{
  constructor(){
    this.name = "普通用户";
    this.viewPage = ['首页', '通讯录', '发现页', '应用数据', '权限管理'];
  }
}
//工厂方法类
class UserFactory {
  getFactory(role){
   switch (role) {
     case 'superAdmin':
       return new SuperAdmin();
       break;
     case 'admin':
       return new Admin();
       break;
     case 'user':
       return new NormalUser();
       break;
     default:
       throw new Error('参数错误, 可选参数:superAdmin、admin、user');
   }
  }
 }
 
//调用
let uesr =new UserFactory();
uesr.getFactory('superAdmin');
uesr.getFactory('admin');
uesr.getFactory('user');

L'avantage d'une usine simple est qu'il vous suffit d'un paramètre correct pour obtenir l'objet dont vous avez besoin sans connaître les détails précis de sa création. Cependant, la fonction contient la logique de création (constructeur) et le code logique de jugement de tous les objets. Chaque fois qu'un nouveau constructeur est ajouté, le code logique de jugement doit être modifié.

Lorsque nos objets ne sont pas les 3 ci-dessus mais 30 ou plus, cette fonction deviendra une énorme super fonction et sera difficile à maintenir.

Ainsi, l'usine simple ne peut être utilisée que lorsque le nombre d'objets créés est faible et que la logique de création d'objets n'est pas complexe.

【Recommandations associées :

tutoriel vidéo javascript

, front-end web】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!