Trier les points de connaissance des entretiens dans js

Écrivez le contenu du lien ici1. Quels types de données le typeof de JavaScript renvoie-t-il ? Tout d'abord, les types de données JavaScript sont divisés en deux catégories : les types primitifs et les types de référence. J'espère que cela pourra aider tout le monde.

Types primitifs : nul, non défini, nombre, chaîne, booléen
Types de référence : objet, symbole (ES6)
(Quant à la différence entre les types primitifs et les types références, vous pouvez voir l'un des mes articles de blog : syntaxe de base Js, variables, types de données)
Ensuite, l'opérateur typeof peut déterminer tous les types primitifs. typeof renvoie sept valeurs possibles : "numéro", "chaîne", "booléen", "objet", "symbole", "fonction" et "indéfini".

2. Veuillez écrire les résultats de l'opération suivants

alert(typeof null); //object 
alert(typeof undefined);//undefined 
alert(typeof NaN);//number 
alert(NaN == undefined);//false 
alert(NaN == NaN);//false 
var str = “123abc”; 
alert(typeof str++); 
alert(str);//string

3 Pourquoi y a-t-il une instance d'opérateur ?

typeof est une opération unaire, placée avant un opérande, et l'opérande peut être de n'importe quel type. Un problème survient lors de l'utilisation d'un type référence pour stocker une valeur lors de l'utilisation de l'opérateur typeof, qui renvoie « objet » quel que soit le type d'objet référencé. Pour les objets spéciaux tels que Array et Null, l'utilisation de typeof renverra toujours un objet. C'est la limitation de typeof.

instanceof est utilisé pour déterminer si une variable est une instance d'un objet ,

tel que :
var a=nouveau tableau();
alert(une instance de Array); renverra true,
En même temps,
alert(a instanceof Object) retournera également true ;

Un autre exemple :
fonction test(){};
var a=nouveau test();
alert(a instanceof test); return true

De plus, le point le plus important est que instanceof peut être utilisé dans les relations d'héritage pour déterminer si une instance appartient à son type parent. Par exemple :

function Aoo(){} 
function Foo(){} 
Foo.prototype = new Aoo();//JavaScript 原型继承var foo = new Foo(); 
console.log(foo instanceof Foo)//true console.log(foo instanceof Aoo)//true

Le code ci-dessus détermine la classe parent dans une relation d'héritage à un niveau. Dans une relation d'héritage à plusieurs niveaux, l'opérateur instanceof est également applicable.

console.log(Object instanceof Object);//true console.log(Function instanceof Function);//true console.log(Number instanceof Number);//false console.log(String instanceof String);//false console.log(Function instanceof Object);//true console.log(Foo instanceof Function);//true console.log(Foo instanceof Foo);//false

Êtes-vous à nouveau confus après avoir lu le code ci-dessus ? Pourquoi les instances d'objet et de fonction d'elles-mêmes sont-elles égales à vrai, mais les instances d'elles-mêmes d'autres classes ne sont pas égales à vrai ? Comment expliquer ? Pour comprendre fondamentalement le mystère d'instanceof, vous devez partir de deux aspects :
1. Comment cet opérateur est défini dans la spécification du langage.
2. Mécanisme d'héritage prototype JavaScript.
Code de l'opérateur instanceof JavaScript :

function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
 var O = R.prototype;// 取 R 的显示原型
 L = L.__proto__;// 取 L 的隐式原型
 while (true) { 
   if (L === null) 
     return false; 
   if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
     return true; 
   L = L.__proto__; 
 } 
}

Quant à l'utilisation complexe de instanceof, vous pouvez vous référer au lien suivant :
Analyse approfondie de l'instance JavaScript de l'opérateur

3. Exemple Donnez au moins 3 types de conversions de type forcées et 2 types de conversions de type implicites ?

Vous pouvez vous référer à votre propre article de blog : Conversion de type de données JS

1. Conversion de type forcée : appelez explicitement des fonctions intégrées pour forcer la conversion d'une valeur d'un type en un autre. Les conversions de type forcées incluent principalement : Boolean, Number, String, parseInt, parseFloat

2. Conversion de type implicite : lors de l'utilisation d'opérateurs arithmétiques, les types de données des deux côtés de l'opérateur peuvent être arbitraires. Par exemple, une chaîne peut être ajoutée à un nombre. La raison pour laquelle des opérations peuvent être effectuées entre différents types de données est que le moteur JavaScript effectuera silencieusement des conversions de type implicites avant d'effectuer des opérations. Les conversions de types implicites incluent principalement : +, –, ==, !

5. Quels sont les modèles de flux d'événements de JavaScript ?

Le flux d'événements décrit l'ordre dans lequel les événements sont reçus de la page. La structure DOM est une structure arborescente. Lorsqu'un élément de la page déclenche un événement, l'événement démarre à partir de l'objet fenêtre de niveau supérieur et se propage vers le bas jusqu'à l'élément cible. le courant Si l'événement du nœud est lié à une fonction de gestion d'événement, la fonction sera exécutée Lorsque l'événement atteint l'élément cible et que la fonction de liaison est exécutée (s'il existe une liaison), l'événement sera propagé vers le haut. l'élément window et les nœuds ancêtres du chemin déclencheront l'événement correspondant

Le flux d'événements contient trois étapes :

Étape de capture d'événement
Dans l'étape cible

<br/>

Étape de bouillonnement d'événement

Étape de capture d'événement : l'événement commence à être déclenché par l'objet de niveau supérieur, puis se propage vers le bas par étape jusqu'à l'élément cible ;
Dans l'étape cible : sur l'élément lié à l'événement
Étape de bouillonnement d'événement : l'événement est d'abord reçu par l'élément spécifique, puis propagé vers le haut pas à pas jusqu'à l'élément non spécifique ; element;

6.Que sont les objets de la nomenclature ? Lister les objets de la fenêtre ?

1. L'objet window est l'objet de niveau supérieur de JS. Les autres objets BOM sont des attributs de l'objet window

2.

3. Objet d'emplacement, informations sur l'URL actuelle du navigateur ;

4. Objet Navigateur, informations du navigateur lui-même

5. . Objet historique, informations sur l'historique d'accès au navigateur ;

7. Veuillez décrire brièvement AJAX et ses étapes de base ?

Référez-vous à mon article de blog : Ajax

Réponse de référence :

Brève description d'AJAX : AJAX signifie "Asynchronous Javascript And XML" (Asynchronous JavaScript and XML), qui fait référence à une technologie de développement Web permettant de créer des applications Web interactives. AJAX permet aux pages Web de se mettre à jour de manière asynchrone en échangeant de petites quantités de données avec le serveur en arrière-plan. Cela signifie que certaines parties d'une page Web peuvent être mises à jour sans recharger la page entière.

Étapes de base d'AJAX :

Initialiser l'objet ajax
Connecter l'adresse, préparer les données
Envoyer la demande
Recevoir des données (réception, pas encore terminée)
Recevoir des données terminé
//Initialiser l'objet ajax
var xhr = new XMLHttpRequest();
//Connecter l'adresse et préparer les données
xhr.open("method", "address", que ce soit est asynchrone);
//Événements déclenchés lorsque la réception des données est terminée
xhr.onload =function(){}
//Envoi de données
xhr.send();

8. HTTP Que signifient les messages d'état 200 302 304 403 404 500 ?

200 : la requête a réussi et l'en-tête de réponse ou le corps de données attendu par la requête sera renvoyé avec cette réponse.
302 : La ressource demandée a temporairement répondu à la demande à partir d’un autre URI. Ces redirections étant temporaires, le client doit continuer à envoyer de futures demandes à l'adresse d'origine. Cette réponse peut être mise en cache uniquement si elle est spécifiée dans Cache-Control ou Expires.
304 : Si le client envoie une requête GET conditionnelle et que la requête est autorisée, mais que le contenu du document n'a pas changé (depuis le dernier accès ou selon les conditions de la requête), le serveur doit renvoyer ce code d'état . Une réponse 304 NE DOIT PAS contenir de corps de message et se termine donc toujours par la première ligne vide après l'en-tête du message.
403 : Le serveur a compris la requête mais a refusé de l'exécuter.
404 : La requête a échoué. La ressource demandée n'a pas été trouvée sur le serveur.
500 : Le serveur a rencontré une condition inattendue qui l'a empêché de terminer le traitement de la demande. D'une manière générale, ce problème se produit lorsqu'il y a une erreur dans le code source côté serveur.

9. Quelle est la différence entre synchrone et asynchrone ?

Tout d'abord, synchrone et asynchrone n'ont rien à voir avec le blocage et le non-blocage. La synchronisation et l'asynchrone se concentrent principalement sur la façon de traiter les choses une fois qu'elles sont terminées, ou se concentrent sur un mécanisme de communication de messages.

La synchronisation et l'asynchronisme peuvent être considérés comme étant pour la partie requise, la méthode utilisée par la partie requise pour informer les résultats du traitement.

En cas de synchronisation, le gestionnaire de messages attend que le message soit déclenché;
En cas d'asynchrone, le mécanisme de déclenchement informe le gestionnaire de messages

Blocage non bloquant ; Le blocage concerne principalement le demandeur.
Blocage : faites une demande et attendez que le résultat soit renvoyé, puis traitez les choses suivantes.
Non bloquant : faites une demande sans attendre que le résultat soit renvoyé, et vous pouvez continuer à faire les choses suivantes ; ;

10. GET Quelle est la différence entre POST et quand utiliser POST ?

GET : généralement utilisé pour interroger des données, en utilisant une URL pour transmettre des paramètres. Étant donné que le navigateur a des restrictions sur la longueur de la barre d'adresse, il existe une limite sur la quantité d'informations envoyées à l'aide de la méthode get. , et le navigateur l'enregistrera. Les informations sur l'adresse demandée, y compris les données derrière l'adresse, seront conservées dans (historique, cache). get ne peut envoyer des données qu'au format brut (format codé en URL).

POST : Généralement utilisé pour envoyer des données au serveur. Il n'y a théoriquement aucune limite sur la taille des données envoyées. Le navigateur mettra en cache et enregistrera l'adresse, mais n'enregistrera pas les données soumises par courrier. post peut envoyer des chaînes en texte brut, au format codé URL et au format binaire sous diverses formes.

Veuillez utiliser la requête POST dans les situations suivantes :

Demande de soumission (sémantique similaire, demande d'obtention de moyens, soumission de moyens de publication
Envoyer des données privées (nom d'utilisateur, mot de passe) (en raison) ; aux caractéristiques d'enregistrement du cache du navigateur) ;
Envoi d'une grande quantité de données au serveur (différence dans la limite de taille des données) ;
Lors du téléchargement d'images de fichiers (différence dans le type de données) ; 11. Limites d'AJAX ?

1. AJAX ne prend pas en charge le bouton Précédent du navigateur. 2. Problèmes de sécurité AJAX expose les détails de l'interaction avec le serveur.

3. Le support des moteurs de recherche est relativement faible. Il n'exécutera pas votre script JS, mais exploitera uniquement le code source de votre page Web

4. Il existe certaines restrictions sur les requêtes inter-domaines ; Solution : jsonp ;


12. Que fait exactement le nouvel opérateur

1. Créer un nouvel objet 2. (scope) object this pointe vers l'objet ;

3. Exécutez le code et ajoutez des attributs ou des méthodes au nouvel objet via ceci

4. Renvoyez l'objet ; null Quelle est la différence entre indéfini et indéfini ?


null : null signifie une valeur nulle, qui est 0 lorsqu'elle est convertie en valeur numérique

indéfini : indéfini signifie "valeur manquante", c'est-à-dire qu'il devrait y avoir une valeur ; ici, mais il n'a pas encore été défini. Lorsqu'une variable est déclarée mais qu'aucune valeur ne lui est attribuée, elle est égale à indéfinie.

L'objet n'a aucun attribut attribué et la valeur de cet attribut n'est pas définie.

Lorsque la fonction ne renvoie pas de valeur, elle renvoie undéfini par défaut.

Voir mon article de blog pour plus de détails : JS détermine la différence entre le type de données, nul et indéfini ?

14. Prototype JavaScript, chaîne de prototypes ? Quelles sont ses caractéristiques ? Chaîne de portée ?

作用域链的理解：
   当执行一段JavaScript代码（全局代码或函数）时，JavaScript引擎会创建为其创建一个作用域又称为执行上下文（Execution Context），在页面加载后会首先创建一个全局的作用域，然后每执行一个函数，会建立一个对应的作用域，从而形成了一条作用域链。每个作用域都有一条对应的作用域链，链头是全局作用域，链尾是当前函数作用域。
    作用域链的作用是用于解析标识符，当函数被创建时（不是执行），会将this、arguments、命名参数和该函数中的所有局部变量添加到该当前作用域中，当JavaScript需要查找变量X的时候（这个过程称为变量解析），它首先会从作用域链中的链尾也就是当前作用域进行查找是否有X属性，如果没有找到就顺着作用域链继续查找，直到查找到链头，也就是全局作用域链，仍未找到该变量的话，就认为这段代码的作用域链上不存在x变量，并抛出一个引用错误（ReferenceError）的异常。

JavaScript 原型： 每创建一个函数，函数上都有一个属性为 prototype，它的值是一个对象。 这个对象的作用在于当使用函数创建实例的时候，那么这些实例都会共享原型上的属性和方法。

原型链： 在 JavaScript 中，每个对象都有一个指向它的原型（prototype）对象的内部链接（proto）。这个原型对象又有自己的原型，直到某个对象的原型为 null 为止（也就是不再有原型指向）。这种一级一级的链结构就称为原型链（prototype chain）。 当查找一个对象的属性时，JavaScript 会向上遍历原型链，直到找到给定名称的属性为止;到查找到达原型链的顶部（Object.prototype），仍然没有找到指定的属性，就会返回 undefined。

十五、JavaScript代理
当我们需要对很多元素添加事件的时候，可以通过将事件添加到它们的父节点而将事件委托给父节点来触发处理函数。

比如我们需要向一个ul中动态添加很多个li，需要遍历li逐个添加点击事件

<ul id=&#39;list&#39;></ul> var count = 100; var ulList = document.getElementById("list"); //动态构建节点
 for(var i = count;i--;){  var liDom = document.createElement(&#39;li&#39;);
  ulList.appendChild(liDom);
 } //绑定点击事件
 var liNode = ulList.getElementByTagName("li"); for(var i=0, l = liNodes.length; i < l; i++){
  liNode[i].onClick = function(){
   //li点击事件
  }
 }

众所周知，DOM操作是十分消耗性能的。所以重复的事件绑定简直是性能杀手。而事件代理的核心思想，就是通过尽量少的绑定，去监听尽量多的事件。如何做呢？答案是利用事件冒泡机制,对其父节点ul进行事件绑定（Event Bubble),然后通过event.target来判断是哪个节点触发的事件，从而减少很多EventHandler的绑定。

“` 
var count = 100; 
var ulList = document.getElementById(“list”); 
//动态构建节点 
for(var i = count;i–;){ 

 var liDom = document.createElement(‘li’); 

 ulList.appendChild(liDom); 
} 
//绑定点击事件 
var liNode = ulList.getElementByTagName(“li”); 
liNode.onClick = function(e){ 

 if(e.target && e.target.nodeName.toUpperCase == “LI”) { 

  // li点击事件 

 } 
}

十六、如何理解闭包？
闭包

十七、call和apply的作用是什么？区别是什么？
call和apply的功能基本相同，都是实现继承或者转换对象指针的作用；
唯一不通的是前者参数是罗列出来的，后者是存到数组中的；
call或apply功能就是实现继承的；与面向对象的继承extends功能相似；但写法不同；
语法：
.call(对象[,参数1，参数2,….]);//此地参数是指的是对象的参数，非方法的参数；
.apply(对象,参数数组)//参数数组的形式:[参数1，参数2,……]

十八、JavaScript 如何实现继承？

(1)构造继承 (2)原型继承 (3)实例继承 (4)拷贝继承
 //原型prototype机制或apply和call方法去实现较简单，建议使用构造函数与原型混合方式。 function Parent()
 {  
     this.name = ‘song’; } function Child() {
     this.age = 28; } Child.prototype = new Parent(); //通过原型,继承了Parent var demo = new Child(); alert(demo.age); alert(demo.name); //得到被继承的属性

十九、JavaScript 有哪几种创建对象的方式？

Pour faire simple, créer des objets en JavaScript n'est rien de plus que d'utiliser des objets intégrés ou divers objets personnalisés. Bien sûr, vous pouvez également utiliser JSON mais il existe de nombreuses façons de les écrire, et ils le peuvent. être également mixte. //
(1) Méthode littérale d'objet
personne = {prénom : "Mark", nom : "Yun", âge : 25, couleur des yeux : "noir"}
 ; (2) Utilisez function pour simuler la fonction constructeur sans paramètre Person(){} var person = new Person(); //Définissez une fonction. Si vous utilisez une nouvelle "instanciation", la fonction peut être considérée comme une classe person.name =
. "Xiaosong"; personne.age = "23"; personne.work = function() {
alert("Bonjour" + person.name); } person.work(); (3) Utiliser la fonction pour simuler le constructeur de paramètres (utilisez ce mot-clé pour définir l'attribut de contexte de la construction) function
Personne (nom, âge, passe-temps) {
This.name = name; //cette portée : objet actuel
Cet.âge = âge
This.work = travail;
This.info = function() {
alert("mon nom" + this.name + "cette année" + this.age + "year-old" + this.work
); } } var Xiaosong = new Person("WooKong",23,"Programmer"); //Instancier et créer l'objet Xiaosong.info(); //Appelle la méthode info() (4) pour le créer en utilisant la méthode factory (Objet intégré) var jsCreater = new
Object(); jsCreater.name = « Brendan Eich » ; //Inventeur de JavaScript
jsCreater.work = « JavaScript » ; jsCreater.info = function() {
alert("Je suis l'inventeur de "+this.work+""+this.name); } jsCreater.info(); (5) Utiliser la méthode prototype pour créer la fonction Standard(){} Standard.prototype.name =
"ECMAScript" ; Standard.prototype.event = function() {
alert(this.name+"est la spécification standard du langage de script"); } var jiaoben = new Standard(); (6) Utiliser une méthode mixte pour créer la fonction iPhone(name, event) {
This.name = nom;
This.event = event; } iPhone.prototype.sell = function() {
alert("Je suis "+this.name+", je suis iPhone5s "+this.event+"~ haha!" } var SE = new iPhone("iPhone SE","Machine remise à neuf officielle"); );

20. En JavaScript, il existe une fonction qui ne recherche jamais le prototype lors d'une recherche d'objet. De quelle fonction s'agit-il ?

hasOwnProperty // hasOwnProperty en JavaScript

La méthode fonction renvoie une valeur booléenne indiquant si un objet possède une propriété portant le nom spécifié. Cette méthode ne peut pas vérifier si la propriété est dans la chaîne de prototypes de l'objet ; la propriété doit être membre de l'objet lui-même.
//
Utilisation : object.hasOwnProperty(proName) où le paramètre object est une option obligatoire, une instance d'un objet. proName est requis, une valeur de chaîne du nom de l'attribut.
// Si l'objet a une propriété avec le nom spécifié, alors la méthode de fonction hasOwnProperty en JavaScript renvoie true, sinon elle renvoie
FAUX.

21. Qu'est-ce que l'Ajax ? Comment créer un Ajax ?

Le nom complet d'ajax : Javascript asynchrone et XML, transmission asynchrone + js + xml.

Ce qu'on appelle asynchrone, une explication simple ici est la suivante : lors de l'envoi d'une requête au serveur, nous n'avons pas à attendre le résultat, mais pouvons faire autre chose en même temps. Lorsque le résultat est disponible, il effectuera la suite. opérations en fonction des paramètres Dans le même temps, la page Une actualisation complète de la page ne se produira pas, ce qui améliore l'expérience utilisateur.
(1) Créez un objet XMLHttpRequest, c'est-à-dire créez un objet appelant asynchrone
(2) Créez une nouvelle requête HTTP et spécifiez la méthode, l'URL et les informations de vérification de la requête HTTP
(3) Définissez une fonction pour répondre aux changements d'état des requêtes HTTP
(4) Récupérez les données renvoyées par l'appel asynchrone
(5) Utilisez JavaScript et DOM pour implémenter une actualisation partielle

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!