JavaScript
Variabel tvång / konvertering

Anmärkningar

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

Konvertera en sträng till ett nummer

Number('0') === 0

Number('0') konverterar strängen ( '0' ) till ett nummer ( 0 )

En kortare, men mindre tydlig form:

+'0' === 0

Unary + -operatören gör ingenting till siffror, men konverterar allt annat till ett nummer.
Intressant är +(-12) === -12 .

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

parseInt('0', 10) konverterar strängen ( '0' ) till ett nummer ( 0 ), glöm inte det andra argumentet, som är radix. Om det inte ges, kan parseInt konvertera strängen till fel nummer.

Konvertera ett nummer till en sträng

String(0) === '0'

String(0) konverterar siffran ( 0 ) till en sträng ( '0' ).

En kortare, men mindre tydlig form:

'' + 0 === '0'

Double Negation (!! x)

Dubbelnegationen !! är inte en tydlig JavaScript-operatör eller en speciell syntax utan snarare bara en sekvens av två negationer. Det används för att konvertera värdet av vilken typ som helst till dess lämpliga true eller false booleska värde beroende på om det är sant eller falskt .

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

Den första negationen omvandlar något värde till false om det är sant och till true om det är falskt . Den andra negationen verkar sedan med ett normalt booleskt värde. Tillsammans konverterar de alla sanningsvärden till true och alla falskvärden till false .

Många yrkesverksamma anser emellertid praxis att använda en sådan syntax som oacceptabel och rekommenderar enklare att läsa alternativ, även om de är längre att skriva:

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

Användning av !!x anses vara dålig praxis på grund av följande skäl:

1. Stylistiskt kan det se ut som en distinkt speciell syntax medan den faktiskt inte gör något annat än två på varandra följande negationer med implicit typkonvertering.
2. Det är bättre att tillhandahålla information om typer av värden lagrade i variabler och egenskaper genom koden. Exempelvis säger x !== 0 att x förmodligen är ett nummer, medan !!x inte förmedlar någon sådan fördel till läsarna av koden.
3. Användning av Boolean(x) möjliggör liknande funktionalitet och är en mer tydlig konvertering av typen.

Implicit konvertering

JavaScript försöker automatiskt konvertera variabler till mer lämpliga typer vid användning. Det rekommenderas vanligtvis att göra konverteringar uttryckligen (se andra exempel), men det är fortfarande värt att veta vilka konverteringar som sker implicit.

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

Några av de svårare delarna:

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

Konvertera ett nummer till en boolean

Boolean(0) === false

Boolean(0) konverterar siffran 0 till en boolean false .

En kortare, men mindre tydlig form:

!!0 === false

Konvertera en sträng till en boolean

För att konvertera en sträng till boolesk användning

Boolean(myString)

eller den kortare men mindre tydliga formen

!!myString 

Alla strängar utom den tomma strängen (med längden noll) utvärderas till true som booleaner.

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

Heltal till Float

I JavaScript representeras alla nummer internt som flottörer. Detta betyder att helt enkelt använda ditt heltal som en flottör är allt som måste göras för att konvertera det.

Flyta till heltal

För att konvertera en flottör till ett heltal tillhandahåller JavaScript flera metoder.

floor returnerar det första heltalet mindre än eller lika med flottören.

Math.floor(5.7); // 5

ceil returnerar det första heltalet större än eller lika med flottören.

Math.ceil(5.3); // 6

Den round funktionen rundar flottören.

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

Konvertera sträng till flyta

parseFloat accepterar en sträng som ett argument som den konverterar till en flottör /

parseFloat("10.01") // = 10.01

Konvertera till boolean

Boolean(...) konverterar valfri datatyp till antingen true eller 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

Tomma strängar och antalet 0 kommer att konverteras till falska, och alla andra kommer att konverteras till true.

En kortare, men mindre tydlig form:

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

Denna kortare form utnyttjar implicit typkonvertering med den logiska INTE-operatören två gånger, såsom beskrivs i http://www.riptutorial.com/javascript/example/3047/double-negation----x-

Här är den kompletta listan över booleska omvandlingar från ECMAScript-specifikationen

• om myArg av typen undefined eller null då Boolean(myArg) === false
• om myArg av typ boolean så Boolean(myArg) === myArg
• om myArg av typen number sedan Boolean(myArg) === false om myArg är +0 , ‑0 , eller NaN ; annars true
• om myArg av typen string sedan Boolean(myArg) === false om myArg är den tomma String (dess längd är noll); annars true
• om myArg av typ symbol eller object sedan Boolean(myArg) === true

Värden som omvandlas till false som booleaner kallas förfalskning (och alla andra kallas sanning ). Se Jämförelseoperationer .

Konvertera en matris till en sträng

Array.join(separator) kan användas för att mata ut en matris som en sträng, med en konfigurerbar separator.

Standard (separator = ","):

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

Med en strängseparator:

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

Med en tom separator:

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

Array to String med hjälp av matrismetoder

Det här sättet kan tyckas vara uselss eftersom du använder anonym funktion för att kompensera något som du kan göra det med join (); Men om du behöver göra något till strängarna medan du konverterar Array till String kan det vara användbart.

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"

Primitiv till primitiv konverteringstabell

Djärva värden belyser konvertering som programmerare kan vara förvånande

För att konvertera uttryckligen värden kan du använda String () Number () Boolean ()