Malentendus liés à l'utilisation de JavaScript

Dans ce chapitre, nous discuterons des malentendus dans l'utilisation de JavaScript.

Remplacement de chaîne

Nous utilisons souvent la méthode de remplacement de chaîne pour remplacer certains caractères dans une chaîne. La syntaxe est la suivante

string.replace(subStr/reg,replaceStr/function)

Le premier paramètre est la chaîne à trouver ou une expression régulière, et le deuxième paramètre est Pour remplacer une chaîne ou une méthode, on peut utiliser

"Je suis Byron".replace("B","b") // Je suis byron

Les démérites sont les mêmes qu'on le pense, mais

"Je suis étudiant, et toi ?".replace("n","N"); // Je suis étudiant, et vous ?

Contrairement à ce que l'on attendait, le deuxième 'n' n'est pas remplacé. Si une chaîne est passée comme premier argument à la méthode de remplacement d'une chaîne, seule la première correspondance sera remplacée. Si vous souhaitez remplacer toutes les correspondances, vous devez transmettre un objet RegExp et spécifier sa propriété globale.

"Je suis étudiant, et toi ?".replace(/n/g,"N"); // Je suis étudiant, et toi ?

typeof

La chose la plus mal comprise à propos de typeof est typeof C'est un opérateur, pas une fonction, ce qui signifie que nous n'avons pas besoin d'ajouter des parenthèses pour juger du type d'une variable, nous pouvons simplement l'utiliser directement

typeof 1; //numbertypeof(1); , il n'est pas nécessaire de faire cela. Écrire, mais c'est vrai, cela équivaut à envelopper une variable ou une constante

La valeur de retour de typeof est une chaîne Dans la plupart des cas, le résultat renvoyé est le même. comme résultat attendu, mais il y a quelques points à noter. Nous savons que JavaScript a plusieurs types de base, nombre, chaîne, booléen, nul, non défini, puis regardons quelques exemples

<. 🎜>type de 123; // nombre

type de NaN //numéro

type de "123" //chaîne

typeof false; //boolean

typeof undefined ; //undefined

typeof null //object

typeof new Array(); //object

typeof (new Array()); //Si vous pensez que ce n'est pas assez clair, vous peut l'utiliser de cette façon, le résultat est le même

typeof (function(){}); //function

typeof a; //non défini

1.123 est un nombre Numéro de retour

2. Bien que NaN signifie que ce n'est pas un nombre, typeof renverra toujours le nombre

3. "123" devient une chaîne, donc la chaîne

4 est le type booléen.

5. Le type de non défini est indéfini. Une variable de ce type ne peut avoir qu'une seule valeur littérale "undéfini"

6 Le type de null n'est pas nul, mais objet, donc nous. n'y mettez pas d'espoir. Utilisez typeof pour nous aider à déterminer null

7. Si typeof détermine qu'il s'agit d'un objet, il ne renverra que l'objet et ne renverra pas les types spécifiques de Array et Date. .

9. La fonction est aussi un type d'objet. On dit que l'objet doit également être renvoyé directement. Mais typeof le traite différemment et renvoie une fonction. Nous pouvons l'utiliser pour déterminer si la variable est une fonction

10 Les variables non définies renvoient également undéfini

<. 🎜>if et ==

En JavaScript, if ne juge pas seulement booléen pour déterminer vrai ou faux, 0, NaN, "", undefined, null, false seront tous être considéré comme faux

if (!false) {

          console.log(1);

    } ;

if (!0) {

console.log(2);

};

if (!"") {

console.log(3);

};

if (!undefined) {

console.log(4);

};

if (!null) {

console.log(5);

};

if (!NaN) {

console.log(6); 🎜>};

123456 sera imprimé dans la consoleMais cela ne veut pas dire que ces valeurs == faux

0==false; //true

"0"==false; //true, c'est aussi vrai

undefined= = faux //faux

null==false //faux

null==null //true

NaN==NaN //faux

null==undefined //true

Erreur d'application de l'opérateur d'affectation

Dans les programmes JavaScript, si vous utilisez le signe égal (=) de l'opérateur d'affectation dans une instruction conditionnelle if, un résultat incorrect sera produit. La méthode correcte consiste à utiliser le. opérateur de comparaison Les deux signes égaux (==).

si l'instruction conditionnelle renvoie faux (ce à quoi nous nous attendions) car x n'est pas égal à 10 :

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>php中文网(php.cn)</title>
</head>
<body>
<p id="demo"></p>
<script>
var x = 0;
document.getElementById("demo").innerHTML = Boolean(x == 10);
</script>
</body>
</html>

Erreurs courantes des opérateurs de comparaison

Dans les opérations de comparaison strictes, === est l'opérateur d'identité et vérifie en même temps la valeur et le type de l'expression. L'instruction conditionnelle suivante renvoie false :

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>php中文网(php.cn)</title>
</head>
<body>
<p id="demo"></p>
<script>
var x = 10;
var y = "10";
document.getElementById("demo").innerHTML = Boolean(x === y);
</script>
</body>
</html>

Ce type d'erreur se produit souvent. dans les instructions switch. L'instruction switch utilisera l'opérateur d'identité (===) pour la comparaison

Les exemples suivants n'exécuteront pas la fenêtre contextuelle d'alerte en raison de types incohérents :

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>php中文网(php.cn)</title>
</head>
<body>
<p id="demo"></p>
<script>
var x = 10;
switch(x) {
    case "10": alert("Hello");
}
</script>
</body>
</html>

Notes d'addition sur les connexions

L'addition est l'addition de deux nombres.

La concaténation est la concaténation de deux chaînes.

JavaScript utilise l'opérateur + pour l'addition et la concaténation.

Ensuite, nous pouvons voir la différence entre l'ajout de deux nombres et la concaténation de nombres et de chaînes à travers des exemples :

var x = 10 + 5; // Le résultat de x est 15
var x = 10 + "5"; // Le résultat de x est "105"

Remarques sur l'utilisation des données à virgule flottante

Toutes les données en JavaScript sont stockées sous forme de données à virgule flottante 64 bits (float).

Tous les langages de programmation, y compris JavaScript, ont du mal à déterminer l'exactitude des données à virgule flottante :

var x = 0,1;
var y = 0,2;
var z = x + y // Le résultat de z est 0,3
if (z == 0,3) // Renvoie faux

Notes sur en utilisant l'instruction Return

JavaScript se termine automatiquement à la dernière ligne de code par défaut.

Les exemples de résultats suivants renverront undéfini :

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>php中文网(php.cn)</title>
</head>
<body>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = myFunction(55);
function myFunction(a) {
    var
    power = 10;
    return
    a * power;
}
</script>
</body>
</html>

Pourquoi y a-t-il un tel résultat ? Car en JavaScript, le code de l'exemple 4 est cohérent avec le code suivant :

function myFunction(a) {
var
power = 10;
return; Fin, renvoie undefined
un * power;
}

Parsing

S'il s'agit d'une instruction incomplète, comme suit :

var

JavaScript tentera de lire la deuxième ligne de déclarations :

power = 10;

Mais puisqu'une instruction comme celle-ci est complète :

return

JavaScript fermera automatiquement l'instruction :

return ;

En JavaScript, les points-virgules sont facultatifs.

Puisque return est une instruction complète, JavaScript fermera l'instruction return.

Utiliser des noms pour indexer des tableaux

De nombreux langages de programmation permettent l'utilisation de noms comme index dans des tableaux.

Un tableau qui utilise des noms comme index est appelé tableau associatif (ou hachage).

JavaScript ne prend pas en charge l'utilisation de noms pour indexer les tableaux, seuls les index numériques sont autorisés.

var personne = [];
personne[0] = "Jean";
personne[1] = "Biche";
personne[2] = 46;
var x = personne.longueur;            // personne.longueur renvoie 3
var y = personne[0];                                                                                                                                                                                                                                                               🎜>En JavaScript, les objets sont indexés par nom.

Si vous utilisez des noms comme index, JavaScript redéfinira le tableau en tant qu'objet standard lors de son accès.

Après avoir effectué cette opération, les méthodes et propriétés du tableau ne peuvent plus être utilisées, sinon une erreur se produira :

var person = [];

person[ "firstName"] = "John";

person["lastName"] = "Doe";

person["age"] = 46;

var x = person.length; renvoie 0

var y = personne[0]; // personne[0] renvoie undéfini

Définir un élément de tableau, la virgule ne peut pas être ajoutée à la fin

Mauvaise définition :

points = [40, 100, 1, 5, 25, 10,];

Définition correcte :

points = [40, 100, 1, 5, 25, 10];

Définissez l'objet, vous ne pouvez pas ajouter de virgule à la fin

Mauvaise façon de définition :

sites web = { site : "site Web chinois php", url : "www.php.cn", comme : 460,>

Définition correcte :

sites Web = { site : "php中文网", url : "www.php.cn", comme : 460}

Undéfini n'est pas Null

En JavaScript, null est utilisé pour les objets et undéfini est utilisé pour les variables, les propriétés et les méthodes.

L'objet ne peut être nul que s'il est défini, sinon il est indéfini.

Si nous voulons tester si l'objet existe, une erreur sera générée si l'objet n'est pas encore défini.

Utilisation incorrecte :

if (myObj !== null && typeof myObj !== "undefined")

La bonne manière est que nous devons d'abord utiliser typeof pour détecter si l'objet est défini :

if (typeof myObj !== "undefined" && myObj !== null)