JavaScript
Coercition / conversion variable

Remarques

<span id="freezing-point">0</span>

var el = document.getElementById('freezing-point');
var freezingPoint = el.textContent || el.innerText;
var moreHeat = 100;
var boilingPoint = freezingPoint + moreHeat;

var el = document.getElementById('freezing-point');
var freezingPoint = Number(el.textContent || el.innerText);
var boilingPoint = freezingPoint + moreHeat;

Conversion d'une chaîne en nombre

Number('0') === 0

Number('0') convertira la chaîne ( '0' ) en un nombre ( 0 )

Une forme plus courte mais moins claire:

+'0' === 0

L'opérateur unaire + ne fait rien avec les nombres, mais convertit tout autre élément en nombre.
Fait intéressant, +(-12) === -12 .

parseInt('0', 10) === 0

parseInt('0', 10) convertira la chaîne ( '0' ) en un nombre ( 0 ), n'oubliez pas le second argument, qui est la base. Si ce n'est pas le cas, parseInt pourrait convertir la chaîne en mauvais numéro.

Conversion d'un nombre en chaîne

String(0) === '0'

String(0) convertira le nombre ( 0 ) en une chaîne ( '0' ).

Une forme plus courte mais moins claire:

'' + 0 === '0'

Double négation (!! x)

La double négation !! n'est pas un opérateur JavaScript distinct ni une syntaxe spéciale mais plutôt une séquence de deux négations. Il est utilisé pour convertir la valeur de n'importe quel type à sa valeur booléenne true ou false appropriée, selon qu'elle est véridique ou fausse .

!!1            // true
!!0            // false
!!undefined    // false
!!{}           // true
!![]           // true

La première négation convertit toute valeur en false si elle est véridique et true si elle est falsifiée . La seconde négation opère alors sur une valeur booléenne normale. Ensemble , ils convertissent une valeur truthy à true et toute valeur falsy à false .

Cependant, de nombreux professionnels considèrent que l'utilisation de cette syntaxe est inacceptable et recommandent de lire plus facilement les alternatives, même si elles sont plus longues à écrire:

x !== 0        // instead of !!x in case x is a number
x != null      // instead of !!x in case x is an object, a string, or an undefined

L'utilisation de !!x est considérée comme une mauvaise pratique pour les raisons suivantes:

1. Sur le plan stylistique, cela peut ressembler à une syntaxe spéciale distincte, alors qu'en réalité, il ne fait rien d'autre que deux négations consécutives avec une conversion de type implicite.
2. Il est préférable de fournir des informations sur les types de valeurs stockées dans les variables et les propriétés via le code. Par exemple, x !== 0 indique que x est probablement un nombre, alors que !!x ne présente aucun avantage pour les lecteurs du code.
3. L'utilisation de Boolean(x) permet des fonctionnalités similaires et constitue une conversion de type plus explicite.

Conversion implicite

JavaScript tentera de convertir automatiquement les variables en types plus appropriés lors de leur utilisation. Il est généralement conseillé de faire des conversions explicitement (voir d'autres exemples), mais il est toujours utile de savoir quelles sont les conversions implicites.

"1" + 5 === "15" // 5 got converted to string.
1 + "5" === "15" // 1 got converted to string.
1 - "5" === -4 // "5" got converted to a number.
alert({}) // alerts "[object Object]", {} got converted to string.
!0 === true // 0 got converted to boolean
if ("hello") {} // runs, "hello" got converted to boolean.
new Array(3) === ",,"; // Return true. The array is converted to string - Array.toString();

Certaines des parties les plus délicates:

!"0" === false // "0" got converted to true, then reversed.
!"false" === false // "false" converted to true, then reversed.

Conversion d'un nombre en booléen

Boolean(0) === false

Boolean(0) convertira le nombre 0 en un booléen false .

Une forme plus courte mais moins claire:

!!0 === false

Conversion d'une chaîne en booléen

Pour convertir une chaîne en utilisation booléenne

Boolean(myString)

ou la forme plus courte mais moins claire

!!myString 

Toutes les chaînes à l'exception de la chaîne vide (de longueur zéro) sont évaluées à true comme booléennes.

Boolean('') === false   // is true
Boolean("") === false   // is true
Boolean('0') === false  // is false
Boolean('any_nonempty_string') === true // is true

Entier à Flotter

En JavaScript, tous les nombres sont représentés en interne sous forme de flottants. Cela signifie que simplement utiliser votre entier comme un flottant est tout ce qui doit être fait pour le convertir.

Flotter à Entier

Pour convertir un flottant en un entier, JavaScript fournit plusieurs méthodes.

La fonction floor renvoie le premier entier inférieur ou égal au float.

Math.floor(5.7); // 5

La fonction ceil renvoie le premier entier supérieur ou égal au flottant.

Math.ceil(5.3); // 6

La fonction round arrondit le flotteur.

Math.round(3.2); // 3
Math.round(3.6); // 4

Math.trunc(3.7); // 3

Math.floor(-3.1); // -4
Math.trunc(-3.1); // -3

Convertir une chaîne en float

parseFloat accepte une chaîne comme argument qu'il convertit en float /

parseFloat("10.01") // = 10.01

Conversion en booléen

Boolean(...) convertira tout type de données en true ou en false .

Boolean("true") === true
Boolean("false") === true
Boolean(-1) === true
Boolean(1) === true
Boolean(0) === false
Boolean("") === false
Boolean("1") === true
Boolean("0") === true
Boolean({}) === true
Boolean([]) === true

Les chaînes vides et le nombre 0 seront convertis en false et tous les autres seront convertis en true.

Une forme plus courte mais moins claire:

!!"true" === true
!!"false" === true
!!-1 === true
!!1 === true
!!0 === false
!!"" === false
!!"1" === true
!!"0" === true
!!{} === true
!![] === true

Cette forme plus courte tire parti de la conversion de type implicite utilisant l'opérateur logique NOT deux fois, comme décrit dans http://www.riptutorial.com/javascript/example/3047/double-negation----x-

Voici la liste complète des conversions booléennes de la spécification ECMAScript

• si myArg de type undefined ou null alors Boolean(myArg) === false
• si myArg de type boolean alors Boolean(myArg) === myArg
• si myArg de type number alors Boolean(myArg) === false si myArg est +0 , ‑0 ou NaN ; sinon true
• si myArg de type string alors Boolean(myArg) === false si myArg est la chaîne vide (sa longueur est zéro); sinon true
• si myArg de type symbol ou object alors Boolean(myArg) === true

Les valeurs converties en false tant que booléens sont appelées falsy (et toutes les autres sont appelées truthy ). Voir Opérations de comparaison .

Convertir un tableau en chaîne

Array.join(separator) peut être utilisé pour générer un tableau sous forme de chaîne, avec un séparateur configurable.

Par défaut (séparateur = ","):

["a", "b", "c"].join() === "a,b,c"

Avec un séparateur de chaîne:

[1, 2, 3, 4].join(" + ") === "1 + 2 + 3 + 4"

Avec un séparateur vide:

["B", "o", "b"].join("") === "Bob"

Array to String à l'aide de méthodes de tableau

Cette façon de faire peut sembler être un outil car vous utilisez une fonction anonyme pour réaliser quelque chose que vous pouvez faire avec join (); Mais si vous devez créer quelque chose sur les chaînes pendant que vous convertissez le tableau en chaîne, cela peut être utile.

var  arr = ['a', 'á', 'b', 'c']

function upper_lower (a, b, i) {
  //...do something here
  b = i & 1 ? b.toUpperCase() : b.toLowerCase();
  return a + ',' + b
}
arr = arr.reduce(upper_lower); // "a,Á,b,C"

Table de conversion primitive à primitive

Les valeurs en gras soulignent la conversion que les programmeurs peuvent trouver surprenante

Pour convertir explicitement des valeurs, vous pouvez utiliser String () Number () Boolean ()