JavaScript
Zmienna koercja / konwersja

Uwagi

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

Konwertowanie ciągu na liczbę

Number('0') === 0

Number('0') zamieni ciąg ( '0' ) na liczbę ( 0 )

Krótsza, ale mniej przejrzysta forma:

+'0' === 0

Jednoargumentowy operator + nic nie robi na liczby, ale konwertuje wszystko inne na liczbę.
Co ciekawe, +(-12) === -12 .

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

parseInt('0', 10) przekształci ciąg ( '0' ) na liczbę ( 0 ), nie zapomnij o drugim argumencie, którym jest podstawa. Jeśli nie zostanie podany, parseInt może przekonwertować ciąg znaków na niewłaściwy numer.

Konwertowanie liczby na ciąg

String(0) === '0'

String(0) przekształci liczbę ( 0 ) w ciąg ( '0' ).

Krótsza, ale mniej przejrzysta forma:

'' + 0 === '0'

Podwójna negacja (!! x)

Podwójna negacja !! nie jest wyraźnym operatorem JavaScript ani specjalną składnią, ale raczej sekwencją dwóch negacji. Służy do konwertowania wartości dowolnego typu na odpowiednią true lub false wartość logiczną w zależności od tego, czy jest to prawda, czy fałsz .

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

Pierwsza negacja przekształca każdą wartość na false jeśli jest prawdą, i true jeśli jest fałszem . Druga negacja działa wtedy na normalnej wartości logicznej. Razem przekształcić dowolną wartość truthy na true i wszelkie falsy wartość false .

Jednak wielu profesjonalistów uważa praktykę korzystania z takiej składni za niedopuszczalną i zaleca prostsze czytanie alternatyw, nawet jeśli mają dłuższe pisanie:

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

Użycie !!x jest uważane za złą praktykę z następujących powodów:

1. Stylistycznie może to wyglądać jak odrębna specjalna składnia, podczas gdy w rzeczywistości nie robi nic poza dwiema kolejnymi negacjami z niejawną konwersją typów.
2. Lepiej jest podać informacje o typach wartości przechowywanych w zmiennych i właściwościach za pomocą kodu. Na przykład x !== 0 mówi, że x jest prawdopodobnie liczbą, podczas gdy !!x nie przekazuje żadnej takiej korzyści czytelnikom kodu.
3. Użycie Boolean(x) pozwala na podobną funkcjonalność i jest bardziej wyraźną konwersją typu.

Niejawna konwersja

JavaScript będzie próbował automatycznie przekonwertować zmienne na bardziej odpowiednie typy po użyciu. Zwykle zaleca się wykonywanie konwersji jawnie (patrz inne przykłady), ale nadal warto wiedzieć, które konwersje zachodzą niejawnie.

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

Niektóre trudniejsze części:

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

Konwertowanie liczby na wartość logiczną

Boolean(0) === false

Boolean(0) przekształci liczbę 0 w logiczną wartość false .

Krótsza, ale mniej przejrzysta forma:

!!0 === false

Konwertowanie łańcucha na wartość logiczną

Aby przekonwertować ciąg na wartość logiczną, użyj

Boolean(myString)

lub krótsza, ale mniej przejrzysta forma

!!myString 

Wszystkie ciągi oprócz pustego ciągu (o długości zero) są sprawdzane jako true jako logiczne.

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

Integer to Float

W JavaScript wszystkie liczby są wewnętrznie reprezentowane jako liczby zmiennoprzecinkowe. Oznacza to, że po prostu użycie liczby całkowitej jako liczby zmiennoprzecinkowej jest wszystkim, co należy zrobić, aby ją przekonwertować.

Pływak do liczby całkowitej

Aby przekonwertować liczbę zmiennoprzecinkową na liczbę całkowitą, JavaScript udostępnia wiele metod.

Funkcja floor zwraca pierwszą liczbę całkowitą mniejszą lub równą wartości zmiennoprzecinkowej.

Math.floor(5.7); // 5

Funkcja ceil zwraca pierwszą liczbę całkowitą większą lub równą liczby zmiennoprzecinkowej.

Math.ceil(5.3); // 6

round funkcja zaokrągla liczbę zmiennoprzecinkową.

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

Konwertuj ciąg na liczbę zmiennoprzecinkową

parseFloat akceptuje ciąg jako argument, który konwertuje na zmiennoprzecinkowe /

parseFloat("10.01") // = 10.01

Konwersja na wartość logiczną

Boolean(...) przekształci dowolny typ danych na true lub 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

Puste łańcuchy i cyfra 0 zostaną zamienione na false, a wszystkie pozostałe zostaną przekonwertowane na true.

Krótsza, ale mniej przejrzysta forma:

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

Ta krótsza forma korzysta z niejawnej konwersji typu za pomocą logicznego operatora NOT dwa razy, jak opisano w http://www.riptutorial.com/javascript/example/3047/double-negation----x-

Oto pełna lista konwersji boolowskich ze specyfikacji ECMAScript

• jeśli myArg typu jest undefined lub null to Boolean(myArg) === false
• jeśli myArg typu boolean to Boolean(myArg) === myArg
• Jeśli myArg typu number następnie Boolean(myArg) === false jeśli myArg jest +0 , ‑0 lub NaN ; w przeciwnym razie true
• jeśli myArg typu string to Boolean(myArg) === false jeśli myArg jest pustym myArg (jego długość wynosi zero); w przeciwnym razie true
• jeśli myArg typu symbol lub object to Boolean(myArg) === true

Wartości przekształcane na false jako booleany nazywane są fałszem (a wszystkie inne nazywane są prawdą ). Zobacz operacje porównania .

Konwertuj tablicę na ciąg

Array.join(separator) może być użyty do wyprowadzenia tablicy jako łańcucha, z konfigurowalnym separatorem.

Domyślnie (separator = „,”):

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

Z separatorem ciągów:

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

Z pustym separatorem:

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

Array to String przy użyciu metod tablicowych

Ten sposób może wydawać się przydatny, ponieważ używasz anonimowej funkcji do osiągnięcia czegoś, co możesz zrobić za pomocą join (); Ale jeśli musisz coś zrobić z łańcuchami podczas konwersji tablicy na łańcuch, może to być przydatne.

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"

Tabela konwersji pierwotnej na pierwotną

Pogrubione wartości podkreślają konwersję, którą programiści mogą uznać za zaskakującą

Aby przekonwertować wartości jawnie, możesz użyć String () Number () Boolean ()