Maison > Article > interface Web > Expliquer la coercition non booléenne à booléenne en JavaScript ?

Expliquer la coercition non booléenne à booléenne en JavaScript ?

王林avant: 2023-09-20 21:37:021407parcourir

解释一下 JavaScript 中非布尔值到布尔值的强制转换？

Nous apprendrons comment contraindre des valeurs non booléennes en valeurs booléennes en JavaScript. Pour commencer, le mot cast est nouveau en JavaScript. Alors, clarifions ce qu’est la coercition.

La coercition est la conversion d'une variable d'un type de données en un autre type de données. Comme nous le savons tous, JavaScript n’est pas un langage strictement typé. Nous n’avons donc pas besoin de définir le type de la variable. Parfois, JavaScript force automatiquement les variables et donne des résultats imprévisibles dans la sortie.

Il existe deux types de conversions en JavaScript. L’une est l’application implicite et l’autre est l’application explicite. Nous découvrirons les deux moulages un par un dans ce tutoriel.

Forçage explicite

Le transtypage explicite se produit lorsqu'une valeur non booléenne est explicitement convertie en valeur booléenne à l'aide de l'une des méthodes de transtypage booléenne (telle que Boolean() ou !!).

Nous discuterons des deux méthodes en détail :

Casting explicite utilisant l'opérateur double NOT (!!)

Lorsque nous utilisons l'opérateur not (!) sur n'importe quelle valeur en JavaScript, il convertit les valeurs non booléennes en valeurs booléennes.

Un opérateur non (!) donne un résultat incorrect pour une valeur, deux opérateurs non (!!) donnent un résultat réel pour une valeur booléenne.

Grammaire

Les utilisateurs peuvent suivre la syntaxe suivante pour convertir des valeurs non booléennes en valeurs booléennes à l'aide d'opérateurs double NOT. -

var non_bool = "non-bool";
var bool = !!non_bool;

Dans la syntaxe ci-dessus, le premier opérateur not (!) contraint une variable non_bool de type chaîne en une variable booléenne. Le deuxième opérateur not(!) est utilisé pour obtenir la valeur booléenne réelle de la variable non_bool.

Voici quelques exemples d'utilisation de l'opérateur double NOT -

console.log(!!0); // logs false
console.log(!!1); // logs true

Dans l'exemple ci-dessus, la valeur non booléenne 0 est explicitement contrainte à une valeur booléenne à l'aide de l'opérateur double NOT. L'opérateur double NOT convertit son opérande en valeur booléenne puis l'inverse, donc l'expression !!0 est équivalente à !(!false), qui est évaluée comme false.

Voyons un exemple complet utilisant HTML et JavaScript

Exemple

Dans cet exemple, nous avons créé trois variables numériques nommées num1, num2 et num3. De plus, nous avons initialisé les variables numériques avec différentes valeurs positives, négatives et nulles.

L'utilisateur peut observer la valeur booléenne réelle du nombre dans la sortie. La valeur booléenne de zéro est fausse car c'est l'une des fausses valeurs booléennes en JavaScript.

<html>
<body>
   <h2> Coercion using <i> Doble NOT (!!) </i> Operator </h2>
   <p id = "output"> </p>
   <script>
      let output = document.getElementById("output");
      let num1 = 10;
      let num2 = 0;
      let num3 = -10;

      output.innerHTML += "num1 = " + num1 + "<br/>";
      output.innerHTML += "num2 = " + num2 + "<br/>";
      output.innerHTML += "num3 = " + num3 + "<br/>";
      output.innerHTML += "The boolean results of the above number values are given below.<br/>";

      // Using Double NOT Operator
      num1 = !!num1;
      num2 = !!num2;
      num3 = !!num3;

      output.innerHTML += "num1 = " + num1 + "<br/>";
      output.innerHTML += "num2 = " + num2 + "<br/>";
      output.innerHTML += "num3 = " + num3 + "<br/>";
   </script>
</body>
</html>

Utilisez le constructeur Boolean() pour les conversions explicites

En JavaScript, une conversion explicite se produit lorsqu'un développeur JavaScript convertit une variable d'un type de données à un autre. Ici, nous allons apprendre à convertir explicitement une valeur non booléenne en valeur booléenne.

Nous pouvons convertir n'importe quelle valeur en booléen en utilisant simplement le constructeur "booléen" en JavaScript.

Grammaire

Les utilisateurs peuvent contraindre les valeurs non booléennes en JavaScript en valeurs booléennes en suivant la syntaxe suivante.

let var1 = 30;
let var2 = Boolean(var1);

Dans la syntaxe ci-dessus, var1 est un type de données numérique et nous le convertissons en valeur booléenne à l'aide du constructeur booléen.

Voici quelques exemples d'utilisation du constructeur Boolean() -

console.log(Boolean(0)); // logs false
console.log(Boolean(1)); // logs true

Dans l'exemple ci-dessus, la valeur non booléenne 0 est explicitement contrainte à une valeur booléenne à l'aide d'une fonction booléenne. Une fonction booléenne renvoie la valeur booléenne de son argument, donc l'expression Boolean(0) renvoie false.

Lorsque nous convertissons une valeur non booléenne en valeur booléenne à l'exception des six fausses valeurs, cela donne toujours un résultat vrai. Pour les six valeurs d’erreur, nous obtenons toujours la mauvaise valeur booléenne comme résultat.

Six fausses valeurs booléennes sont données ci-dessous.

Erreur
""
NaN
0
vide
undéfini

Exemple

Nous avons créé différentes variables dans cet exemple et les avons initialisées avec différentes fausses valeurs. Nous pouvons observer que lorsque nous les forçons en booléen, cela donne toujours une valeur booléenne erronée.

<html>
<body>
   <h2> Coercion using the <i> Boolean()</i> Constructor </h2>
   <p id = "output"> </p>
   <script>
      let output = document.getElementById("output");
      // Creating the variables
      let falsy1 = undefined;
      let falsy2 = null;
      let falsy3 = "";

      output.innerHTML += "falsy1 = " + falsy1 + "<br/>";
      output.innerHTML += "falsy2 = " + falsy2 + "<br/>";
      output.innerHTML += "falsy3 = " + falsy3 + "<br/>";
      output.innerHTML +=
      "The boolean results of the above falsy values are given below.<br/>";

      // coercing the different falsy values to the boolean values.
      output.innerHTML += "falsy1 = " + Boolean(falsy1) + "<br/>";
      output.innerHTML += "falsy2 = " + Boolean(falsy2) + "<br/>";
      output.innerHTML += "falsy3 = " + Boolean(falsy3) + "<br/>";
   </script>
</body>
</html>

Coercition implicite

Les conversions implicites se produisent lorsqu'une valeur non booléenne est utilisée dans un contexte où une valeur booléenne est attendue. Dans ce cas, JavaScript convertira automatiquement la valeur en booléen en utilisant un ensemble de règles appelées « Vrai » et « Faux ».

Voici quelques exemples de conversion d'une valeur non booléenne en valeur booléenne -

Exemple

Dans cet exemple, nous utilisons la propriété cachée de l'image en JavaScript pour afficher l'image au clic -

// Example 1: Implicit coercion in a conditional statement
if (0) {
   console.log("This will not be logged");
}

// Example 2: Implicit coercion using the logical NOT operator
console.log(!0); // logs true
console.log(!1); // logs false

Dans le premier exemple, la valeur 0 est utilisée dans l'instruction conditionnelle et est implicitement contrainte à une valeur booléenne en utilisant les règles pour les valeurs vraies et fausses. En JavaScript, la valeur 0 est considérée comme fausse, l'instruction conditionnelle ne sera donc pas exécutée.

Dans le deuxième exemple, l'opérateur logique NON est utilisé pour annuler une valeur booléenne qui n'est pas 0. L'opérateur logique NOT inverse la valeur booléenne de son opérande, donc l'expression !0 est équivalente à !false, qui est évalué comme vrai.

Il existe deux types de conversions en JavaScript. L’une est la coercition implicite et l’autre la coercition explicite. Nous avons découvert les deux types de moulages un par un dans ce didacticiel.

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!

JavaScript html 数据类型 Boolean 运算符构造函数字符串字符串类型类型转换

Déclaration：

Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer

Article précédent：Validation du type de fichier lors du téléchargement à l'aide de JavaScriptArticle suivant：Validation du type de fichier lors du téléchargement à l'aide de JavaScript

Articles Liés

Voir plus