JavaScript
Coercizione / conversione variabile

Osservazioni

<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;

Convertire una stringa in un numero

Number('0') === 0

Number('0') convertirà la stringa ( '0' ) in un numero ( 0 )

Una forma più breve, ma meno chiara:

+'0' === 0

L'operatore unario + non fa nulla ai numeri, ma converte qualsiasi altra cosa in un numero.
È interessante notare che +(-12) === -12 .

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

parseInt('0', 10) convertirà la stringa ( '0' ) in un numero ( 0 ), non dimenticare il secondo argomento, che è radix. Se non specificato, parseInt potrebbe convertire la stringa in un numero errato.

Convertire un numero in una stringa

String(0) === '0'

String(0) convertirà il numero ( 0 ) in una stringa ( '0' ).

Una forma più breve, ma meno chiara:

'' + 0 === '0'

Doppia negazione (!! x)

La doppia negazione !! non è un operatore JavaScript distinto né una sintassi speciale ma piuttosto solo una sequenza di due negazioni. Viene utilizzato per convertire il valore di qualsiasi tipo nel valore booleano true o false appropriato a seconda che si tratti di verità o falsità .

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

La prima negazione converte qualsiasi valore in false se è vero e true se falsi . La seconda negazione funziona quindi su un valore booleano normale. Insieme convertire qualsiasi valore truthy al true e qualsiasi valore falsy al false .

Tuttavia, molti professionisti considerano inaccettabile l'utilizzo di tale sintassi e raccomandano soluzioni più semplici da leggere, anche se sono più lunghe da scrivere:

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'utilizzo di !!x è considerato scarsa pratica a causa dei seguenti motivi:

1. Stilisticamente può sembrare una sintassi speciale distinta mentre in realtà non fa altro che due negazioni consecutive con conversione di tipo implicita.
2. È meglio fornire informazioni sui tipi di valori memorizzati in variabili e proprietà attraverso il codice. Ad esempio, x !== 0 dice che x è probabilmente un numero, mentre !!x non trasmette alcun vantaggio ai lettori del codice.
3. L'utilizzo di Boolean(x) consente funzionalità simili ed è una conversione più esplicita di tipo.

Conversione implicita

JavaScript proverà a convertire automaticamente le variabili in tipi più appropriati dopo l'uso. Di solito è consigliabile eseguire le conversioni in modo esplicito (vedere altri esempi), ma vale comunque la pena conoscere quali conversioni avvengono implicitamente.

"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();

Alcune delle parti più complicate:

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

Convertire un numero in un booleano

Boolean(0) === false

Boolean(0) convertirà il numero 0 in un valore booleano false .

Una forma più breve, ma meno chiara:

!!0 === false

Convertire una stringa in un booleano

Per convertire una stringa in uso booleano

Boolean(myString)

o la forma più breve ma meno chiara

!!myString 

Tutte le stringhe tranne la stringa vuota (di lunghezza zero) vengono valutate come true booleane.

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

Integer to Float

In JavaScript, tutti i numeri sono rappresentati internamente come float. Ciò significa che è sufficiente utilizzare il numero intero come float per convertirlo.

Passa a numero intero

Per convertire un float in un intero, JavaScript fornisce più metodi.

La funzione floor restituisce il primo intero inferiore o uguale al float.

Math.floor(5.7); // 5

La funzione ceil restituisce il primo intero maggiore o uguale al float.

Math.ceil(5.3); // 6

La funzione round arrotonda il galleggiante.

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

Converti una stringa in float

parseFloat accetta una stringa come argomento che converte in un float /

parseFloat("10.01") // = 10.01

Conversione in booleano

Boolean(...) convertirà qualsiasi tipo di dati in true o 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

Le stringhe vuote e il numero 0 saranno convertite in false e tutte le altre verranno convertite in true.

Una forma più breve, ma meno chiara:

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

Questa forma più breve sfrutta la conversione di tipo implicita utilizzando l'operatore logico NOT due volte, come descritto in http://www.Scriptutorial.com/javascript/example/3047/double-negation----x-

Ecco l'elenco completo delle conversioni booleane dalla specifica ECMAScript

• se myArg di tipo undefined o null then Boolean(myArg) === false
• se myArg di tipo boolean poi Boolean(myArg) === myArg
• se myArg di tipo number poi Boolean(myArg) === false se myArg è +0 , ‑0 o NaN ; altrimenti true
• se myArg di tipo string then Boolean(myArg) === false if myArg è la String vuota (la sua lunghezza è zero); altrimenti true
• se myArg di tipo symbol o object then Boolean(myArg) === true

I valori convertiti in false come booleani sono chiamati falsy (e tutti gli altri sono chiamati truthy ). Vedi le operazioni di confronto .

Convertire una matrice in una stringa

Array.join(separator) può essere utilizzato per generare un array come stringa, con un separatore configurabile.

Predefinito (separatore = ","):

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

Con un separatore di stringhe:

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

Con un separatore vuoto:

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

Matrice su stringa utilizzando metodi array

In questo modo, potrebbe sembrare che ci siano degli utenti perché si sta utilizzando una funzione anonima per realizzare qualcosa che si può fare con join (); Ma se hai bisogno di creare qualcosa per le stringhe mentre stai convertendo l'array in stringa, questo può essere 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"

Tabella di conversione primitiva a primitiva

I valori in grassetto evidenziano la conversione che i programmatori possono trovare sorprendente

Per convertire in modo esplicito i valori puoi usare String () Number () Boolean ()