Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Konwersja typów i operacje na typach
W tej lekcji8
W Parku Jurajskim naukowcy często muszą przekształcać dane z jednej formy w drugą - tłumaczyć sekwencje DNA na atrybuty dinozaurów, konwertować pomiary między różnymi systemami czy analizować zachowania zwierząt. Podobnie w JavaScript, konwersja typów i operacje na typach danych to podstawowe umiejętności, które pozwalają na efektywne manipulowanie danymi.
Niejawna konwersja typów (Type Coercion)
JavaScript jest językiem dynamicznie typowanym (typ ma wartość, a nie zmienna) i słabo typowanym: gdy operacja tego wymaga, sam konwertuje wartości na inny typ. To jak automatyczne systemy adaptacyjne w Parku Jurajskim, które dostosowują się do zmian warunków - czasami wygodne, ale czasami zaskakujące.
Konwersja w operacjach arytmetycznych
Kiedy JavaScript wykonuje operacje arytmetyczne, próbuje automatycznie konwertować wartości na liczby:
// String + Number -> String (konkatenacja)
"Velociraptor " + 3; // "Velociraptor 3"
// String - Number -> Number
"50" - 10; // 40 (string "50" zostaje skonwertowany na liczbę)
// String * Number -> Number
"5" * 4; // 20 (string "5" zostaje skonwertowany na liczbę)
// String / Number -> Number
"20" / 5; // 4 (string "20" zostaje skonwertowany na liczbę)Zauważ szczególny przypadek operatora +, który dla stringów działa jako operator konkatenacji (łączenia), a nie dodawania. To jak obserwacja, że velociraptory zawsze polują w stadach - wiedza, która może uratować życie!
Konwersja w operacjach porównania
Kiedy porównujemy wartości różnych typów za pomocą operatora == (równość nieścisła), JavaScript próbuje je skonwertować na wspólny typ:
// Number == String
5 == "5"; // true (string "5" zostaje skonwertowany na liczbę 5)
// Boolean == Number
true == 1; // true (true zostaje skonwertowany na 1)
false == 0; // true (false zostaje skonwertowany na 0)
// null == undefined
null == undefined; // true (specjalny przypadek w specyfikacji)
// Object == Primitive
[1] == 1; // true ([1] zostaje skonwertowany na "1", a potem na 1)Takie zachowanie przypomina "intuicyjne" obserwacje w parku - "Ta zagroda wygląda tak samo jak tamta" - które mogą być mylące, jeśli nie znasz szczegółów.
Konwersja w operacjach logicznych
Operatory logiczne &&, || i ! mogą pracować z wartościami każdego typu, konwertując je niejawnie na boolean:
// Operator ! (negacja) konwertuje wartość na boolean i neguje ją
!0; // true (0 zostaje skonwertowane na false, a potem znegowane)
!"Dino"; // false ("Dino" zostaje skonwertowane na true, a potem znegowane)
// Operatory && i || mogą zwracać oryginalne wartości, a nie tylko boolean
"T-Rex" && "Raptor"; // "Raptor" (jeśli pierwszy operand jest truthy, zwraca drugi)
0 || "Backup"; // "Backup" (jeśli pierwszy operand jest falsy, zwraca drugi)Ta logika jest jak protokół postępowania w parku: "Jeśli ogrodzenie działa ORAZ jest wysokie, dinozaur nie ucieknie" - obydwa warunki muszą być spełnione, aby całe zdanie było prawdziwe.
Jawna konwersja typów (Explicit Type Conversion)
Aby uniknąć nieoczekiwanych wyników niejawnej konwersji, często warto jawnie skonwertować wartości na pożądany typ. To jak precyzyjne protokoły laboratoryjne w Parku Jurajskim - dokładnie określone procedury dające przewidywalne rezultaty.
Konwersja na String
// Metoda #1: Funkcja String()
String(42); // "42"
String(true); // "true"
String(null); // "null"
String(undefined); // "undefined"
String({ name: "T-Rex" }); // "[object Object]"
String([1, 2, 3]); // "1,2,3"
// Metoda #2: Metoda toString()
(42).toString(); // "42"
true.toString(); // "true"
[1, 2, 3].toString(); // "1,2,3"
// null.toString(); // Błąd! Null i undefined nie mają metody toString()
// Metoda #3: Konkatenacja z pustym stringiem
42 + ""; // "42"
true + ""; // "true"
null + ""; // "null"Konwersja na Number
// Metoda #1: Funkcja Number()
Number("42"); // 42
Number("42px"); // NaN (nie można skonwertować całego stringa na liczbę)
Number(true); // 1
Number(false); // 0
Number(null); // 0
Number(undefined); // NaN
Number([1]); // 1 (jednoelementowa tablica jest konwertowana na jej element)
Number([1, 2]); // NaN (tablica z wieloma elementami nie może być konwertowana)
// Metoda #2: Funkcje parseInt() i parseFloat()
parseInt("42"); // 42
parseInt("42px"); // 42 (konwertuje, dopóki nie napotka nieprawidłowego znaku)
parseInt("3.14"); // 3 (konwertuje tylko część całkowitą)
parseFloat("3.14"); // 3.14 (konwertuje część zmiennoprzecinkową)
// Metoda #3: Operatory unarny + i -
+"42"; // 42
-"42"; // -42
+true; // 1Konwersja na Boolean
// Metoda #1: Funkcja Boolean()
Boolean(42); // true
Boolean(0); // false
Boolean(""); // false
Boolean("text"); // true
Boolean(null); // false
Boolean(undefined); // false
Boolean({}); // true (każdy obiekt jest truthy)
// Metoda #2: Podwójna negacja !!
!!42; // true
!!0; // false
!!"text"; // true
!!null; // falseTabele konwersji
Poniższe tabele są jak tablice genetyczne dinozaurów w parku - pokazują, co dokładnie dzieje się podczas konwersji między różnymi typami.
Konwersja na String
| Typ wejściowy | Przykład wejściowy | Wynik konwersji na String |
|---|---|---|
| Number | 42 | "42" |
| Boolean | true | "true" |
| null | null | "null" |
| undefined | undefined | "undefined" |
| Array | [1, 2, 3] | "1,2,3" |
| Object | {name: "Rex"} | "[object Object]" |
| Function | function(){} | "function(){}" |
Konwersja na Number
| Typ wejściowy | Przykład wejściowy | Wynik konwersji na Number |
|---|---|---|
| String | "42" | 42 |
| String | " 42 " | 42 (białe znaki są usuwane) |
| String | "42px" | NaN |
| String | "" | 0 (pusty string) |
| Boolean | true | 1 |
| Boolean | false | 0 |
| null | null | 0 |
| undefined | undefined | NaN |
| Array | [] | 0 (pusta tablica) |
| Array | [5] | 5 (tablica z jednym elementem) |
| Array | [1, 2] | NaN (wiele elementów) |
| Object | {} | NaN |
Konwersja na Boolean
| Typ wejściowy | Przykład wejściowy | Wynik konwersji na Boolean |
|---|---|---|
| Number | 42 | true |
| Number | 0 | false |
| Number | NaN | false |
| String | "tekst" | true |
| String | "" | false |
| null | null | false |
| undefined | undefined | false |
| Object | {} (jakikolwiek) | true |
| Array | [] (jakakolwiek) | true |
Operacje na typach danych
Teraz zajmijmy się szczegółowymi operacjami na poszczególnych typach danych. To jak specjalistyczne procedury dla różnych gatunków dinozaurów.
Operacje na Stringach
Stringi w JavaScript oferują bogaty zestaw metod do manipulacji tekstem:
const parkName = "Jurassic Park";
// Długość stringa
parkName.length; // 13
// Dostęp do poszczególnych znaków
parkName[0]; // "J"
parkName.charAt(0); // "J" (alternatywna metoda)
// Wyszukiwanie podciągów
parkName.indexOf("Park"); // 9 (indeks, gdzie zaczyna się "Park")
parkName.startsWith("Jur"); // true
parkName.endsWith("Park"); // true
parkName.includes("assic"); // true
// Zmiana wielkości liter
parkName.toUpperCase(); // "JURASSIC PARK"
parkName.toLowerCase(); // "jurassic park"
// Wycinanie fragmentów
parkName.substring(0, 8); // "Jurassic"
parkName.slice(-4); // "Park" (liczy od końca)
// Zastępowanie fragmentów
parkName.replace("Jurassic", "Dinosaur"); // "Dinosaur Park"
// Podział stringa na tablicę
parkName.split(" "); // ["Jurassic", "Park"]
// Usuwanie białych znaków
" Danger Zone ".trim(); // "Danger Zone"
// Łączenie stringów
"Welcome".concat(" to ", parkName); // "Welcome to Jurassic Park"
// Powtarzanie stringa
"Roar! ".repeat(3); // "Roar! Roar! Roar! "Operacje na Liczbach
JavaScript oferuje wiele możliwości pracy z liczbami, zarówno bezpośrednio na wartościach, jak i przez obiekt Math:
// Podstawowe operacje arytmetyczne
5 + 3; // 8 (dodawanie)
5 - 3; // 2 (odejmowanie)
5 * 3; // 15 (mnożenie)
5 / 3; // 1.6666666666666667 (dzielenie)
5 % 3; // 2 (modulo - reszta z dzielenia)
5 ** 3; // 125 (potęgowanie - 5 do potęgi 3)
// Inkrementacja i dekrementacja
let dinoCount = 5;
dinoCount++; // dinoCount jest teraz 6
dinoCount--; // dinoCount z powrotem do 5
// Operatory przypisania i operacji
dinoCount += 3; // To samo co: dinoCount = dinoCount + 3
dinoCount *= 2; // To samo co: dinoCount = dinoCount * 2
// Obiekt Math do zaawansowanych operacji
Math.abs(-5); // 5 (wartość bezwzględna)
Math.round(4.7); // 5 (zaokrąglenie do najbliższej liczby całkowitej)
Math.ceil(4.1); // 5 (zaokrąglenie w górę)
Math.floor(4.9); // 4 (zaokrąglenie w dół)
Math.max(3, 7, 2, 4); // 7 (znajdowanie maksimum)
Math.min(3, 7, 2, 4); // 2 (znajdowanie minimum)
Math.pow(2, 3); // 8 (potęgowanie - 2 do potęgi 3)
Math.sqrt(16); // 4 (pierwiastek kwadratowy)
Math.sin(0); // 0 (sinus)
Math.cos(0); // 1 (cosinus)
Math.random(); // Losowa liczba od 0 (włącznie) do 1 (wyłącznie)
// Generowanie losowej liczby z zakresu
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
getRandom(1, 10); // Losowa liczba od 1 do 10
// Formatowanie liczb
const height = 5.678934;
height.toFixed(2); // "5.68" (dwa miejsca po przecinku, zwraca string)
height.toPrecision(3); // "5.68" (trzy znaczące cyfry, zwraca string)
height.toString(2); // "101.1010110111001110100111100101111000100100011110001" (reprezentacja binarna)
(1234567).toLocaleString(); // "1,234,567" (formatowanie z separatorami, zależy od locale)Operacje na Wartościach Logicznych
Chociaż typ boolean ma tylko dwie możliwe wartości, istnieje wiele operacji logicznych:
// Operatory porównania
5 > 3; // true (większe niż)
5 >= 5; // true (większe lub równe)
3 < 5; // true (mniejsze niż)
3 <= 3; // true (mniejsze lub równe)
5 == "5"; // true (równość nieścisła - różne typy są konwertowane)
5 === "5"; // false (równość ścisła - typy muszą być zgodne)
5 != "6"; // true (nierówność nieścisła)
5 !== "5"; // true (nierówność ścisła)
// Operatory logiczne
true && true; // true (AND logiczne - oba warunki muszą być prawdziwe)
true && false; // false
true || false; // true (OR logiczne - co najmniej jeden warunek musi być prawdziwy)
false || false; // false
!true; // false (NOT logiczne - negacja)
!false; // true
// Złożone warunki
const isSafe = fenceActive && powerLevel > 5000 && !stormApproaching;
const needsEvacuation = alarmTriggered || dinoEscaped || stormStrength > 8;Operacje na null i undefined
Pomimo ograniczonych możliwości bezpośrednich operacji na null i undefined, istnieją użyteczne wzorce pracy z nimi:
// Operator || do wartości domyślnych (uwaga: zastąpi też 0 i pusty string)
const visitorName = userName || "Gość"; // Użycie userName, jeśli istnieje, w przeciwnym razie "Gość"
// Operator nullish coalescing (??) - dostępny w nowszych wersjach JS
const count = dinoCount ?? 0; // Użycie dinoCount, jeśli nie jest null/undefined, w przeciwnym razie 0
// Optional chaining (?.) - dostępny w nowszych wersjach JS
const species = dinosaur?.species; // Bezpieczny dostęp do właściwości, nawet jeśli dinosaur jest null/undefinedCiekawe i trudne przypadki konwersji typów
Niektóre konwersje typów w JavaScript mogą być zaskakujące, podobnie jak nietypowe zachowania dinozaurów po burzy:
// Dziwne przypadki równości nieścisłej (==)
[] == ''; // true (pusta tablica jest konwertowana na pusty string)
[1] == 1; // true (tablica [1] jest konwertowana na string "1", a potem na liczbę 1)
[1, 2] == '1,2'; // true (tablica [1, 2] jest konwertowana na string "1,2")
true == '1'; // true (true jest konwertowane na 1, a '1' na 1)
false == '0'; // true (false jest konwertowane na 0, a '0' na 0)
null == undefined; // true (specjalny przypadek w specyfikacji)
'' == 0; // true (pusty string jest konwertowany na 0)
// Operacje z NaN
NaN == NaN; // false (NaN nie jest równe niczemu, nawet samemu sobie)
Number.isNaN(NaN); // true (właściwy sposób sprawdzania NaN)
// Operacje z obiektami
const obj1 = {}, obj2 = {};
obj1 == obj2; // false (obiekty są porównywane przez referencję, nie zawartość)
obj1 === obj2; // false (obiekty są porównywane przez referencję, nie zawartość)
// Operacje na tablicach
[] + []; // "" (tablice są konwertowane na stringi, a potem łączone)
[] + {}; // "[object Object]" (obiekt jest konwertowany na string)
{} + []; // 0 (puste {} jest traktowane jako blok kodu, a +[] jest konwertowane na liczbę)Najlepsze praktyki
Aby uniknąć niespodzianek przy pracy z typami danych, warto stosować następujące zasady - są jak protokoły bezpieczeństwa w Parku Jurajskim:
1. Używaj ścisłego porównania (===, !==)
// ŹLE
if (dinoCount == "5") { // Zadziała, ale może prowadzić do błędów
// DOBRZE
if (dinoCount === 5) { // Wyraźnie wskazuje, że dinoCount powinno być liczbą2. Jawnie konwertuj typy, gdy jest to potrzebne
// ŹLE
const totalVisitors = visitorCount + newVisitors; // Może dawać niepoprawne wyniki, jeśli któraś zmienna jest stringiem
// DOBRZE
const totalVisitors = Number(visitorCount) + Number(newVisitors); // Jawna konwersja na liczby3. Używaj odpowiednich metod sprawdzania typu
// ŹLE
if (typeof height == "number" && !isNaN(height)) { // Działa, ale jest nieprecyzyjne
// DOBRZE
function isValidNumber(value) {
return typeof value === 'number' && !isNaN(value) && isFinite(value);
}
if (isValidNumber(height)) {4. Uważaj na operacje na obiektach
// ŹLE
if (dinosaur == otherDinosaur) { // Porównuje referencje, nie zawartość
// DOBRZE
function isEqual(obj1, obj2) {
return JSON.stringify(obj1) === JSON.stringify(obj2); // Dla prostych obiektów
}
if (isEqual(dinosaur, otherDinosaur)) {5. Używaj operatorów nullish coalescing (??) i optional chaining (?.)
// ZAMIAST
const safeVisitorCount = visitorCount !== null && visitorCount !== undefined ? visitorCount : 0;
const speciesName = dinosaur && dinosaur.species ? dinosaur.species : "Nieznany";
// LEPIEJ (w nowszym JS)
const safeVisitorCount = visitorCount ?? 0;
const speciesName = dinosaur?.species ?? "Nieznany";Praktyczny przykład: Przetwarzanie danych o dinozaurach
Poniższy przykład pokazuje, jak zastosować operacje na typach danych w praktycznym scenariuszu:
// Dane przychodzące z różnych źródeł (symulacja API, formularzy, plików CSV)
const rawDinoData = [
{ id: "1", name: "Rexy", species: "T-Rex", height: "5.6", dangerous: "true", lastFed: "2023-05-15T08:30:00" },
{ id: 2, name: "Blue", species: "Velociraptor", height: "1.8", dangerous: true, lastFed: "2023-05-15T09:15:00" },
{ id: "3", name: "Spike", species: "Stegosaurus", height: 4.2, dangerous: "false", lastFed: null },
{ id: "4", name: "Cera", species: "Triceratops", height: "unknown", dangerous: false, lastFed: "invalid-date" }
];
// Funkcja do normalizacji i walidacji danych
function processDinosaurData(dinoList) {
// Przygotowanie znormalizowanej tablicy
const processedData = [];
// Przetworzenie każdego elementu
for (let i = 0; i < dinoList.length; i++) {
const dino = dinoList[i];
// Normalizacja ID
const id = Number(dino.id);
if (isNaN(id) || id <= 0) {
console.warn(`Pominięto dinozaura z nieprawidłowym ID: ${dino.id}`);
continue;
}
// Normalizacja imienia
const name = String(dino.name).trim();
if (name === "") {
console.warn(`Pominięto dinozaura bez imienia, ID: ${id}`);
continue;
}
// Normalizacja gatunku
const species = String(dino.species).trim() || "Nieznany";
// Normalizacja wysokości
let height;
if (dino.height === "unknown" || dino.height === undefined) {
height = null;
} else {
height = Number(dino.height);
if (isNaN(height)) {
console.warn(`Nieprawidłowa wysokość dla ${name}, ustawiono null`);
height = null;
}
}
// Normalizacja flagi niebezpieczny
let dangerous;
if (typeof dino.dangerous === 'string') {
dangerous = dino.dangerous.toLowerCase() === 'true';
} else {
dangerous = Boolean(dino.dangerous);
}
// Normalizacja daty ostatniego karmienia
let lastFed = null;
if (dino.lastFed) {
const date = new Date(dino.lastFed);
if (!isNaN(date.getTime())) {
lastFed = date;
} else {
console.warn(`Nieprawidłowa data karmienia dla ${name}`);
}
}
// Dodatkowe obliczenia
const securityLevel = dangerous ? (height > 3 ? "Wysoki" : "Średni") : "Niski";
const daysFromLastFeed = lastFed ? Math.floor((new Date() - lastFed) / (1000 * 60 * 60 * 24)) : null;
// Dodanie znormalizowanego dinozaura do wynikowej tablicy
processedData.push({
id,
name,
species,
height,
dangerous,
lastFed,
securityLevel,
daysFromLastFeed,
needsFeeding: daysFromLastFeed === null || daysFromLastFeed > 1
});
}
return processedData;
}
// Używanie funkcji
const normalizedDinos = processDinosaurData(rawDinoData);
console.log(normalizedDinos);
// Dodatkowe przetwarzanie danych
const dangerousDinos = normalizedDinos.filter(dino => dino.dangerous);
const withHeight = normalizedDinos.filter(dino => dino.height !== null);
const avgHeight = withHeight.reduce((sum, dino) => sum + dino.height, 0) / withHeight.length;
const dinosBySecurityLevel = normalizedDinos.reduce((groups, dino) => {
groups[dino.securityLevel] = groups[dino.securityLevel] || [];
groups[dino.securityLevel].push(dino);
return groups;
}, {});Ten przykład pokazuje, jak radzić sobie z różnymi typami danych, konwertować je, walidować i normalizować - wszystko to są podstawowe operacje, których naukowcy w Parku Jurajskim musieliby dokonywać na codziennych danych.
Podsumowanie
Konwersja typów i operacje na typach danych w JavaScript to obszerne zagadnienie, które wymaga zrozumienia wielu niuansów. Kluczowe aspekty to:
Niejawna konwersja - JavaScript automatycznie konwertuje typy w wielu kontekstach
- Może prowadzić do nieoczekiwanych wyników
- Jest wygodna, ale czasem niebezpieczna
Jawna konwersja - Kontrolowane przekształcanie typów
String(),Number(),Boolean()- funkcje konwertującetoString(),parseInt(),parseFloat()- metody i funkcje specjalizowane!!- szybka konwersja na boolean
Operacje na poszczególnych typach
- Stringi mają bogaty zestaw metod do manipulacji tekstem
- Liczby mogą być przetwarzane przy użyciu operatorów i obiektu Math
- Wartości logiczne są podstawą dla instrukcji warunkowych
- Null i undefined mają specjalne zasady w operacjach
Najlepsze praktyki
- Używanie ścisłego porównania (===, !==)
- Jawne konwertowanie typów tam, gdzie to potrzebne
- Stosowanie odpowiednich funkcji sprawdzających
Podobnie jak w Parku Jurajskim, gdzie różne gatunki dinozaurów wymagają różnych protokołów postępowania, tak w JavaScript różne typy danych wymagają odpowiedniego podejścia. Znajomość zasad konwersji i operacji na typach pozwala na skuteczne i bezpieczne manipulowanie danymi - podstawę każdej aplikacji JavaScript.
W następnej lekcji przyjrzymy się operatorom arytmetycznym i przypisania, które pozwalają na przeprowadzanie bardziej zaawansowanych kalkulacji - niezbędnych dla zarządzania zasobami w tak złożonym przedsięwzięciu jak Park Jurajski.
Kod do tej lekcji: index.js
// Konwersja typów i operacje na typach danych
// Eksperymentuj z niejawna i jawna konwersja typów w JavaScript
// === Niejawna konwersja (Type Coercion) ===
console.log("=== Niejawna konwersja ===");
// String + Number -> konkatenacja
console.log("Dinozaurów: " + 5); // "Dinozaurów: 5"
console.log("5" + 3); // "53" (string!)
// String - Number -> Number
console.log("10" - 3); // 7
console.log("5" * 2); // 10
// Boolean w operacjach
console.log(true + 1); // 2
console.log(false + 1); // 1
// === Jawna konwersja ===
console.log("\n=== Jawna konwersja ===");
// Na Number
console.log(Number("42")); // 42
console.log(Number("abc")); // NaN
console.log(parseInt("100px")); // 100
console.log(parseFloat("3.14m")); // 3.14
// Na String
console.log(String(42)); // "42"
console.log(String(true)); // "true"
console.log((255).toString(16)); // "ff" (hex)
// Na Boolean
console.log(Boolean(0)); // false
console.log(Boolean("")); // false
console.log(Boolean("tekst")); // true
console.log(Boolean(1)); // true
// === typeof operator ===
console.log("\n=== typeof ===");
console.log(typeof 42); // "number"
console.log(typeof "tekst"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (historyczny bug!)
// Twoje zadanie:
// 1. Sprawdź wynik "5" + 3 vs "5" - 3
// 2. Użyj Number() do konwersji stringa na liczbę
// 3. Sprawdź typeof dla różnych wartości
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Co zwróci wyrażenie Number('hello') w JavaScript?
2. Co zwróci wyrażenie '5' - 2 w JavaScript?
3. Która metoda jawnej konwersji stringa na liczbę jest NIEPOPRAWNA?
4. Która z poniższych wartości NIE jest wartością falsy w JavaScript?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy template literal: