96 questions d'entretien JS frontales de base (y compris les réponses)

[Recommandations associées : Questions d'entretien préliminaires]

1. Type de données ? Type de données complexe ? Type de valeur et type de données de référence ? Structure de données de pile

Type de données de base : Indéfini, Null, Booléen, Nombre, Chaîne
Type de valeur : Numérique , booléen, nul, indéfini.
Types de référence : objets, tableaux, fonctions.
Structure de données de pile : il s'agit d'une collection qui prend en charge le dernier entré, premier sorti (LIFO), c'est-à-dire que les données insérées plus tard sont supprimées en premier
Les méthodes suivantes sont fournies dans le tableau js pour créer ! il nous est facile d'implémenter la pile :
shift : supprime le premier élément du tableau et renvoie la valeur de cet élément.
unshift : ajoute un ou plusieurs éléments au début du tableau et renvoie la nouvelle longueur
push : ajoute des éléments à la fin du tableau et renvoie la nouvelle longueur
pop : supprime le dernier élément du array Supprime un élément et renvoie la valeur de cet élément.

2. L'effet de la déclaration des fonctions est amélioré ? Quelle est la différence entre la déclaration de variables et la déclaration de fonctions

(1) Promotion de la déclaration de variable : variable ? la déclaration est saisie. Le contexte d'exécution est complet.
Tant qu'une variable est déclarée dans le code, peu importe où elle est déclarée, le moteur js placera sa déclaration en haut de la portée

(2) Promotion de la déclaration de fonction : exécution La ; La déclaration de fonction est lue avant le code, ce qui signifie que la déclaration de fonction peut être placée après l'instruction qui l'appelle.
Tant que la fonction est déclarée dans le code, peu importe où elle est déclarée, le moteur js placera sa déclaration en haut de la portée

(3) Déclaration de variable ou de fonction : Fonction ; les déclarations remplacent les déclarations de variables, mais pas les affectations de variables.
Le même nom identifie a, c'est-à-dire qu'il existe une déclaration de variable var a et une déclaration de fonction function a() {} Quel que soit l'ordre des deux déclarations, la déclaration de fonction écrasera la déclaration de variable, c'est-à-dire. c'est-à-dire que la valeur de a à ce moment est la fonction déclarée function a() {}. Remarque : Si a est initialisé en même temps que la variable est déclarée, ou si une valeur est attribuée à a ultérieurement, la valeur de a à ce moment est la valeur de la variable. par exemple : var a; var c = 1; a = 1; function a() { return true; console.log(a);

3. 🎜 >
Les types renvoyés par typeof sont tous sous forme de chaînes, qui peuvent être utilisées pour déterminer le type de fonction ; c'est plus pratique pour déterminer des objets de type autre que Object ;

Méthode 1 : Fonction de rappel. L'avantage est qu'elle est simple, facile à comprendre et à déployer. L'inconvénient est qu'elle n'est pas propice à la lecture et à la maintenance des différentes parties. sont fortement couplés (Couplage), et le processus sera très compliqué, et une seule fonction de rappel peut être spécifiée par tâche.

Méthode 2 : Surveillance du temps, plusieurs événements peuvent être liés, chaque événement peut spécifier plusieurs fonctions de rappel et peut être « découplé », ce qui est propice à la modularisation. L'inconvénient est que l'ensemble du programme doit être piloté par des événements et que le processus en cours devient très flou.

Méthode 3 : Publier/Abonnez-vous, de nature similaire à "l'écoute d'événements", mais évidemment meilleure que cette dernière.

Méthode 4 : L'objet Promises est une spécification proposée par le groupe de travail CommonJS pour fournir une interface unifiée pour la programmation asynchrone.
En termes simples, l'idée est que chaque tâche asynchrone renvoie un objet Promise, qui possède une méthode then qui permet de spécifier une fonction de rappel.

Flux d'événements : l'ordre dans lequel les événements sont reçus depuis la page. C'est-à-dire que lorsqu'un événement survient, le processus de propagation de cet événement est le flux d'événements.

Le flux d'événements dans IE est appelé bouillonnement d'événements ; bouillonnement d'événements : l'événement est initialement reçu par l'élément le plus spécifique, puis propagé vers des nœuds moins spécifiques (documents). Pour HTML, lorsqu'un élément génère un événement, il transmettra l'événement à son élément parent. Une fois que l'élément parent l'aura reçu, il continuera à le transmettre à son élément de niveau supérieur, puis il sera propagé au document. Objet (Personnellement testé le navigateur actuel sur l'objet fenêtre, seuls IE8 et versions antérieures ne sont pas comme ça

La capture d'événement signifie que les éléments moins spécifiques doivent recevoir l'événement plus tôt et que le nœud le plus spécifique doit recevoir l'événement en dernier. Leur L'intention est de capturer l'événement avant qu'il n'atteigne la cible ; c'est-à-dire que c'est exactement le contraire du processus de bouillonnement. En prenant comme exemple l'événement click du HTML, l'objet document (la spécification au niveau DOM exige que la propagation commence à partir du document). document, mais les navigateurs actuels partent du document). En commençant par l'objet window) le premier à recevoir l'événement click, puis l'événement se propage vers le bas le long de l'arborescence DOM, jusqu'à la cible réelle de l'événement

6. Comment effacer une minuterie ?

window.clearInterval();
window.clearTimeout();

基本步骤：var xhr =null;//创建对象 
if(window.XMLHttpRequest){
       xhr = new XMLHttpRequest();}else{
       xhr = new ActiveXObject("Microsoft.XMLHTTP");}xhr.open(“方式”,”地址”,”标志位”);//初始化请求 
   xhr.setRequestHeader(“”,””);//设置http头信息 
xhr.onreadystatechange =function(){}//指定回调函数 
xhr.send();//发送请求

13. Fonction auto-exécutable ? Avantages ?

Fonction : Créer une portée indépendante.

Avantages : Empêchez les variables de se propager dans le monde global pour éviter les conflits avec diverses bibliothèques js. Isolez la portée pour éviter toute contamination ou tronquez la chaîne de portée pour éviter les fermetures qui empêchent la libération des variables de référence. Utilisez la fonctionnalité d'exécution immédiate pour renvoyer les fonctions ou objets métier requis et éviter le traitement par jugement conditionnel à chaque fois

Scénario : généralement utilisé dans les frameworks, les plug-ins et d'autres scénarios

14 .html et Quelle est la différence entre xhtml ?

1.Les éléments XHTML doivent être correctement imbriqués.
2.Les éléments XHTML doivent être fermés.
3. Les noms des tags doivent être en lettres minuscules.
4. Les balises vides doivent également être fermées.
5.Les documents XHTML doivent avoir un élément racine.

15. Qu'est-ce qu'un constructeur ? Quelle est la différence avec les fonctions ordinaires ?

构造函数：是一种特殊的方法、主要用来创建对象时初始化对象，总与new运算符一起使用，创建对象的语句中构造函数的函数名必须与类名完全相同。
与普通函数相比只能由new关键字调用，构造函数是类的标示

16. 通过new创建一个对象的时候，函数内部有哪些改变

function Person(){}Person.prototype.friend = [];Person.prototype.name = '';// var a = new Person();// a.friend[0] = '王琦';// a.name = '程娇';// var b = new Person();// b.friend？// b.name?

1、创建一个空对象，并且 this 变量引用该对象，同时还继承了该函数的原型。
2、属性和方法被加入到 this 引用的对象中。
3、新创建的对象由 this 所引用，并且最后隐式的返回 this 。

17.事件委托？有什么好处?

（1）利用冒泡的原理，把事件加到父级上，触发执行效果
（2）好处：新添加的元素还会有之前的事件；提高性能。

18.window.onload ==? DOMContentLoaded ?

一般情况下，DOMContentLoaded事件要在window.onload之前执行，当DOM树构建完成的时候就会执行DOMContentLoaded事件，而window.onload是在页面载入完成的时候，才执行，这其中包括图片等元素。大多数时候我们只是想在DOM树构建完成后，绑定事件到元素，我们并不需要图片元素，加上有时候加载外域图片的速度非常缓慢。

19.节点类型?判断当前节点类型?

1. 元素节点                        
2. 属性节点                        
3. 文本节点                        
8. 注释节点                        
9. 文档节点                        
通过nodeObject.nodeType判断节点类型：其中，nodeObject 为DOM节点（节点对象）。该属性返回以数字表示的节点类型，例如，元素节点返回 1，属性节点返回 2 。

20.如何合并两个数组？数组删除一个元素?

//三种方法。 （1）var arr1=[1,2,3];
               var arr2=[4,5,6];
               arr1 = arr1.concat(arr2);
               console.log(arr1); 
 （2）var arr1=[1,2,3];
               var arr2=[4,5,6];
               Array.prototype.push.apply(arr1,arr2);
               console.log(arr1);
 （3）var arr1=[1,2,3];
               var arr2=[4,5,6];
               for (var i=0; i < arr2.length; i++) {
                   arr1.push( arr2[i] );
               }
               console.log(arr1);

21.强制转换 显式转换 隐式转换?

//强制类型转换：
Boolean(0)                // => false - 零
           Boolean(new object())   // => true - 对象
               Number(undefined)       // =>   NaN
               Number(null)              // => 0
               String(null)              // => "null"
parseInt( )
parseFloat( )
JSON.parse( )
JSON.stringify ( )

隐式类型转换：
在使用算术运算符时，运算符两边的数据类型可以是任意的，比如，一个字符串可以和数字相加。之所以不同的数据类型之间可以做运算，是因为JavaScript引擎在运算之前会悄悄的把他们进行了隐式类型转换的
（例如：x+""         //等价于String(x)
              +x                 //等价于Number(x)
              x-0         //同上
              !!x         //等价于Boolean(x),是双叹号）

显式转换：
如果程序要求一定要将某一类型的数据转换为另一种类型，则可以利用强制类型转换运算符进行转换，这种强制转换过程称为显示转换。
显示转换是你定义让这个值类型转换成你要用的值类型，是底到高的转换。例 int 到float就可以直接转，int i=5,想把他转换成char类型，就用显式转换（char）i

22. Jq中如何实现多库并存?

Noconfict 多库共存就是“$ ”符号的冲突。

方法一： 利用jQuery的实用函数$.noConflict();这个函数归还$的名称控制权给另一个库，因此可以在页面上使用其他库。这时，我们可以用"jQuery "这个名称调用jQuery的功能。 $.noConflict();  
jQuery('#id').hide();    
.....
//或者给jQuery一个别名  
var $j=jQuery  
$j('#id').hide();    
.....

方法二： (function($){})(jQuery)

方法三： jQuery(function($){})
通过传递一个函数作为jQuery的参数，因此把这个函数声明为就绪函数。 我们声明$为就绪函数的参数，因为jQuery总是吧jQuery对象的引用作为第一个参数传递，所以就保证了函数的执行。

23.Jq中get和eq有什么区别？

get() :取得其中一个匹配的元素。num表示取得第几个匹配的元素，get多针对集合元素，返回的是DOM对象组成的数组 eq():获取第N个元素，下标都是从0开始，返回的是一个JQuery对象

24.如何通过原生js 判断一个元素当前是显示还是隐藏状态?

if( document.getElementById("div").css("display")==='none')
if( document.getElementById("div").css("display")==='block')
$("#div").is(":hidden"); // 判断是否隐藏
$("#div").is(":visible")

25.Jq如何判断元素显示隐藏？

//第一种：使用CSS属性 
var display =$('#id').css('display'); 
if(display == 'none'){    alert("我是隐藏的！"); }
//第二种：使用jquery内置选择器 
<div id="test"> <p>仅仅是测试所用</p> </div>
if($("#test").is(":hidden")){        
	$("#test").show();    
	//如果元素为隐藏,则将它显现 
}else{       
	$("#test").hide();     
	//如果元素为显现,则将其隐藏 
}
//第三种：jQuery判断元素是否显示 是否隐藏
var node=$('#id');
if(node.is(':hidden')){　　//如果node是隐藏的则显示node元素，否则隐藏
　　node.show();　
}else{
　　node.hide();
}

26.移动端上什么是点击穿透?

点击穿透现象有3种：
点击穿透问题：点击蒙层（mask）上的关闭按钮，蒙层消失后发现触发了按钮下面元素的click事件跨页面点击穿透问题：如果按钮下面恰好是一个有href属性的a标签，那么页面就会发生跳转另一种跨页面点击穿透问题：这次没有mask了，直接点击页内按钮跳转至新页，然后发现新页面中对应位置元素的click事件被触发了

解决方案：
1、只用touch
最简单的解决方案，完美解决点击穿透问题
把页面内所有click全部换成touch事件（ touchstart 、’touchend’、’tap’）

2、只用click
下下策，因为会带来300ms延迟，页面内任何一个自定义交互都将增加300毫秒延迟

3、tap后延迟350ms再隐藏mask
改动最小，缺点是隐藏mask变慢了，350ms还是能感觉到慢的

4、pointer-events
比较麻烦且有缺陷， 不建议使用mask隐藏后，给按钮下面元素添上 pointer-events: none; 样式，让click穿过去，350ms后去掉这个样式，恢复响应缺陷是mask消失后的的350ms内，用户可以看到按钮下面的元素点着没反应，如果用户手速很快的话一定会发现

27.Jq绑定事件的几种方式？on bind ?

jQuery中提供了四种事件监听方式，分别是bind、live、delegate、on，对应的解除监听的函数分别是unbind、die、undelegate、off

Bind( )是使用频率较高的一种，作用就是在选择到的元素上绑定特定事件类型的监听函数;

Live( )可以对后生成的元素也可以绑定相应的事件,处理机制就是把事件绑定在DOM树的根节点上，而不是直接绑定在某个元素上;

Delegate( )采用了事件委托的概念，不是直接为子元素绑定事件，而是为其父元素（或祖先元素也可）绑定事件，当在p内任意元素上点击时，事件会一层层从event target向上冒泡，直至到达你为其绑定事件的元素；

on( )方法可以绑定动态添加到页面元素的事件，on()方法绑定事件可以提升效率；

28.Jq中如何将一个jq对象转化为dom对象？

方法一：
jQuery对象是一个数据对象，可以通过[index]的方法，来得到相应的DOM对象。
如：var $v =$("#v") ; //jQuery对象
var v=$v[0]; //DOM对象
alert(v.checked) //检测这个checkbox是否被选中

方法二：
jQuery本身提供，通过.get(index)方法，得到相应的DOM对象
如：var $v=$("#v"); //jQuery对象
var v=$v.get(0); //DOM对象
alert(v.checked) //检测这个checkbox是否被选中

29.Jq中有几种选择器?分别是什么?

层叠选择器、基本过滤选择器、内容过滤选择器、可视化过滤选择器、属性过滤选择器、子元素过滤选择器、表单元素选择器、表单元素过滤选择器

30.Jq中怎么样编写插件?

//第一种是类级别的插件开发：//1.1 添加一个新的全局函数 添加一个全局函数，我们只需如下定义： 
jQuery.foo = function() {
     alert('This is a test. This is only a test.');  };   //1.2 增加多个全局函数 添加多个全局函数，可采用如下定义： 
jQuery.foo = function() {
       alert('This is a test. This is only a test.');  };  jQuery.bar = function(param) {
      alert('This function takes a parameter, which is "' + param + '".');  };   调用时和一个函数的一样的:jQuery.foo();jQuery.bar();或者$.foo();$.bar('bar');//1.3 使用jQuery.extend(object);　 
jQuery.extend({
      foo: function() {
          alert('This is a test. This is only a test.');
        },
      bar: function(param) {
          alert('This function takes a parameter, which is "' + param +'".');
        }
     }); //1.4 使用命名空间// 虽然在jQuery命名空间中，我们禁止使用了大量的javaScript函数名和变量名。// 但是仍然不可避免某些函数或变量名将于其他jQuery插件冲突，因此我们习惯将一些方法// 封装到另一个自定义的命名空间。jQuery.myPlugin = {         foo:function() {         
  alert('This is a test. This is only a test.');         
 },         
 bar:function(param) {         
  alert('This function takes a parameter, which is "' + param + '".');   
 }        }; //采用命名空间的函数仍然是全局函数，调用时采用的方法： 
$.myPlugin.foo();        $.myPlugin.bar('baz');//通过这个技巧（使用独立的插件名），我们可以避免命名空间内函数的冲突。//第二种是对象级别的插件开发//形式1： 
(function($){    
  $.fn.extend({    
   pluginName:function(opt,callback){    
             // Our plugin implementation code goes here.      
   }    
  })    })(jQuery);  //形式2：(function($) {      
   $.fn.pluginName = function() {    
        // Our plugin implementation code goes here.    
   };     })(jQuery);//形参是$，函数定义完成之后,把jQuery这个实参传递进去.立即调用执行。//这样的好处是,我们在写jQuery插件时,也可以使用$这个别名,而不会与prototype引起冲突

31.$('p+.ab')和$('.ab+p') 哪个效率高？

$('p+.ab')效率高

32.$.map和$.each有什么区别

map()方法主要用来遍历操作数组和对象，会返回一个新的数组。$.map()方法适用于将数组或对象每个项目新阵列映射到一个新数组的函数；
each()主要用于遍历jquery对象，返回的是原来的数组，并不会新创建一个数组。

33.编写一个 getElementsByClassName 封装函数?

<body>   <input type="submit" id = "sub" class="ss confirm btn" value="提交"/>   <script> window.onload = function(){ //方法一         
    var Opt = document.getElementById('sub');
    var getClass = function(className,tagName){
        if(document.getElementsByTagName){
            var Inp = document.getElementsByTagName(tagName);
            for(var i=0; i<Inp.length; i++){
                if((new RegExp(&#39;(\\s|^)&#39; +className +&#39;(\\s|$)&#39;)).test(Inp[i].className)){
                      return Inp[i];
                    }
                }
            }else if(document.getElementsByClassName){
                return document.getElementsByClassName(className);
        }
    }                 //方法二    var aa = getClass("confirm", "input");
        function getClass(className, targetName){
            var ele = [];
            var all = document.getElementsByTagName(targetName || "*");
            for(var i=0; i<all.length; i++){
                if(all[i].className.match(new RegExp(&#39;(\\s|^)&#39;+confirm+&#39;(\\s|$)&#39;))){    
                    ele[ele.length] = all[i];
                }
            }
            return ele;
        }//方法三    function getObjsByClass(tagName, className){
           if(document.getElementsByClassName){
               alert("document.getElementsByClassName");
               return document.getElementsByClassName(className);
           }else{
               var el = [];
               var _el = document.getElementsByTagName(tagName);
               for(var i=0; i<_el.length; i++){
                   if(_el[i].className.indexOf(className) > -1){
                       alert(_el[i]);
                       el[_el.length] = _el[i];
                   }
               }
               alert(el);
               return el;
           }
       }
   }
 </script></body>

34.简述下工作流程

Mon processus de travail dans mon ancienne entreprise était à peu près le suivant : après la réunion de finalisation de l'entreprise, une simple discussion technique avait lieu, puis notre front-end effectuait des préparatifs techniques avancés. Le cutter frontal coupera le brouillon de conception psd et intégrera les fichiers CSS. Nous écrivons principalement la partie JS, qui comprend la construction du framework front-end (grand projet), l'écriture des opérations commerciales et de persistance des données js, nous écrirons également des plug-ins js et les encapsulerons pour une utilisation facile, et écrirons des composants front-end JS. et les unités de test JS. Enfin Intégrez la partie JS complétée à la page HTML fournie par le cutter. Enfin, effectuez des tests fonctionnels, la compatibilité des pages et la restauration du produit sur la page terminée. Le produit est ensuite scellé et soumis à des tests. Si un BUG survient, il sera renvoyé à nos développeurs pour modification, puis soumis pour test. Enfin, si le test est réussi, la version sera archivée. Attendez que tous les programmes soient en ligne pour effectuer des tests en ligne.

35. Quels outils de contrôle de version sont généralement utilisés ? Comment svn verrouille-t-il les fichiers

Objectif du verrouillage svn : empêcher plusieurs personnes de modifier le même fichier ? en même temps Pour se couvrir, le système de contrôle de version doit disposer d'un mécanisme de gestion des conflits.

Deux stratégies pour le verrouillage svn : Verrouillage optimiste : tous les fichiers extraits sont lisibles et accessibles en écriture. Les modifications apportées aux fichiers n'ont pas besoin d'obtenir des verrous de fichier. Lorsque vous vous enregistrez après avoir modifié le fichier, vous l'êtes d'abord. requis pour mettre à jour les fichiers locaux. Le système de contrôle de version n’écrasera pas vos modifications locales, mais vous permettra de fusionner les conflits et de les enregistrer.

Verrouillage strict : tous les fichiers extraits sont en lecture seule. Toute modification du fichier doit obtenir le verrou du fichier. Si d'autres n'ont pas le verrou sur le fichier, le système de contrôle de version l'autorisera. vous verrouillez le fichier et rend le fichier modifiable.

Deux étapes de verrouillage pour svn : Verrouillage optimiste : sélectionnez le fichier que vous souhaitez verrouiller, puis cliquez avec le bouton droit sur le menu et cliquez sur TortoiseSVN pour sélectionner Obtenir le verrouillage.

Verrouillage strict : cliquez avec le bouton droit sur le fichier ou le répertoire que vous souhaitez verrouiller strictement, utilisez le menu des propriétés de TortoiseSVN, cliquez sur Nouvelle propriété et sélectionnez le verrou requis.

36. Quelle est la différence entre git et svn ?

SVN est un système de contrôle de version centralisé. Ils utilisent tous leur propre ordinateur, ils doivent donc d'abord obtenir la dernière version du serveur central, puis effectuer le travail, une fois le travail terminé, ils doivent transférer le travail qu'ils ont effectué vers le serveur central. Le système de contrôle de version centralisé doit être connecté à Internet pour fonctionner. S'il est sur un réseau local, ce n'est pas grave, la bande passante est suffisamment grande et la vitesse est suffisamment rapide. S'il est sur Internet, si le réseau. la vitesse est lente, ce sera déroutant.

Git est un système de contrôle de versions distribué, il n'a donc pas de serveur central. L'ordinateur de tout le monde est une bibliothèque de versions complète. De cette façon, vous n'avez pas besoin d'être connecté à Internet lorsque vous travaillez, car les versions. sont tous seuls sur l'ordinateur. Puisque l’ordinateur de chacun dispose d’une bibliothèque de versions complète, comment plusieurs personnes peuvent-elles collaborer ? Par exemple, si vous avez modifié le fichier A sur votre ordinateur et que quelqu'un d'autre a également modifié le fichier A sur votre ordinateur, il vous suffit de transmettre vos modifications les unes aux autres et vous pouvez voir les modifications de chacun.

37. Quelle est la différence entre jquery et zepto ?

1. Pour les programmes mobiles, Zepto propose des événements tactiles de base qui peuvent être utilisés pour l'interaction sur l'écran tactile ( tap events, swipe incident), Zepto ne prend pas en charge le navigateur IE. Ce n'est pas parce que le développeur de Zepto, Thomas Fucks, était confus sur le problème entre les navigateurs, mais une décision prise après un examen attentif afin de réduire la taille du fichier. ne prend plus en charge les anciennes versions d'IE (6 7 8) dans la version 2.0. Étant donné que Zepto utilise la syntaxe jQuery, il recommande jQuery comme bibliothèque de secours sur IE dans sa documentation. De cette façon, le programme peut toujours fonctionner dans IE et les autres navigateurs peuvent profiter de l'avantage de Zepto en matière de taille de fichier. Cependant, les API des deux ne sont pas entièrement compatibles, alors soyez prudent et effectuez des recherches suffisantes lorsque vous utilisez cette méthode de test.

2. La différence entre les opérations Dom : jQuery ne prendra pas effet lors de l'ajout d'un identifiant, mais Zepto le fera.

3.zepto est principalement utilisé sur les appareils mobiles et ne prend en charge que les navigateurs les plus récents. L'avantage est que la taille du code est plus petite et les performances sont meilleures.
Jquery a principalement une bonne compatibilité et peut fonctionner sur différents PC et téléphones mobiles. L'avantage est qu'il est compatible avec différents navigateurs. L'inconvénient est que la quantité de code est importante et que les performances ne sont pas assez bonnes compte tenu de la compatibilité.

38. $(function(){}) et window.onload et $(document).ready(function(){})

window.onload : utilisé pour exécuter la fonction dans la fonction lorsque tous les éléments de la page, y compris les fichiers de référence externes, les images, etc., sont chargés. La méthode de chargement ne peut être exécutée qu'une seule fois. Si plusieurs sont écrites dans le fichier js, seule la dernière peut être exécutée.

$(document).ready(function(){}) et $(function(){}) sont tous deux utilisés pour exécuter des fonctions internes après que les éléments DOM standard de la page soient analysés dans une arborescence DOM. Cette fonction peut être écrite plusieurs fois dans le fichier js. Elle présente un grand avantage pour les js écrits par plusieurs personnes, car toutes les fonctions comportementales seront exécutées. De plus, la fonction $(document).ready() peut être exécutée après le chargement de la structure HMTL. Elle n'a pas besoin d'attendre la fin d'un travail fastidieux tel que le chargement de fichiers volumineux ou des connexions inexistantes avant l'exécution. est très efficace.

39. Quelle est la différence entre attr et prop dans Jq

Pour les attributs inhérents à l'élément HTML lui-même, utilisez la méthode prop lors du traitement.
Pour nos propres attributs DOM personnalisés des éléments HTML, utilisez la méthode attr lors de leur traitement.

40. Décrivez brièvement la différence entre cela et lors de la définition des propriétés et des méthodes ?

this représente l'objet actuel. Si this est utilisé dans la portée globale, il fait référence à la fenêtre de l'objet de page actuelle. Si this est utilisé dans une fonction, ce à quoi cela fait référence est basé sur le runtime ; de cette fonction. Quel objet est appelé. Nous pouvons également utiliser les deux méthodes globales apply et call pour changer le pointeur spécifique de this dans la fonction.

Le prototype est essentiellement un objet JavaScript. Et chaque fonction possède un attribut de prototype par défaut.

Les méthodes d'attribut définies sur le prototype sont partagées par toutes les instances. Toutes les instances font référence au même objet. La modification des attributs sur le prototype par une seule instance affectera également toutes les autres instances.

41. Qu'est-ce que la parole précompilée | Processeur précompilé

Sass est un langage de préprocesseur CSS qui génère du code CSS par programme. Parce qu'il est programmable, il offre une flexibilité et une liberté de contrôle élevées, ce qui facilite la mise en œuvre de certains codes difficiles à écrire directement du code CSS.

En même temps, Sass étant un langage qui génère du CSS, le fichier Sass écrit ne peut pas être utilisé directement. Il doit être compilé en fichier CSS par un compilateur avant de pouvoir être utilisé.

Le préprocesseur CSS est un langage utilisé pour ajouter certaines fonctionnalités de programmation au CSS sans tenir compte des problèmes de compatibilité du navigateur. Par exemple, vous pouvez utiliser des variables, une logique de programme simple, des fonctions, etc. en CSS Quelques compétences de base dans les langages de programmation ​​peut rendre votre CSS plus concis, plus adaptable et le code plus intuitif, parmi de nombreux autres avantages. Les préprocesseurs CSS les plus couramment utilisés sont sass, less css et stylus.

42.ajax et jsonp ?

La différence entre ajax et jsonp :
Point similaire : les deux demandent une url
Différence : le cœur d'ajax est d'obtenir du contenu via xmlHttpRequest
Le cœur de jsonp est dynamique ajout de la balise