recherche
Maisoninterface Webjs tutorielRésumé de l'expérience d'apprentissage de l'héritage Javascript_Connaissances de base

Après avoir lu beaucoup de choses sur l'héritage js, il est temps de résumer.
Permettez-moi d'abord de vous donner une compréhension générale. J'espère que vous pourrez me corriger si je me trompe, afin que je puisse corriger mes trois points de vue. De plus, les exemples suivants ne sont pas originaux, ce sont simplement des noms de variables modifiés, et certains sont même utilisés directement.

À quoi sert l'héritage js :

Tout d'abord, js n'a pas le même concept d'héritage que les autres langages orientés objet. L'héritage mentionné dans js fait référence à l'héritage simulé.
À quoi sert exactement l'héritage js ? Lorsque j'ai commencé à travailler sur le front-end, je l'ai utilisé pour des interviews (je ne l'ai pratiquement pas utilisé lorsque j'ai écrit quelques petits effets pour la première fois. Pourquoi dois-je le lire ? Parce que les intervieweurs adorent pour poser cette question), je l'ai donc juste utilisé pour des entretiens. Jetez-y un coup d'œil, et si vous pouvez donner un aperçu lors de l'entretien, vous êtes considéré comme un bon intervieweur sur cette question. Plus tard, j’ai progressivement commencé à l’utiliser même si le concept n’était pas très clair.
A quoi sert-il réellement ? Il sert principalement à réutiliser le code que nous avons écrit auparavant. Par exemple, si nous avons écrit une fonction, un objet ou utilisé quelque chose écrit par quelqu'un d'autre et que nous voulons ajouter quelque chose nous-mêmes, nous ne pouvons pas modifier les éléments de quelqu'un d'autre. Nous pouvons simplement en hériter et l'utiliser. utilisation réelle de l'héritage.

Comment implémenter l'héritage js :
Je n’entrerai pas dans le code en premier, parlons d’abord de mes réflexions. En fait, l'héritage consiste à trouver des moyens de transférer les propriétés ou les méthodes d'autres objets (tout dans js est un objet) vers notre propre objet, afin que notre propre objet puisse être utilisé. Cela permet également d’atteindre l’objectif de réutilisation.
Maintenant que le but est clair, voici les moyens pour y parvenir.
Selon les caractéristiques de js, l'implémentation n'est rien de plus qu'une ou une combinaison des méthodes suivantes.

1. Constructeur, js ne semble pas avoir de définition stricte du constructeur, mais vous pouvez utiliser new pour créer de nouveaux objets. On dit que le constructeur est également une méthode pour implémenter l'héritage dans des langages strictement orientés objet, donc bien sûr js peut le simuler, donc les personnes qui ont appris le langage oop y penseront en premier.

2. Utilisez des prototypes de fonctions et des chaînes de prototypes pour relier deux objets. Parce que la chaîne de prototypes js est relativement unique, il est facile d'y penser.
Il existe plusieurs types de prototypes, c'est-à-dire ce qui est utilisé comme prototype de l'objet hérité, prototype de l'objet hérité ou instance de l'objet hérité, ou encore héritier direct. Les effets d'héritage obtenus par ces prototypes en tant qu'objets d'héritage sont différents.

3. Copiez les attributs et les méthodes. Copiez et clonez simplement tous les attributs ou méthodes de l'objet hérité et transformez-les en attributs et méthodes de nos propres objets. Bien entendu, cela peut être divisé en deux situations : la copie superficielle et la copie approfondie.

4. Utilisez les deux méthodes call et apply. Ces deux méthodes sont assez magiques et peuvent changer le contexte d'exécution de la fonction (this). Par conséquent, l'utilisation de ces deux méthodes peut également réaliser l'héritage et la réutilisation des méthodes héritées. objet. .

D'une manière générale, les moyens d'obtenir l'héritage dans js sont probablement les suivants. Les méthodes d'implémentation en constante évolution sont toutes combinées et mises à niveau en fonction de ces méthodes. Pourquoi la plupart d'entre elles sont-elles utilisées en combinaison ? une seule méthode. Pas idéal. Bien entendu, vous pouvez choisir la méthode à utiliser en fonction des besoins réels de votre projet, à condition qu'elle réponde à vos propres besoins et ne précise pas quelle méthode doit être utilisée pour y parvenir. C'est comme dire que le moyen le plus rapide pour aller de Pékin à Shijiazhuang est l'avion. Mais si c'est loin de l'aéroport, y compris pour se rendre à l'aéroport et aller de l'aéroport à la ville, ce n'est pas aussi rapide que le train à grande vitesse dans son ensemble, alors vous pouvez prendre le train à grande vitesse. Par exemple, si vous avez une voiture et pouvez conduire, mais si vous voulez relever un défi, vous pouvez faire du vélo. Vous pouvez choisir cela en fonction de votre situation réelle.


Implémentation du code, parlons des méthodes d'implémentation ci-dessus basées sur le code. Certaines d'entre elles sont extraites d'autres endroits et ajoutons quelques commentaires.

Après avoir lu beaucoup de choses sur l'héritage js, il est temps de résumer.
Permettez-moi d'abord de vous donner une compréhension générale. J'espère que vous pourrez me corriger si je me trompe, afin que je puisse corriger mes trois points de vue. De plus, les exemples suivants ne sont pas originaux, ce sont simplement des noms de variables modifiés, et certains sont même utilisés directement.

À quoi sert l'héritage js :

Tout d'abord, js n'a pas le même concept d'héritage que les autres langages orientés objet. L'héritage mentionné dans js fait référence à l'héritage simulé.
À quoi sert exactement l'héritage js ? Lorsque j'ai commencé à travailler sur le front-end, je l'ai utilisé pour des interviews (je ne l'ai pratiquement pas utilisé lorsque j'ai écrit quelques petits effets pour la première fois. Pourquoi dois-je le lire ? Parce que les intervieweurs adorent pour poser cette question), je l'ai donc juste utilisé pour des entretiens. Jetez-y un coup d'œil, et si vous pouvez donner un aperçu lors de l'entretien, vous êtes considéré comme un bon intervieweur sur cette question. Plus tard, j’ai progressivement commencé à l’utiliser même si le concept n’était pas très clair.
A quoi sert-il réellement ? Il sert principalement à réutiliser le code que nous avons écrit auparavant. Par exemple, si nous avons écrit une fonction, un objet ou utilisé quelque chose écrit par quelqu'un d'autre et que nous voulons ajouter quelque chose nous-mêmes, nous ne pouvons pas modifier les éléments de quelqu'un d'autre. Nous pouvons simplement en hériter et l'utiliser. utilisation réelle de l'héritage.

Comment implémenter l'héritage js :
Ne parlons pas d’abord du code, parlons d’abord de l’idée. En fait, l'héritage consiste à trouver des moyens de transférer les propriétés ou les méthodes d'autres objets (tout dans js est un objet) vers notre propre objet, afin que notre propre objet puisse être utilisé. Cela permet également d’atteindre l’objectif de réutilisation.
Maintenant que le but est clair, voici les moyens pour y parvenir.
Selon les caractéristiques de js, l'implémentation n'est rien de plus qu'une ou une combinaison des méthodes suivantes.

1. Constructeur, js ne semble pas avoir de définition stricte du constructeur, mais vous pouvez utiliser new pour créer de nouveaux objets. On dit que le constructeur est également une méthode pour implémenter l'héritage dans des langages strictement orientés objet, donc bien sûr js peut le simuler, donc les personnes qui ont appris le langage oop y penseront en premier.

2. Utilisez des prototypes de fonctions et des chaînes de prototypes pour relier deux objets. Parce que la chaîne de prototypes js est relativement unique, il est facile d'y penser.
Il existe plusieurs types de prototypes, c'est-à-dire ce qui est utilisé comme prototype de l'objet hérité, prototype de l'objet hérité ou instance de l'objet hérité, ou encore héritier direct. Les effets d'héritage obtenus par ces prototypes en tant qu'objets d'héritage sont différents.

3. Copiez les attributs et les méthodes. Copiez et clonez simplement tous les attributs ou méthodes de l'objet hérité et transformez-les en attributs et méthodes de nos propres objets. Bien entendu, cela peut être divisé en deux situations : la copie superficielle et la copie approfondie.

4. Utilisez les deux méthodes call et apply. Ces deux méthodes sont assez magiques et peuvent changer le contexte d'exécution de la fonction (this). Par conséquent, l'utilisation de ces deux méthodes peut également réaliser l'héritage et la réutilisation des méthodes héritées. objet. .

D'une manière générale, les moyens d'obtenir l'héritage dans js sont probablement les suivants. Les méthodes d'implémentation en constante évolution sont toutes combinées et mises à niveau en fonction de ces méthodes. Pourquoi la plupart d'entre elles sont-elles utilisées en combinaison ? une seule méthode. Pas idéal. Bien entendu, vous pouvez choisir la méthode à utiliser en fonction des besoins réels de votre projet, à condition qu'elle réponde à vos propres besoins et ne précise pas quelle méthode doit être utilisée pour y parvenir. C'est comme dire que le moyen le plus rapide pour aller de Pékin à Shijiazhuang est l'avion. Mais si c'est loin de l'aéroport, y compris pour se rendre à l'aéroport et aller de l'aéroport à la ville, ce n'est pas aussi rapide que le train à grande vitesse dans son ensemble, alors vous pouvez prendre le train à grande vitesse. Par exemple, si vous avez une voiture et pouvez conduire, mais si vous voulez relever un défi, vous pouvez faire du vélo. Vous pouvez choisir cela en fonction de votre situation réelle.


Implémentation du code, parlons des méthodes d'implémentation ci-dessus basées sur le code. Certaines d'entre elles sont extraites d'autres endroits et ajoutons quelques commentaires.

1. Implémentation du constructeur (constructeur emprunteur) :

function Super(arg){
      this.arr1 = "I'm super "+arg;
      this.show = function(){
        alert(this.arr1);
      }
    }

    Super.prototype.say = function(){
      alert(this.arr1);
    }

    function suber(arg){
      Super.apply(this, arguments); //在suber的上下文中运行super
    }

    var sub =new suber("suber");
    var sub2 = new suber("suber1");

    console.log(sub.arr1); //I'm super suber
    console.log(sub.show); //function (){ alert(this.arr1);}
    console.log(sub.say); //undefined
    console.log(sub.show === sub2.show); //false

Oups, j'ai trouvé que sub.say n'est pas défini, ce qui signifie qu'il n'a pas été hérité. L'affichage des deux objets sub et sub2 ci-dessous n'est pas égal, ce qui signifie que les deux fonctions pointent vers deux objets différents, ce qui signifie. ils sont copiés. Deux exemplaires sont sortis.

Donc, si cette méthode implémente l'héritage, les propriétés et méthodes de l'objet prototype ne seront pas héritées. Les propriétés et méthodes de Super seront copiées séparément pour chaque nouvel objet.
Par conséquent, il n’est pas approprié d’utiliser cette méthode seule pour implémenter l’héritage, car aucune des méthodes du prototype n’a été héritée. Alors les maîtres ont eu l'idée de l'héritage prototype

2. Héritage prototype :

function Super(arg){
      this.arr1 = "I'm super "+arg;
      this.show = function(){
        alert(this.arr1);
      }
    }

    Super.prototype.say = function(){
      alert(this.arr1);
    }

    function suber(arg){}

    suber.prototype = new Super();

    var sub = new suber("suber1");
    var sub2 = new suber("suber2");

    console.log(sub.arr1); //I'm super undefined
    console.log(sub.show); //function (){ alert(this.arr1);}
    console.log(sub.say); //function (){ alert(this.arr1);}
    console.log(sub.show === sub2.show);  //true;
    console.log(sub.say === sub2.say);  //true;


Cette fois, arr1 a été hérité, mais les paramètres n'ont pas été ajoutés et n'étaient pas définis. Par conséquent, lorsque la sous-classe de cette méthode a été déclarée, le paramètre transmis et la propriété héritée de la sous-classe n'ont pas pu être reçus. Tout le reste est assez normal. Montrer et dire sont tous deux hérités. Mais une chose à noter est que say est hérité via l'objet prototype de super, et show est un attribut de l'instance lors de la création d'une nouvelle instance de super objet.

Alors, comment implémenter la transmission des paramètres et hériter des éléments du prototype. Bien sûr, il suffit de combiner les deux méthodes ci-dessus, donc les seniors ont inventé la méthode suivante


3. Héritage combiné (emprunter le constructeur et définir le prototype) :

function Super(arg){
      this.arr1 = "I'm super "+arg;
      this.show = function(){
        alert(this.arr1);
      }
    }

    Super.prototype.say = function(){
      alert(this.arr1);
    }

    function suber(arg){
      Super.apply(this, arguments);
    }

    suber.prototype = new Super();


    var sub = new suber("suber1");
    var sub2 = new suber("suber2");

    console.log(sub.arr1); //I'm super suber1
    console.log(sub.show); //function (){ alert(this.arr1);}
    console.log(sub.say); //function (){ alert(this.arr1);}
    console.log(sub.show === sub2.show);  //false;
    console.log(sub.say === sub2.say);  //true;

Cette fois, c'est presque parfait, mais vous pouvez constater que sub.show et sub2.show ne sont pas égaux. Pourquoi est-ce parce que le lieu d'application fait que show devient le propre attribut de suber, alors mettez-le simplement dans le prototype de suber ? Le show (le show de Super est utilisé comme objet d'instance du sous-prototype) est écrasé, il est donc copié un par un. Bien sûr, il n'y a aucun moyen d'éviter cela. Afin de ne pas encourir cette surcharge inutile, davantage de ces fonctions partageables peuvent être placées dans des objets prototypes.
Étant donné que les appels lors de la construction de suber et les appels lors de l'attribution de valeurs à l'objet prototype suber provoquent l'appel de Super deux fois, alors Super est appelé deux fois à chaque fois qu'un nouvel objet suber est créé, et deux objets d'instance seront générés lorsque appelé deux fois. Les ressources excédentaires doivent être consommées.

Les seniors ont donc ouvert leur esprit pour résoudre ce problème et ont développé la méthode suivante.

4. Héritage des combinaisons parasites :
La principale différence entre cette méthode et la méthode 3 est que le prototype de la classe parent est affecté au prototype de la classe enfant au lieu de l'exemple de la classe parent

.

function Super(arg){
  this.arr1 = "I'm super "+arg;
  
}

Super.prototype.show = function(){ //这个方法放到了原型对象上。
    alert(this.arr1);
  }
Super.prototype.say = function(){
  alert(this.arr1);
}

function suber(arg){
  Super.apply(this, arguments);
}

/*inherit函数的作用,使用一个新的空函数,来切断父类对象的原型对象与子类原型对象的直接联系,而是通过这个空构造的实例对象实现继承,这样可以避免更改子类原型的属性或者方法而影响了父类原型对象的属性或者方法。*/

function inherit(obj){ 
  function F(){}
  F.prototype = obj;
  return new F();  
}

suber.prototype = inherit(Super.prototype);


var sub = new suber("suber1");
var sub2 = new suber("suber2");

console.log(sub.arr1); //I'm super suber1
console.log(sub.show); //function (){ alert(this.arr1);}
console.log(sub.say); //function (){ alert(this.arr1);}
console.log(sub.show === sub2.show);  //true;
console.log(sub.say === sub2.say);  //true;

好了,这样就把三方法的弊端干掉了,这个可以完美的使用了吧。

五、复制属性实现

拷贝我们可以写一个拷贝函数来实现。

function extend(Super,suber){
  suber = suber || {};
  for(var i in Super){
    if(Super.hasOwnProperty(i)){
      suber[i] = Super[i];
    }
   }
  return suber;
}


var parent = {
  name:"dad",
  num:[1,2,3],
  say:function(){alert("dad");}
}

var child = {
  age:5,
  sex:"boy"
};

child = extend(parent, child);

//以下测试
console.log(child); /*{
             age:5,
             sex:"boy",
             name:"dad",
             num:[1,2,3],
             say:function(){alert("dad");}
            }*/
console.log(child.say === parent.say); //true
console.log(child.num === parent.num); //true

复制成功,那么child成功继承了parent的一些属性,但是后面两个测试发现他们是相等的,就表明了他们在公用同一个数组,同一个函数,函数这个可以,但是数组这个就有问题了,如果一个chiild改变了数组,几个被继承对象的数组也跟着变了,这就不给力了啊。
为什么会发生这种情况呢,js里边对象存储的是指针,然后这个指针指向这个值,我们在这复制的实际是指向该对象的指针的值,所以继承对象和被继承对象都指向了同一个对象,接下来看看如何使用深度复制来解决这个问题。

深度复制对象属性:

function extenddeep(Super, suber){
      var tostr = Object.prototype.toString, astr = "[object Array]";
      suber = suber || {};

      for(var i in Super){
        if(Super.hasOwnProperty(i)){
          if(typeof Super[i] === "object"){
            suber[i] = (tostr.call(Super[i]) == astr) ? [] : {};
            extenddeep(Super[i],suber[i]);
          }else {
            suber[i] = Super[i];
          }
        }
      }

      return suber;
    }


    var parent = {
      name:"papa",
      num:[1,2,3],
      say:function(){alert("I'm father of my son!");}
    }

    var child = {
      name:"jone",
      sex:"boy",
    }

    var kid = extenddeep(parent, child);

    console.log(kid);  // {name: "papa"
                num: Array[3]
                say: ()
                sex: "boy"
              // }

    console.log(kid.say === parent.say); //true
    console.log(kid.num === parent.num);  //false
    console.log(kid.name); //papa

好了,深度复制完毕,但似有木有发现问题,name是parent的,也就是说如果继承对象有和被继承对象一样的属性名的属性如果不做处理就会被替换掉。那么我们可以做一下处理,先声明一个属性,保存parent里的东西,剩下的的当然就是child自己的东西了,最后再把属性给child对象就可以了。

六、利用call和apply这两个方法(借用方法)。
这个就是通过call和apply来复用其他对象的方法,达到复用的目的。

var one = {
      name:"object",
      say: function(greet){
        return greet + ', ' + this.name;
      }
    }

    var tow = {
      name:"two"
    }

    one.say.call(tow, "hi");  //hi, two

这个就是借用了,好了,下课。

好吧,好吧,其实这里边还有其他东西要看。可以借用并不“带表”可以随便把某个方法赋值给谁然后跟没发生什么似的继续用。所以我们平时使用借用时要注意一下上下文,下面看下那些容易出错的地方。

//赋值给一个变量时候上下文会变化
    var say = one.say;
    console.log(say('hoho')); // "hoho, undefined"

    //作为回调函数时也会发生变化
    var yetother = {
      name:"yetother obj",
      method:function(callback){
        return callback("Hola");
      }
    }

    console.log(yetother.method(one.say)); //"Hola, "

神马意思呢,就是this.name是undefined,当one.say赋值给say是,实际上是say存储了指向函数对象的指针,say这个变量明显又是全局变量的一个属性,那么它运行的时候实际的上下文就变成了windows了,当然这个时候name就变成undefined了。回调这个也是一样,return 的是函数运行的结果。如果我们事先设置 windows.name="windows" 那么得到的结果就变成了 "hoho, windows" 和"Hola, windows" 了。

function bind(o, m){
      return function(){
        return m.apply(o, [].slice.call(arguments));
      }
    }

    var othersay = bind(yetother, one.say);

    othersay("Hola"); //"Hola, yetother obj"

通过apply可以改变方法执行的上下文,那么我们构建一个函数来实现这样一个功能,通过使用方法调用实现上下文的改变,这样就不会出现上下文不是我们期望的上下文的情况了。

//这段是直接复制过来的。
    // ECMAScript 5给Function.prototype添加了一个bind()方法,以便很容易使用apply()和call()。

      if (typeof Function.prototype.bind === 'undefined') {
        Function.prototype.bind = function (thisArg) {
          var fn = this,
      slice = Array.prototype.slice,
      args = slice.call(arguments, 1);
          return function () {
            return fn.apply(thisArg, args.concat(slice.call(arguments)));
          };
        };
      }

      var twosay2 = one.say.bind(two);
      console.log(twosay2('Bonjour')); // "Bonjour, another object"

      var twosay3 = one.say.bind(two, 'Enchanté');
      console.log(twosay3()); // "Enchanté, another object"

介绍完了,该说说自己的疑惑了,当复制属性方法遇到的被继承对象里边存在方法,如何单独复制出来呢,现在的是直接共用了,因为毕竟方法一般不会经常改动。求解答?

下面是转载过来的jQuery的extend方法,好像也没有特殊处理函数这块,继承完了两个函数也是共用的。

$.extend源码

jQuery.extend = jQuery.fn.extend = function() {
          var options, name, src, copy, copyIsArray, clone,
             target = arguments[0] || {},
             i = 1,
             length = arguments.length,
             deep = false ;

          // Handle a deep copy situation
          //如果第一个参数是boolean类型
          //修正参数,将第二个参数作为target
          if ( typeof target === "boolean" ) {
             deep = target;

              // skip the boolean and the target
             target = arguments[ i ] || {};
              //i++是为了后续 i === length的判断
             i++;
          }

          // Handle case when target is a string or something (possible in deep copy)
          //如果目标既不是对象也不是方法(例如给基本类型扩展属性方法和属性不会报错但是是无用的),修正target为 js对象
          if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
             target = {};
          }

          // extend jQuery itself if only one argument is passed
          //如果只有一个参数,修正对象为JQuery函数或JQuery对象
          if ( i === length ) {
             target = this ;
              //修正target所在位置,后面的都是要添加给target的对象
             i--;
          }

          for ( ; i < length; i++ ) {
              // Only deal with non-null/undefined values
              if ( (options = arguments[ i ]) != null ) {
                 // Extend the base object
                 for ( name in options ) {
                    src = target[ name ];
                    copy = options[ name ];

                    // Prevent never-ending loop
                    //如果target和copy是同一个对象,略过,防止自己的属性引用了本身对象导致的循环引用,以致GC无法回收
                    if ( target === copy ) {
                        continue ;
                    }

                    // Recurse if we're merging plain objects or arrays
                    //如果是deep为true,并且要添加给target的copy为对象获数组
                    if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
                        if ( copyIsArray ) {
                           copyIsArray = false ;
                           clone = src && jQuery.isArray(src) &#63; src : [];

                       } else {
                           clone = src && jQuery.isPlainObject(src) &#63; src : {};
                       }
                 
                        // Never move original objects, clone them
                        //很巧妙 ,用一个递归,实现引用对象的深克隆,递归的返回条件是属性石基本类型,基本类型都是深克隆
                       target[ name ] = jQuery.extend( deep, clone, copy );

                    // Don't bring in undefined values
                    } else if ( copy !== undefined ) {
                        //浅克隆
                       target[ name ] = copy;
                    }
                 }
             }
          }

          // Return the modified object
          return target;
      };

以上这篇javascript 继承学习心得总结就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

Déclaration
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Moteurs JavaScript: comparaison des implémentationsMoteurs JavaScript: comparaison des implémentationsApr 13, 2025 am 12:05 AM

Différents moteurs JavaScript ont des effets différents lors de l'analyse et de l'exécution du code JavaScript, car les principes d'implémentation et les stratégies d'optimisation de chaque moteur diffèrent. 1. Analyse lexicale: convertir le code source en unité lexicale. 2. Analyse de la grammaire: générer un arbre de syntaxe abstrait. 3. Optimisation et compilation: générer du code machine via le compilateur JIT. 4. Exécuter: Exécutez le code machine. Le moteur V8 optimise grâce à une compilation instantanée et à une classe cachée, SpiderMonkey utilise un système d'inférence de type, résultant en différentes performances de performances sur le même code.

Au-delà du navigateur: Javascript dans le monde réelAu-delà du navigateur: Javascript dans le monde réelApr 12, 2025 am 12:06 AM

Les applications de JavaScript dans le monde réel incluent la programmation côté serveur, le développement des applications mobiles et le contrôle de l'Internet des objets: 1. La programmation côté serveur est réalisée via Node.js, adaptée au traitement de demande élevé simultané. 2. Le développement d'applications mobiles est effectué par le reactnatif et prend en charge le déploiement multiplateforme. 3. Utilisé pour le contrôle des périphériques IoT via la bibliothèque Johnny-Five, adapté à l'interaction matérielle.

Construire une application SaaS multi-locataire avec next.js (intégration backend)Construire une application SaaS multi-locataire avec next.js (intégration backend)Apr 11, 2025 am 08:23 AM

J'ai construit une application SAAS multi-locataire fonctionnelle (une application EdTech) avec votre outil technologique quotidien et vous pouvez faire de même. Premièrement, qu'est-ce qu'une application SaaS multi-locataire? Les applications saas multi-locataires vous permettent de servir plusieurs clients à partir d'un chant

Comment construire une application SaaS multi-locataire avec Next.js (Frontend Integration)Comment construire une application SaaS multi-locataire avec Next.js (Frontend Integration)Apr 11, 2025 am 08:22 AM

Cet article démontre l'intégration frontale avec un backend sécurisé par permis, construisant une application fonctionnelle EdTech SaaS en utilisant Next.js. Le frontend récupère les autorisations des utilisateurs pour contrôler la visibilité de l'interface utilisateur et garantit que les demandes d'API adhèrent à la base de rôles

JavaScript: Explorer la polyvalence d'un langage WebJavaScript: Explorer la polyvalence d'un langage WebApr 11, 2025 am 12:01 AM

JavaScript est le langage central du développement Web moderne et est largement utilisé pour sa diversité et sa flexibilité. 1) Développement frontal: construire des pages Web dynamiques et des applications à une seule page via les opérations DOM et les cadres modernes (tels que React, Vue.js, Angular). 2) Développement côté serveur: Node.js utilise un modèle d'E / S non bloquant pour gérer une concurrence élevée et des applications en temps réel. 3) Développement des applications mobiles et de bureau: le développement de la plate-forme multiplateuse est réalisé par réact noral et électron pour améliorer l'efficacité du développement.

L'évolution de JavaScript: tendances actuelles et perspectives d'avenirL'évolution de JavaScript: tendances actuelles et perspectives d'avenirApr 10, 2025 am 09:33 AM

Les dernières tendances de JavaScript incluent la montée en puissance de TypeScript, la popularité des frameworks et bibliothèques modernes et l'application de WebAssembly. Les prospects futurs couvrent des systèmes de type plus puissants, le développement du JavaScript côté serveur, l'expansion de l'intelligence artificielle et de l'apprentissage automatique, et le potentiel de l'informatique IoT et Edge.

Démystifier javascript: ce qu'il fait et pourquoi c'est importantDémystifier javascript: ce qu'il fait et pourquoi c'est importantApr 09, 2025 am 12:07 AM

JavaScript est la pierre angulaire du développement Web moderne, et ses principales fonctions incluent la programmation axée sur les événements, la génération de contenu dynamique et la programmation asynchrone. 1) La programmation axée sur les événements permet aux pages Web de changer dynamiquement en fonction des opérations utilisateur. 2) La génération de contenu dynamique permet d'ajuster le contenu de la page en fonction des conditions. 3) La programmation asynchrone garantit que l'interface utilisateur n'est pas bloquée. JavaScript est largement utilisé dans l'interaction Web, les applications à une page et le développement côté serveur, améliorant considérablement la flexibilité de l'expérience utilisateur et du développement multiplateforme.

Python ou JavaScript est-il meilleur?Python ou JavaScript est-il meilleur?Apr 06, 2025 am 12:14 AM

Python est plus adapté à la science des données et à l'apprentissage automatique, tandis que JavaScript est plus adapté au développement frontal et complet. 1. Python est connu pour sa syntaxe concise et son écosystème de bibliothèque riche, et convient à l'analyse des données et au développement Web. 2. JavaScript est le cœur du développement frontal. Node.js prend en charge la programmation côté serveur et convient au développement complet.

See all articles

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

AI Hentai Generator

AI Hentai Generator

Générez AI Hentai gratuitement.

Article chaud

R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
3 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Meilleurs paramètres graphiques
3 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Comment réparer l'audio si vous n'entendez personne
3 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
WWE 2K25: Comment déverrouiller tout dans Myrise
4 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌

Outils chauds

Adaptateur de serveur SAP NetWeaver pour Eclipse

Adaptateur de serveur SAP NetWeaver pour Eclipse

Intégrez Eclipse au serveur d'applications SAP NetWeaver.

DVWA

DVWA

Damn Vulnerable Web App (DVWA) est une application Web PHP/MySQL très vulnérable. Ses principaux objectifs sont d'aider les professionnels de la sécurité à tester leurs compétences et leurs outils dans un environnement juridique, d'aider les développeurs Web à mieux comprendre le processus de sécurisation des applications Web et d'aider les enseignants/étudiants à enseigner/apprendre dans un environnement de classe. Application Web sécurité. L'objectif de DVWA est de mettre en pratique certaines des vulnérabilités Web les plus courantes via une interface simple et directe, avec différents degrés de difficulté. Veuillez noter que ce logiciel

SublimeText3 version anglaise

SublimeText3 version anglaise

Recommandé : version Win, prend en charge les invites de code !

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

Télécharger la version Mac de l'éditeur Atom

Télécharger la version Mac de l'éditeur Atom

L'éditeur open source le plus populaire