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)
section suivante
