JavaScript
Variabele dwang / conversie

Opmerkingen

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

Een string omzetten naar een nummer

Number('0') === 0

Number('0') converteert de string ( '0' ) naar een nummer ( 0 )

Een kortere, maar minder duidelijke vorm:

+'0' === 0

De operator unary + doet niets aan getallen, maar converteert iets anders naar een getal.
Interessant is dat +(-12) === -12 .

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

parseInt('0', 10) converteert de string ( '0' ) naar een getal ( 0 ), vergeet het tweede argument niet, namelijk radix. Indien niet gegeven, kan parseInt een string naar een verkeerd nummer converteren.

Een getal omzetten in een tekenreeks

String(0) === '0'

String(0) converteert het getal ( 0 ) naar een string ( '0' ).

Een kortere, maar minder duidelijke vorm:

'' + 0 === '0'

Dubbele ontkenning (!! x)

De dubbele ontkenning !! is geen afzonderlijke JavaScript-operator noch een speciale syntaxis, maar eerder een reeks van twee ontkenningen. Het wordt gebruikt om de waarde van elke soort zetten op de betrokken true of false Booleaanse waarde naargelang het truthy of falsy.

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

De eerste negatie converteert waarde false als het truthy en true of is falsy. De tweede ontkenning werkt dan op een normale Booleaanse waarde. Samen zetten ze elke waarheidswaarde om in true en elke valse waarde in false .

Veel professionals vinden de praktijk van het gebruik van dergelijke syntaxis echter onaanvaardbaar en raden eenvoudiger alternatieven aan om te lezen, zelfs als ze langer moeten schrijven:

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

Het gebruik van !!x wordt als een slechte oefening beschouwd vanwege de volgende redenen:

1. Stilistisch lijkt het misschien een aparte speciale syntaxis, terwijl het in feite niets anders doet dan twee opeenvolgende ontkenningen met impliciete conversie van het type.
2. Het is beter om via de code informatie te geven over soorten waarden die zijn opgeslagen in variabelen en eigenschappen. Bijvoorbeeld, x !== 0 zegt dat x waarschijnlijk een getal is, terwijl !!x niet zo'n voordeel oplevert voor lezers van de code.
3. Het gebruik van Boolean(x) zorgt voor vergelijkbare functionaliteit en is een meer expliciete conversie van het type.

Impliciete conversie

JavaScript probeert bij gebruik automatisch variabelen om te zetten in meer geschikte typen. Het wordt meestal geadviseerd om conversies expliciet te doen (zie andere voorbeelden), maar het is nog steeds de moeite waard om te weten welke conversies impliciet plaatsvinden.

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

Enkele van de moeilijkere onderdelen:

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

Een getal converteren naar een Boolean

Boolean(0) === false

Boolean(0) converteert het getal 0 naar een Booleaanse waarde false .

Een kortere, maar minder duidelijke vorm:

!!0 === false

Een string omzetten naar een Boolean

Om een string om te zetten naar boolean gebruik

Boolean(myString)

of de kortere maar minder duidelijke vorm

!!myString 

Alle tekenreeksen behalve de lege tekenreeks (met lengte nul) worden als booleans als true geëvalueerd.

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

Geheel getal voor zweven

In JavaScript worden alle nummers intern weergegeven als drijvers. Dit betekent dat alleen het gebruik van uw gehele getal als float het enige is dat moet worden gedaan om het te converteren.

Zweven naar geheel getal

Om een float naar een geheel getal te converteren, biedt JavaScript meerdere methoden.

De floor functie retourneert het eerste gehele getal kleiner dan of gelijk aan de float.

Math.floor(5.7); // 5

De ceil retourneert het eerste gehele getal groter dan of gelijk aan de float.

Math.ceil(5.3); // 6

De round functie rondt de vlotter af.

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

String omzetten in zwevend

parseFloat accepteert een string als een argument dat het converteert naar een float /

parseFloat("10.01") // = 10.01

Converteren naar boolean

Boolean(...) converteert elk gegevenstype naar true of 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

Lege tekenreeksen en het getal 0 worden omgezet in onwaar, en alle andere worden omgezet in waar.

Een kortere, maar minder duidelijke vorm:

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

Deze kortere vorm maakt gebruik van een impliciete conversie van het type met de logische NOT-operator twee keer, zoals beschreven in http://www.riptutorial.com/javascript/example/3047/double-negation----x-

Hier is de complete lijst met booleaanse conversies uit de ECMAScript-specificatie

• als myArg van het type undefined of null dan is Boolean(myArg) === false
• als myArg van het type boolean dan Boolean(myArg) === myArg
• Als myArg type number dan Boolean(myArg) === false wanneer myArg is +0 , ‑0 , of NaN ; anders true
• als myArg van het type string dan Boolean(myArg) === false als myArg de lege string is (de lengte is nul); anders true
• als myArg van het type symbol of object dan is Boolean(myArg) === true

Waarden die worden omgezet naar false als booleans worden genoemd falsy (en alle anderen worden genoemd truthy). Zie Vergelijkingsbewerkingen .

Converteer een array naar een string

Array.join(separator) kan worden gebruikt om een array als een string uit te voeren, met een configureerbaar scheidingsteken.

Standaard (scheidingsteken = ","):

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

Met een stringscheider:

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

Met een blanco scheidingsteken:

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

Van array naar string met behulp van array-methoden

Op deze manier lijkt het nuttig omdat u een anonieme functie gebruikt om iets te bereiken waarmee u het kunt doen met join (); Maar als u iets aan de strings moet maken terwijl u de array naar String converteert, kan dit handig zijn.

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"

Primitieve naar Primitieve conversietabel

Vetgedrukte waarden benadrukken conversie die programmeurs misschien verrassend vinden

Om waarden expliciet te converteren, kunt u String () Number () Boolean () gebruiken