JavaScript, będąc językiem o dynamicznym typowaniu, zapewnia dużą swobodę w obsłudze danych, ale jednocześnie wymaga od programistów zrozumienia procesu konwersji typów. W JavaScript istnieją dwie metody zmieniania typów danych jawna konwersja i niejawna konwersja.
Jawna konwersja
Zachodzi w sytuacji gdzie to my mówimy interpreterowi JavaScript aby zamienił jeden typ danych na drugi, np:
Konwersja na String
//Za pomocą funkcji String():
let liczba = 123;
let tekst = String(liczba); // "123"
//Za pomocą metody .toString():
let liczba = 123;
let tekst = liczba.toString(); // "123"Konwersja na Number
//Za pomocą funkcji Number():
let tekst = "123";
let liczba = Number(tekst); // 123
//Za pomocą operatora +
let tekst = "123";
let liczba = +tekst; // 123
//Za pomocą parseInt() lub parseFloat():
let tekst = "123.45";
let tekst = "123Liczba";
let liczbaInt = parseInt(tekst); // 123
let liczbaFloat = parseFloat(tekst); // 123.45
//Jeżeli pierwszym znakiem nie jest liczba, to zwracany jest NaN
parseInt("123Liczba") // 123
parseInt("Liczba123") // NaNKonwersja na Boolean
//Za pomocą funkcji Boolean()
let wartosc1 = 0;
let boolean1 = Boolean(wartosc1); // false
let wartosc2 = 123;
let boolean2 = Boolean(wartosc2); // true
//Za pomocą operatora !!
let wartosc = "Hej!";
let boolean = !!wartosc; // truePodwójna negacja !!
Podwójna negacja !! w JavaScript konwertuje wartość na typ boolean. Pierwszy ! zamienia dowolną wartość na jej logiczne przeciwieństwo (wartości „truthy” na false i „falsy” na true), a drugi ! ponownie odwraca tę wartość. W rezultacie, wartości „truthy” stają się true, a „falsy” – false. Jest to szybki sposób na uzyskanie ścisłej wartości boolowskiej z dowolnej wartości.
Niejawna konwersja
Niejawna konwersja w JavaScript odnosi się do sytuacji, gdy interpreter języka samodzielnie zmienia typ danych w trakcie wykonywania operacji, aby dostosować je do kontekstu kodu. Jest to proces automatyczny, w którym interpreter interpretuje i przekształca wartości bez bezpośredniej instrukcji od programisty. Na przykład, gdy odejmujemy wartość boolean od pustego stringa (np. false - ""), JavaScript automatycznie konwertuje te wartości na liczby, co umożliwia wykonanie operacji arytmetycznej. Niejawna konwersja może ułatwić pisanie kodu, ale też prowadzić do nieoczekiwanych wyników.
Każda typ danych ma swoje odwzorowanie w innym typie:
Na podstawie powyższej tablicy, możliwe są poniższe działania:
console.log(true + true)// 2
console.log(true + false)// 1
console.log(true + null)// 1
console.log(false - "")// 0
console.log("22" - 10)// 10
console.log("22" + 10)// "2210" operator + powoduje tutaj że liczba 10 zostanie przekonwertowana na stringa
//oraz warunki
if ("czyToPrawda") {
//nastąpi niejawna konwersja na true
}Pułapki konwersji typów
Niejawna konwersja typów może prowadzić do trudnych do zdiagnozowania błędów. Oto kilka przykładów, które mogą być mylące:
- różnice między
nullaundefined
console.log(null == undefined); // true, ponieważ są traktowane jako równe w nieścisłym porównaniu
console.log(null === undefined); // false, ponieważ mają różne typy
console.log(null + 1); // 1, null jest traktowany jako 0
console.log(undefined + 1); // NaN, undefined nie jest konwertowany na liczbę- porównywanie różnych typów
console.log('0' == false); // true, ponieważ obie strony są konwertowane do liczby 0- konkatenacja zamiast dodawania
console.log("5" + 1); // "51", nie 6
console.log("5" - 1); // 4, ponieważ "5" jest konwertowany na liczbę- niejawna konwersja w instrukcjach warunkowych
if ("0") {
console.log("true"); // "true", ponieważ "0" jest wartością "truthy"
}
if (0) {
console.log("true"); // nie wykona się, ponieważ 0 jest wartością "falsy"
}