Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Podstawowe typy danych (string, number, boolean, null, undefined)
W tej lekcji8
Jak w Parku Jurajskim mamy różne gatunki dinozaurów, każdy z unikalnymi cechami i zachowaniami, tak w JavaScript mamy różne typy danych, z których każdy służy konkretnym celom. Zrozumienie tych typów jest kluczowe dla skutecznego programowania - to jak znajomość różnic między Velociraptorem a Triceratopsem dla pracownika parku.
Typy pierwotne (primitive types)
JavaScript posiada pięć głównych typów pierwotnych: string, number, boolean, null i undefined. Są to podstawowe "gatunki" w naszym cyfrowym parku.
1. String - teksty
Typ string reprezentuje tekst - sekwencję znaków ujętą w pojedyncze ('), podwójne (") lub grawisowe (`) cudzysłowy. To jak tabliczki informacyjne w Parku Jurajskim, które przekazują odwiedzającym ważne komunikaty.
// Różne sposoby deklarowania stringów
const dinoName = "Tyrannosaurus Rex";
const warningSign = 'Uwaga! Nie zbliżaj się do ogrodzenia!';
const locationInfo = `Znajdujesz się w sektorze B4`;
// Stringi mogą zawierać specjalne znaki
const multilineWarning = "Uwaga!\nNie karm dinozaurów!"; // \n oznacza nową linię
// Długość stringa (liczba znaków)
const nameLength = dinoName.length; // 17
// Łączenie stringów (konkatenacja)
const fullWarning = warningSign + " " + dinoName + " jest niebezpieczny!";
// Template literals (szablony tekstowe) - tylko z grawisami (``)
const modernWarning = `${warningSign} ${dinoName} jest niebezpieczny!`;Stringi są jak uniwersalny język komunikacji w parku - służą do wyświetlania informacji, wysyłania wiadomości i etykietowania zasobów.
Metody stringów
Stringi w JavaScript posiadają wbudowane metody, które pozwalają na ich manipulację, podobnie jak pracownicy parku mają narzędzia do zarządzania ekspozycjami:
const species = "Velociraptor";
// Zmiana wielkości liter
const upperCase = species.toUpperCase(); // "VELOCIRAPTOR"
const lowerCase = species.toLowerCase(); // "velociraptor"
// Wyszukiwanie w stringu
const hasRaptor = species.includes("raptor"); // true
const position = species.indexOf("raptor"); // 6 (indeksy zaczynają się od 0)
const startsWith = species.startsWith("Velo"); // true
const endsWith = species.endsWith("tor"); // true
// Wycinanie fragmentów
const firstFour = species.substring(0, 4); // "Velo"
const lastSix = species.slice(-6); // "raptor"
// Zamiana fragmentów
const newSpecies = species.replace("Veloci", "Micro"); // "Microraptor"
// Podział stringa na tablicę
const announcement = "Uwaga! Wszyscy goście proszeni są o ewakuację!";
const words = announcement.split(" "); // ["Uwaga!", "Wszyscy", "goście", ...]2. Number - liczby
Typ number reprezentuje zarówno liczby całkowite, jak i zmiennoprzecinkowe (ułamki dziesiętne). W przeciwieństwie do wielu innych języków programowania, JavaScript nie rozróżnia tych dwóch rodzajów - wszystkie są po prostu number.
To jak system numeryczny w parku używany do wszystkiego - od liczenia dinozaurów po mierzenie ich wagi czy wysokości.
// Liczby całkowite
const dinoCount = 37;
const parkSectors = 12;
// Liczby zmiennoprzecinkowe (ułamki dziesiętne)
const trexHeight = 5.6; // metry
const raptorSpeed = 38.5; // km/h
// Notacja naukowa
const atomSize = 1.5e-10; // 0.00000000015
const dinosaurCellCount = 3.2e12; // 3,200,000,000,000
// Nieskończoność i NaN (Not a Number)
const infinity = Infinity; // Wartość nieskończona
const negInfinity = -Infinity; // Wartość ujemnie nieskończona
const notANumber = NaN; // Wynik nieprawidłowej operacji matematycznej, np. 0/0Operacje na liczbach
Liczby w JavaScript wspierają wszystkie standardowe operacje matematyczne, podobnie jak naukowcy w parku przeprowadzają różne obliczenia:
// Podstawowe operacje arytmetyczne
const sum = 10 + 5; // 15 (dodawanie)
const diff = 10 - 5; // 5 (odejmowanie)
const product = 10 * 5; // 50 (mnożenie)
const quotient = 10 / 5; // 2 (dzielenie)
const remainder = 10 % 3; // 1 (modulo - reszta z dzielenia)
const power = 10 ** 2; // 100 (potęgowanie - 10 do potęgi 2)
// Obiekt Math do zaawansowanych operacji
const roundedHeight = Math.round(trexHeight); // 6 (zaokrąglenie)
const ceilingHeight = Math.ceil(trexHeight); // 6 (zaokrąglenie w górę)
const floorHeight = Math.floor(trexHeight); // 5 (zaokrąglenie w dół)
const randomNumber = Math.random(); // Losowa liczba między 0 a 1
const maxSpeed = Math.max(42, 35, 38, 40); // 42 (najwyższa wartość)
const sqrtValue = Math.sqrt(25); // 5 (pierwiastek kwadratowy)Uwaga na dokładność liczb zmiennoprzecinkowych
W JavaScript (i wielu innych językach) liczby zmiennoprzecinkowe mogą prowadzić do nieoczekiwanych wyników, podobnie jak nieprzewidziane zachowania dinozaurów:
const precisionIssue = 0.1 + 0.2; // Oczekujemy 0.3, ale dostajemy 0.30000000000000004
// Rozwiązanie - użycie zaokrąglenia lub stałej przeskalowanej:
const fixedResult = Number((0.1 + 0.2).toFixed(1)); // 0.3
const scaledResult = (0.1 * 10 + 0.2 * 10) / 10; // 0.33. Boolean - wartości logiczne
Typ boolean ma tylko dwie możliwe wartości: true (prawda) lub false (fałsz). To jak system alarmowy w parku, który może być włączony lub wyłączony.
// Podstawowe wartości boolean
const fenceActive = true;
const parkClosed = false;
// Wyrażenia logiczne zwracają boolean
const isTRexDangerous = true;
const isParkOpen = !parkClosed; // true (negacja)
const isSafeToEnter = fenceActive && isParkOpen; // true (AND - i)
const needsAttention = !fenceActive || parkClosed; // false (OR - lub)Wartości boolean są kluczowe dla podejmowania decyzji w programie - podobnie jak systemy bezpieczeństwa w parku, które decydują, czy otworzyć bramę, uruchomić alarm czy ewakuować sektor.
// Użycie boolean w instrukcjach warunkowych
if (fenceActive) {
console.log("Zagroda zabezpieczona");
} else {
console.log("UWAGA! Zagroda niezabezpieczona!");
activateEmergencyProtocol();
}
// Operatory porównania zwracają boolean
const isDangerousSpecies = dinosaurType === "Velociraptor" || dinosaurType === "T-Rex";
const isHerbivore = dinosaurDiet !== "mięsożerca";
const isTooBig = dinosaurHeight > 3;
const isInRange = visitorDistance >= 50;4. null - celowy brak wartości
Wartość null reprezentuje celowy brak wartości - jest to jawne wskazanie, że zmienna nie zawiera żadnej wartości. To jak pusta zagroda w parku, specjalnie przygotowana, ale aktualnie bez dinozaura.
// Zmienna z wartością null
let selectedDinosaur = null; // Aktualnie żaden dinozaur nie jest wybrany
// Null jest często używany jako wartość początkowa
let scannedChip = null; // Przed skanowaniem chip nie zawiera danych
// Sprawdzanie, czy wartość to null
if (selectedDinosaur === null) {
console.log("Żaden dinozaur nie został wybrany");
}
// Null jest wartością falsy
if (!selectedDinosaur) {
console.log("To się również wyświetli dla null");
}5. undefined - niezdefiniowana wartość
Wartość undefined oznacza, że zmienna została zadeklarowana, ale nie została jej przypisana żadna wartość. To jak niezagospodarowana działka w parku - istnieje, ale nie określono jeszcze, co na niej będzie.
// Zadeklarowana, ale niezainicjalizowana zmienna
let newDinosaur; // automatycznie ma wartość undefined
// Funkcja bez jawnego return zwraca undefined
function checkEnclosure() {
// Brak instrukcji return
}
const result = checkEnclosure(); // result ma wartość undefined
// Sprawdzanie, czy wartość to undefined
if (newDinosaur === undefined) {
console.log("Dinozaur nie został jeszcze określony");
}
// undefined jest wartością falsy
if (!newDinosaur) {
console.log("To się również wyświetli dla undefined");
}Różnice między null i undefined
Choć oba typy reprezentują "brak wartości", istnieją między nimi ważne różnice:
nullto celowy brak wartości (jak pusta zagroda)undefinedto niezamierzony brak wartości (jak nieprzydzielone miejsce)
// typeof pokazuje różnicę
typeof null; // "object" (to jest historyczny błąd w JavaScript)
typeof undefined; // "undefined"
// W kontekście równości
null == undefined; // true (równość nieścisła)
null === undefined; // false (równość ścisła)Symbol i BigInt - nowsze typy pierwotne
Nowsze wersje dodały dwa kolejne typy pierwotne: Symbol (ES2015) i BigInt (ES2020). Razem z pięcioma typami opisanymi wyżej JavaScript ma siedem typów pierwotnych.
Symbol - unikalny identyfikator
// Tworzenie unikalnych identyfikatorów
const dinoId = Symbol('dino-id');
const enclosureId = Symbol('enclosure-id');
// Każdy Symbol jest unikalny
const id1 = Symbol('id');
const id2 = Symbol('id');
console.log(id1 === id2); // false, choć mają ten sam opisBigInt - duże liczby całkowite
// Tworzenie BigInt przez dodanie 'n' na końcu liczby lub funkcję BigInt()
const dinoGenomeSize = 9007199254740991n;
const sameBigInt = BigInt(9007199254740991);
// BigInt może reprezentować liczby większe niż Number.MAX_SAFE_INTEGER
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991Sprawdzanie typu
Aby zidentyfikować typ danej wartości (podobnie jak identyfikacja gatunku dinozaura), możemy użyć operatora typeof:
typeof "Triceratops"; // "string"
typeof 42; // "number"
typeof true; // "boolean"
typeof null; // "object" (uwaga: to jest historyczny błąd w JavaScript)
typeof undefined; // "undefined"
typeof Symbol(); // "symbol"
typeof 42n; // "bigint"
// Dla funkcji i obiektów
typeof function() {}; // "function"
typeof {}; // "object"
typeof []; // "object" (tablice są obiektami w JavaScript)Konwersja typów (type coercion)
JavaScript automatycznie konwertuje typy podczas operacji, co czasem może prowadzić do nieoczekiwanych rezultatów - podobnie jak nieoczekiwane zachowanie hybrydowych dinozaurów w parku.
// Automatyczna konwersja na string
"Dinozaur " + 5; // "Dinozaur 5" (liczba 5 została skonwertowana na string)
// Automatyczna konwersja na number
"5" - 2; // 3 (string "5" został skonwertowany na liczbę)
"5" * 2; // 10 (string "5" został skonwertowany na liczbę)
// Automatyczna konwersja na boolean
if ("Dinozaur") {
// Ten kod się wykona, bo niepusty string jest traktowany jako true
}
if (0) {
// Ten kod się NIE wykona, bo 0 jest traktowane jako false
}Wartości falsy i truthy
W JavaScript każda wartość może być skonwertowana na boolean. Wartości automatycznie konwertowane na false nazywamy "falsy", a te konwertowane na true - "truthy".
Wartości falsy:
false0""(pusty string)nullundefinedNaN
Wszystkie inne wartości są truthy, w tym:
true- Każda liczba inna niż 0 (włącznie z ujemnymi i ułamkami)
- Każdy niepusty string
- Każdy obiekt, tablica i funkcja
// Przykłady konwersji na boolean
Boolean(0); // false
Boolean(""); // false
Boolean(null); // false
Boolean(undefined);// false
Boolean(NaN); // false
Boolean(1); // true
Boolean("text"); // true
Boolean([]); // true (pusta tablica jest truthy)
Boolean({}); // true (pusty obiekt jest truthy)Jawna konwersja typów
Aby uniknąć nieoczekiwanych rezultatów, zaleca się jawne konwertowanie typów - podobnie jak w Parku Jurajskim zawsze lepiej jest mieć pełną kontrolę nad dinozaurami:
// Konwersja na string
String(42); // "42"
(42).toString(); // "42"
42 + ""; // "42" (używa niejawnej konwersji)
// Konwersja na number
Number("42"); // 42
parseInt("42", 10); // 42 (druga liczba to system liczbowy, np. 10 dla dziesiętnego)
parseFloat("42.5"); // 42.5
+"42"; // 42 (używa niejawnej konwersji)
// Konwersja na boolean
Boolean(1); // true
Boolean(0); // false
!!"wartość"; // true (podwójna negacja)Bezpieczne sprawdzanie typów
W rzeczywistych aplikacjach, podobnie jak w protokołach bezpieczeństwa parku, warto stosować rygorystyczne sprawdzanie typów:
// Sprawdzanie, czy zmienna jest stringiem
function isString(value) {
return typeof value === 'string' || value instanceof String;
}
// Sprawdzanie, czy zmienna jest liczbą (z dodatkowym sprawdzeniem NaN)
function isNumber(value) {
return typeof value === 'number' && !isNaN(value);
}
// Sprawdzanie, czy zmienna jest boolean
function isBoolean(value) {
return typeof value === 'boolean';
}
// Sprawdzanie, czy zmienna ma wartość null
function isNull(value) {
return value === null;
}
// Sprawdzanie, czy zmienna ma wartość undefined
function isUndefined(value) {
return typeof value === 'undefined';
}Praktyczny przykład: System inwentaryzacji dinozaurów
Poniższy przykład ilustruje użycie różnych typów danych w kompleksowym systemie:
// Stałe konfiguracyjne
const PARK_NAME = "Jurassic Park";
const MAX_CAPACITY = 50;
const SECURITY_LEVELS = {
LOW: 1,
MEDIUM: 2,
HIGH: 3,
CRITICAL: 4
};
// System inwentaryzacji dinozaurów
function processDinosaurData(dinoId, name, species, height, isDangerous) {
// Sprawdzenie typów danych
if (typeof dinoId !== 'number' || !Number.isInteger(dinoId) || dinoId <= 0) {
return "Błąd: Nieprawidłowy ID dinozaura";
}
if (typeof name !== 'string' || name.trim() === '') {
return "Błąd: Nieprawidłowa nazwa dinozaura";
}
if (typeof height !== 'number' || height <= 0) {
return "Błąd: Nieprawidłowa wysokość dinozaura";
}
if (typeof isDangerous !== 'boolean') {
return "Błąd: Parametr niebezpieczeństwa musi być typu boolean";
}
// Przetwarzanie danych
let securityLevel = null;
if (isDangerous) {
securityLevel = height > 3 ? SECURITY_LEVELS.CRITICAL : SECURITY_LEVELS.HIGH;
} else {
securityLevel = height > 5 ? SECURITY_LEVELS.MEDIUM : SECURITY_LEVELS.LOW;
}
// Przygotowanie raportu dinozaura
const dinoRecord = {
id: dinoId,
name: name,
species: species || "Nieznany", // Zabezpieczenie przed undefined
height: height,
dangerous: isDangerous,
securityLevel: securityLevel,
enclosureType: getEnclosureType(securityLevel),
lastUpdated: new Date().toISOString()
};
// Zwracamy raport
return dinoRecord;
}
// Funkcja pomocnicza
function getEnclosureType(securityLevel) {
switch(securityLevel) {
case SECURITY_LEVELS.LOW:
return "Otwarty wybieg";
case SECURITY_LEVELS.MEDIUM:
return "Standardowe ogrodzenie";
case SECURITY_LEVELS.HIGH:
return "Wzmocnione ogrodzenie z monitoringiem";
case SECURITY_LEVELS.CRITICAL:
return "Izolowana zagroda wysokiego bezpieczeństwa";
default:
return "Nieokreślony";
}
}
// Przykład użycia
const trexData = processDinosaurData(
1,
"Rexy",
"Tyrannosaurus Rex",
5.6,
true
);
console.log(trexData);Podsumowanie
String - reprezentuje tekst
- Jak tabliczki informacyjne w parku
- Ujęty w
',"lub` - Posiada wiele wbudowanych metod (np.
toUpperCase(),indexOf())
Number - reprezentuje liczby całkowite i zmiennoprzecinkowe
- Jak system numeryczny w parku
- Obsługuje wszystkie standardowe operacje matematyczne
- Należy uważać na precyzję liczb zmiennoprzecinkowych
Boolean - wartości logiczne
truelubfalse- Jak system alarmowy (włączony/wyłączony)
- Podstawa dla podejmowania decyzji (instrukcje warunkowe)
- Powstaje też w wyniku operacji porównania
null - celowy brak wartości
- Jak pusta, przygotowana zagroda
- Ustawiana jawnie przez programistę
- Reprezentuje "nic" lub "nieznane"
undefined - niezdefiniowana wartość
- Jak nieprzydzielone jeszcze miejsce w parku
- Pojawia się automatycznie dla niezainicjalizowanych zmiennych
- Również jako domyślny wynik funkcji bez
return
Zrozumienie typów danych w JavaScript jest fundamentem skutecznego programowania - podobnie jak znajomość różnych gatunków dinozaurów jest kluczowa dla pracowników Parku Jurajskiego. Każdy typ ma swoje zastosowania, ograniczenia i zachowania, które trzeba znać, aby uniknąć nieoczekiwanych "incydentów" w kodzie!
W następnej lekcji omówimy konwersję typów i operacje na typach danych - to jak nauczyć się bezpiecznej i efektywnej pracy z różnymi gatunkami dinozaurów w parku.
Kod do tej lekcji: index.js
// System Diagnostyczny - Funkcje
// Ćwiczenie: Tworzenie i wywoływanie funkcji
// Deklaracja funkcji
function checkDinosaur(name, health) {
console.log("Badanie: " + name);
if (health > 80) {
return name + " - stan: DOSKONAŁY";
} else if (health > 50) {
return name + " - stan: DOBRY";
} else {
return name + " - stan: WYMAGA OPIEKI";
}
}
// Wywołanie funkcji
console.log(checkDinosaur("T-Rex", 95));
console.log(checkDinosaur("Raptor", 72));
console.log(checkDinosaur("Brachio", 45));
// Funkcja z wartością domyślną
function feedDinosaur(name, amount = 50) {
console.log(name + " nakarmiony: " + amount + " kg");
}
feedDinosaur("T-Rex", 200);
feedDinosaur("Compy"); // użyje domyślnej wartości 50
// Twoje zadanie:
// 1. Stwórz funkcję calculateAge(birthYear) obliczającą wiek
// 2. Stwórz funkcję z parametrem domyślnym
// 3. Wywołaj je z różnymi argumentami
// Twój kod tutaj:
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. Jakie wartości może przyjmować typ boolean w JavaScript?
2. Co zwróci typeof 42 w JavaScript?
Zadania praktyczne w grze
- Edytor kodu
Zadeklaruj trzy zmienne opisujące próbkę DNA: nazwę gatunku (string), wagę w kilogramach (number) i to, czy dinozaur jest mięsożercą (boolean). Wyświetl w konsoli każdą zmienną razem z jej typem, używając typeof.