Compilation de points de connaissances JavaScript sujets aux erreurs

Avant-propos

Cet article concerne certains points de connaissances sujets aux erreurs que j'ai collectés et organisés au cours du processus d'apprentissage de JavaScript. Il couvrira la portée des variables, la comparaison de types, ce pointeur, les paramètres de fonction, les problèmes de fermeture et. copie d'objets et Les six aspects de l'affectation sont introduits et expliqués du moins profond au plus profond, ce qui implique également certains points de connaissances ES6.

Points de connaissance JavaScript

1. Portée de la variable

var a = 1;

function test() {
    var a = 2;

    console.log(a); // 2
}

test();

A est déclaré et attribué dans la portée de la fonction ci-dessus, et il se trouve au-dessus de la console, alors suivez le plus proche. La sortie principale a est égale à 2.

var a = 1;

function test2() {
    console.log(a); // undefined

    var a = 2;
}

test2();

Bien que a soit déclaré et attribué dans la portée de la fonction ci-dessus, il se trouve sous la console. La variable a est promue et est déclarée mais pas encore assignée, donc "indéfini" est affiché.

var a = 1;

function test3() {
    console.log(a); // 1

    a = 2;
}

test3();

A dans la portée de la fonction ci-dessus est réaffecté, non redéclaré, et est situé sous la console, donc a dans la portée globale est généré.

let b = 1;

function test4() {
    console.log(b); // b is not defined

    let b = 2;
}

test4();

Le let ES6 est utilisé dans la portée de la fonction ci-dessus pour redéclarer la variable b. Cependant, contrairement à var, let n'a pas la fonction de promotion de variable, donc l'erreur de sortie "b n'est pas définie". est signalé.

function test5() {
    let a = 1;

    {
        let a = 2;
    }
    
    console.log(a); // 1
}

test5();

Dans la portée de la fonction ci-dessus, let est utilisé pour déclarer a comme 1, et a est déclaré comme 2 dans la portée au niveau du bloc, car la console n'est pas dans la portée au niveau du bloc dans la fonction , donc Sortie 1.

2. Comparaison de types

var arr = [],
    arr2 = [1];

console.log(arr === arr2); // false

Comparaison de deux tableaux différents ci-dessus, la console est fausse.

var arr = [],
    arr2 = [];

console.log(arr === arr2); // false

Comparez les deux tableaux identiques ci-dessus Parce que la comparaison entre tableaux et tableaux est toujours fausse, la console est fausse.

var arr = [],
    arr2 = {};

console.log(typeof(arr) === typeof(arr2)); // true

Utilisez typeof pour comparer les tableaux et les objets ci-dessus. Parce que typeof obtient NULL, les types de tableaux et d'objets sont tous des objets, donc la console est vraie.

var arr = [];

console.log(arr instanceof Object); // true
console.log(arr instanceof Array); // true

Ce qui précède utilise instanceof pour déterminer si une variable appartient à une instance d'un objet. Étant donné que les tableaux sont également un type d'objet en JavaScript, les deux consoles sont vraies.

3.this pointe vers

var obj = {
    name: 'xiaoming',
    getName: function () {
        return this.name;
    }
};

console.log(obj.getName());  // 'xiaoming'

Ceci dans la méthode objet ci-dessus pointe vers l'objet lui-même, donc "xiaoming" est affiché.

var obj = {
    myName: 'xiaoming',
    getName: function () {
        return this.myName;
    }
};

var nameFn = obj.getName;console.log(nameFn()); // undefined

Ce qui précède attribue la méthode dans l'objet à une variable. À ce stade, celle-ci dans la méthode ne pointera plus vers l'objet obj, et pointe donc vers l'objet window, donc la console est. "indéfini".

var obj = {
    myName: 'xiaoming',
    getName: function () {
        return this.myName;
    }
};

var obj2 = {
    myName: 'xiaohua'
};
    
var nameFn = obj.getName;console.log(nameFn.apply(obj2)); // 'xiaohua'

La méthode dans l'objet obj est également affectée à la variable nameFn ci-dessus, mais celle-ci est pointée vers l'objet obj2 via la méthode apply, donc la console finale est 'xiaohua'.

4. Paramètres de la fonction

function test6() {
    console.log(arguments); // [1, 2]
}

test6(1, 2);

Ce qui précède utilise l'objet arguments dans la fonction pour obtenir le tableau de paramètres transmis à la fonction, le tableau de sortie est donc [1, 2].

function test7 () {
    return function () {
        console.log(arguments); // 未执行到此，无输出
    }
}

test7(1, 2);

Ce qui précède utilise également des arguments pour obtenir des paramètres, mais comme test7(1, 2) n'exécute pas la fonction en retour, il n'y a pas de sortie If test7(1, 2)(3, 4. ) est exécuté, il y aura une sortie [3, 4].

var args = [1, 2];

function test9() {
    console.log(arguments); // [1, 2, 3, 4]
}

Array.prototype.push.call(args, 3, 4);

test9(...args);

上方利用Array.prototype.push.call()方法向args数组中插入了3和4，并利用ES6延展操作符(…)将数组展开并传入test9，所以console为[1, 2, 3, 4]。

5.闭包问题

var elem = document.getElementsByTagName('div'); // 如果页面上有5个div

for(var i = 0; i < elem.length; i++) {
    elem[i].onclick = function () {
        alert(i); // 总是5
    };
}

上方是一个很常见闭包问题，点击任何div弹出的值总是5，因为当你触发点击事件的时候i的值早已是5，可以用下面方式解决：

var elem = document.getElementsByTagName('div'); // 如果页面上有5个div

for(var i = 0; i < elem.length; i++) {
    (function (w) {
        elem[w].onclick = function () {
            alert(w); // 依次为0,1,2,3,4
        };
    })(i);
}

在绑定点击事件外部封装一个立即执行函数，并将i传入该函数即可。

6.对象拷贝与赋值

var obj = {
    name: 'xiaoming',
    age: 23
};
    
var newObj = obj;

newObj.name = 'xiaohua';

console.log(obj.name); // 'xiaohua'
console.log(newObj.name); // 'xiaohua'

上方我们将obj对象赋值给了newObj对象，从而改变newObj的name属性，但是obj对象的name属性也被篡改，这是因为实际上newObj对象获得的只是一个内存地址，而不是真正 的拷贝，所以obj对象被篡改。

var obj2 = {
    name: 'xiaoming',
    age: 23
};
    
var newObj2 = Object.assign({}, obj2, {color: 'blue'});

newObj2.name = 'xiaohua';console.log(obj2.name); // 'xiaoming'

console.log(newObj2.name); // 'xiaohua'
console.log(newObj2.color); // 'blue'

上方利用Object.assign()方法进行对象的深拷贝可以避免源对象被篡改的可能。因为Object.assign() 方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。

var obj3 = {
    name: 'xiaoming',
    age: 23
};
    
var newObj3 = Object.create(obj3);

newObj3.name = 'xiaohua';console.log(obj3.name); // 'xiaoming'

console.log(newObj3.name); // 'xiaohua'

我们也可以使用Object.create()方法进行对象的拷贝，Object.create()方法可以创建一个具有指定原型对象和属性的新对象。

结语

学习JavaScript是一个漫长的过程，不能一蹴而就。希望本文介绍的几点内容能够帮助学习JavaScript的同学更加深入的了解和掌握JavaScript的语法，少走弯路。

以上就是JavaScript易错知识点整理的内容，更多相关内容请关注PHP中文网（www.php.cn）！