Kurs JS #2 – Podstawy JavaScript – zmienne i stałe to kolejny artykuł – z serii poświęconej JSowi. W niniejszym artykule temat zmiennych i stałych
Podstawy JavaScript: Zmienne i stałe
JavaScript, jako jeden z najpopularniejszych języków programowania, oferuje programistom różne sposoby przechowywania i manipulowania danymi. Kluczowym elementem tego procesu są zmienne i stałe. W tym artykule omówimy podstawowe koncepcje związane z tymi elementami, skupiając się na ich deklaracji, nazewnictwie i różnicach między nimi.
Czym są zmienne i stałe?
Zmienne i stałe to fundamentalne koncepcje w programowaniu, służące do przechowywania danych w pamięci komputera.
Zmienne
Zmienne to kontenery na dane, których wartość może się zmieniać w trakcie wykonywania programu. Można je porównać do pudełek, w których przechowujemy różne przedmioty i możemy je w dowolnym momencie wymienić.
Stałe
Stałe, podobnie jak zmienne, przechowują dane, ale ich wartość nie może być zmieniona po inicjalizacji. Są jak zaplombowane pudełka, których zawartości nie możemy zmienić po ich zamknięciu.
Jak deklarować zmienne?
W JavaScript mamy trzy sposoby deklarowania zmiennych i stałych:
1. var
var name = "John";
`var` to najstarszy sposób deklarowania zmiennych w JavaScript. Zmienne zadeklarowane za pomocą `var` mają zasięg funkcyjny lub globalny.
2. let
let age = 25;
`let` wprowadzono w ES6 (ECMAScript 2015). Zmienne zadeklarowane za pomocą `let` mają zasięg blokowy.
3. const
const PI = 3.14159;
`const` również wprowadzono w ES6. Służy do deklarowania stałych, których wartość nie może być zmieniona po inicjalizacji.
Zasady nazewnictwa zmiennych
Prawidłowe nazewnictwo zmiennych jest kluczowe dla czytelności i utrzymania kodu. Oto kilka zasad:
1. Nazwy powinny być opisowe i odzwierciedlać przeznaczenie zmiennej.
2. Używaj camelCase dla nazw zmiennych (np. `firstName`, `lastLoginDate`).
3. Nazwy mogą zawierać litery, cyfry, znaki dolara ($) i podkreślenia (_).
4. Nazwa nie może zaczynać się od cyfry.
5. Unikaj używania słów kluczowych JavaScript jako nazw zmiennych.
6. Nazwy są case-sensitive (rozróżniają wielkość liter).
Różnice między var, let i const
Zrozumienie różnic między `var`, `let` i `const` jest kluczowe dla efektywnego programowania w JavaScript:
var
– Ma zasięg funkcyjny lub globalny.
– Może być redeklarowana w tym samym zasięgu.
– Podlega hoistingowi (wynoszeniu deklaracji na początek zasięgu).
let
– Ma zasięg blokowy.
– Nie może być redeklarowana w tym samym zasięgu.
– Nie podlega hoistingowi w taki sam sposób jak `var`.
const
– Ma zasięg blokowy.
– Musi być zainicjalizowana przy deklaracji.
– Nie może być redeklarowana ani ponownie przypisana.
– Dla obiektów i tablic, `const` zapobiega ponownemu przypisaniu referencji, ale nie modyfikacji zawartości.
Przykłady z const
// Podstawowe użycie const const PI = 3.14159; const DAYS_IN_WEEK = 7;
// Const z obiektami
const person = {
name: "Alice",
age: 30
};
person.age = 31; // To jest dozwolone
// person = {} // To wywoła błąd
// Const z tablicami
const fruits = ["apple", "banana", "orange"];
fruits.push("grape"); // To jest dozwolone
// fruits = ["pear", "mango"]; // To wywoła błąd
Przykłady z let
// Podstawowe użycie let let count = 0; count = count + 1; // Zmiana wartości jest dozwolona
// Let w pętlach
for (let i = 0; i < 5; i++) {
console.log(i);
}
// console.log(i); // To wywoła błąd, i nie jest dostępne poza pętlą
// Let w blokach
if (true) {
let blockScoped = "I'm only available in this block";
}
// console.log(blockScoped); // To wywoła błąd
Przykłady z var
// Podstawowe użycie var var name = "John"; var age = 25;
// Var i hoisting console.log(hoistedVar); // Wyświetli undefined var hoistedVar = "I'm hoisted";
// Var w funkcjach
function exampleFunction() {
var functionScoped = "I'm function scoped";
}
// console.log(functionScoped); // To wywoła błąd
// Var i problem z zasięgiem blokowym
for (var i = 0; i < 5; i++) {
// kod
}
console.log(i); // i jest dostępne poza pętlą, co może być niechciane
Korzystanie z var
Używanie `var` w nowoczesnym JavaScript jest generalnie odradzane z kilku powodów:
1. **Problemy z zasięgiem**: `var` ma zasięg funkcyjny, a nie blokowy, co może prowadzić do nieoczekiwanych zachowań i błędów.
2. **Hoisting**: Deklaracje `var` są „wynoszone” na początek ich zasięgu, co może być mylące i prowadzić do błędów.
3. **Możliwość przypadkowego nadpisania**: `var` pozwala na ponowną deklarację tej samej zmiennej w tym samym zasięgu, co może prowadzić do niezamierzonych nadpisań.
4. **Brak wsparcia dla nowoczesnych praktyk**: `let` i `const` lepiej wspierają nowoczesne praktyki programistyczne, takie jak programowanie funkcyjne i immutability.
Kiedy można rozważyć użycie var:
1. **Kompatybilność wsteczna**: Jeśli tworzysz kod, który musi działać w bardzo starych przeglądarkach lub środowiskach.
2. **Praca ze starszym kodem**: Gdy pracujesz z istniejącym, starszym kodem, który intensywnie wykorzystuje `var`.
3. **Specyficzne przypadki użycia**: W rzadkich sytuacjach, gdzie potrzebujesz zasięgu funkcyjnego i hoistingu.
Zalecane podejście:
W nowoczesnym rozwoju JavaScript zaleca się:
1. Używaj `const` jako domyślnego wyboru dla zmiennych, których wartość nie będzie się zmieniać.
2. Używaj `let` dla zmiennych, których wartość może się zmieniać.
3. Unikaj `var`, chyba że masz konkretny powód, aby go użyć.
Podsumowanie
Artykuł Kurs JS #2 – Podstawy JavaScript – zmienne i stałe ma Was zachęcić do rozwoju w zakresie JSa. Zrozumienie zmiennych i stałych jest fundamentalne dla każdego programisty JavaScript. Właściwe ich wykorzystanie pozwala na tworzenie bardziej czytelnego, wydajnego i bezpiecznego kodu. Pamiętaj, że wybór między `var`, `let` i `const` zależy od konkretnego przypadku użycia i kontekstu w twoim programie. W nowoczesnym JavaScript, `let` i `const` są preferowanymi sposobami deklarowania zmiennych, oferując lepszą kontrolę nad zasięgiem i mutowalnością danych.
