W JavaScript istnieją trzy zakresy: globalny, zakres funkcji i zakres blokowy. Zmienny zakres- to jest obszar kod źródłowy program, w którym zmienne i funkcje są widoczne i mogą być używane. Zakres globalny jest również nazywany kodem najwyższego poziomu.
Zmienne globalne
Zmienna zadeklarowana poza funkcją lub blokiem nazywana jest zmienną globalną. Zmienna globalna jest dostępna w dowolnym miejscu w kodzie źródłowym:
varnum = 5; funkcja foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 ( konsola. log(num); // 5 )
Zmienne lokalne
Zmienna zadeklarowana w funkcji nazywana jest zmienną lokalną. Zmienna lokalna jest dostępna w dowolnym miejscu w treści funkcji, w której została zadeklarowana. Zmienna lokalna jest tworzona za każdym razem, gdy nowa funkcja jest wywoływana i niszczona po jej zakończeniu (po zakończeniu funkcji):
Funkcja foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typliczba); // nieokreślony
Zmienna lokalna ma pierwszeństwo przed zmienną globalną o tej samej nazwie, co oznacza, że zmienna lokalna będzie używana wewnątrz funkcji, a nie globalna:
zmienna x = "globalna"; // Funkcja zmiennej globalnej checkscope() ( var x = "local"; // Zmienna lokalna o tej samej nazwie co global document.write(x); // Używana jest zmienna lokalna, a nie globalna ) checkscope(); // => "lokalny" Wypróbuj »
Zmienne blokowe
Zmienna zadeklarowana wewnątrz bloku z słowo kluczowe let , nazywa się blokiem . Zmienna blokowa jest dostępna w dowolnym miejscu bloku, w którym została zadeklarowana:
letnum = 0; ( let num = 5; console.log(num); // 5 ( let num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0
Ponowne ogłoszenie
Jeśli ponownie zadeklarujesz zmienną o tej samej nazwie (w tym samym zakresie) za pomocą słowa kluczowego var, nic się nie stanie:
Wara = 10; var a; dziennik konsoli(a); // dziesięć
Jeżeli po ponownej deklaracji następuje inicjalizacja, to taka instrukcja zachowuje się jak normalne przypisanie nowej wartości:
Wara = 10; zm a = 5; // To samo co a = 5; dziennik konsoli(a); // 5
Jeśli ponownie zadeklarujesz zmienną o tej samej nazwie (w tym samym zakresie) za pomocą słowa kluczowego let, zostanie zgłoszony błąd:
Wara = 10; niech; // Błąd.
Łańcuch lunet
Rozważmy następujący przykład:
varnum = 5; funkcja foo() ( var num2 = 10; funkcja bar() ( var num3 = 15; ) )
W tym kodzie istnieją trzy zakresy: zakres globalny, zakres funkcji foo() i zakres funkcji bar(). Zmienna num i funkcja foo() są zdefiniowane w zasięgu globalnym. Zmienna num2 i funkcja bar() są zdefiniowane w zakresie funkcji foo(), a zmienna num z zakresu globalnego jest w nim również dostępna. Zakres funkcji bar() zawiera jedną zmienną num3 , która jest dostępna tylko wewnątrz funkcji bar(). W zakresie funkcji bar() dostępne są również zmienne z pozostałych dwóch zakresów, ponieważ są one jej rodzicami. Łańcuch zasięgu dla tego przykładu pokazano na poniższym rysunku:
Na rysunku różne zakresy są pokazane z prostokątami o różnych kolorach. Zakres wewnętrzny w łańcuchu zakresów może uzyskać dostęp do wszystkiego z zakresów zewnętrznych, ale zakresy zewnętrzne nie mogą uzyskać dostępu do niczego z zakresów wewnętrznych.
Łańcuch zasięgu jest uporządkowany. Interpreter przeszukuje łańcuch zasięgu w poszukiwaniu identyfikatorów na zewnątrz, a nie do wewnątrz. Oznacza to, że wyszukiwanie nazwy rozpoczyna się w zakresie, w którym uzyskano dostęp do identyfikatora. Jeśli nazwa identyfikatora zostanie znaleziona, wyszukiwanie zostanie zakończone. Jeśli nazwy nie można znaleźć w bieżącym zakresie, wyszukiwanie zostanie przeprowadzone w następnym (zewnętrznym) zakresie itd. W ten sposób zostanie użyty identyfikator z zakresu, w którym została znaleziona. Jeśli identyfikator nie zostanie znaleziony w żadnym z zakresów, JavaScript wygeneruje błąd:
var str = "globalny"; varnum = 5; function foo() ( var str = "local"; // Użyj zmiennej lokalnej str num = 10; // Użyj zmiennej globalnej num // alert(x); // Błąd. Zmienna x nie znajduje się w żadnym zasięgu ) foo( ) ; alert(str); // "globalny" alert(num); // dziesięć
Jeśli przypiszesz wartość do niezadeklarowanej zmiennej w treści funkcji, to w momencie wywołania funkcji, jeśli w zasięgu globalnym nie ma zmiennej o tej samej nazwie, zostanie utworzona nowa zmienna globalna:
Funkcja foo() ( liczba = 2; ) foo(); // Utworzono nową zmienną globalną num alert(num); // 2
Wzrost reklam
W JavaScript zadeklarowane zmienne są dostępne w dowolnym miejscu względem ich zakresu, co oznacza, że zmienne są widoczne jeszcze przed ich zadeklarowaniem w kodzie. Ta funkcja JavaScript jest nieformalnie nazywana podnoszeniem: kod programowania zachowuje się tak, jakby deklaracje zmiennych były niejawnie podnoszone (bez inicjalizacji) na sam szczyt ich zakresu.
Rozważ następujący fragment kodu:
var str = "globalny"; function foo() ( alert(str); // niezdefiniowana var str = "lokalny"; alert(str); // "lokalny" ) foo();
Patrząc na kod, można by pomyśleć, że pierwszy alert powinien wypisać ciąg „global”, ponieważ deklaracja zmiennej lokalnej str nie została jeszcze wykonana. Jednak rzeczywista moc wyjściowa jest niezdefiniowana. Dzięki podniesieniu deklaracji powyższa funkcja jest równoważna poniższej implementacji, w której deklaracja zmiennej jest podnoszona na szczyt funkcji:
Function foo() ( var str; // Deklaracja zmiennej lokalnej na początku funkcji alert(str); // Tutaj jest dostępna, ale nie została zainicjowana str = "local"; // Tutaj jest zainicjowana alert( str); // A tutaj ma wartość oczekiwaną - "local")
To samo dotyczy zasięgu globalnego, zmienna zadeklarowana na dole jest dostępna na górze:
Alert(liczba); // niezdefiniowana var num = 10; alert(liczba); // dziesięć
Czym są zmienne globalne: zmienne są „widoczne” w dowolnym momencie wykonywania programu, z dowolnego miejsca można je odczytać i nadpisać.Zwykle zmienne globalne są definiowane na samym początku programu, poza jakimikolwiek blokami (())
w przypadku Js są ustawiane po skrypcie lub wszystkich funkcjach
cześć = Witaj ; //ustaw zmienną globalną i sprawdź ją
dokument. napisane (->1 + cześć + każdy)
); //->1 Witam wszystkich
Jeśli prawda)
//jeśli(fałsz)
{
var hello = Witaj Dolly i ; //to też jest globalne
świat = świat; //światowy
var cont = , kontynuujemy //global
dokument. napisane (->1,2 + cześć + świat + cd +
);
//1.2 Witaj Dolly i świecie, kontynuujemy
}
dokument. napisane (->2 + cześć + świat + cd +
);
//->2 Witaj Dolly i świecie, kontynuujemy
jeśli to prawda, otrzymujemy odpowiedź
->1 Witam wszystkich
->1.2 Witaj Dolly i świecie, kontynuujemy
->2 Witaj Dolly i świecie, kontynuujemy
przerwy w realizacji
Okazuje się więc, że użycie var nie wpływa w żaden sposób na zasięg globalny. Zmienna wspomniana w skrypcie poza procedurami jest uważana za globalną, nawet jeśli jest umieszczona w nawiasach () wokół if while dla bloków i innych zakresów pozostanie globalna nawet wewnątrz pętli
Podsumowanie, w skrócie
- dla zmiennych używanych w zasięgu globalnym obecność var nie jest istotna.
- Bloki po if while for nie tworzą lokalnego zakresu (tak jak w innych językach)
chłopiec = Jan;
zrobił = zabija Kenny'ego ; //więc mamy 2 zmienne globalne
funkcja doit()
{
//print już minął -1, a my zmieniamy dane zmieniamy dane
var chłopiec = Gary ; // utwórz lokalizację
zrobił = pomóż Annie ; // zmień globalny
;
dokument. napisane (--2 + chłopiec + + zrobił +
);
//--2 Gary pomaga Annie
;
//teraz wewnątrz funkcji ustawiamy zmienne lokalne i globalne
var dobry = był dobrym chłopcem
; //widownia!
zły = lubi złe dziewczyny
; //światowy
}
;
dokument. napisane(--1+chłopiec++zrobił+
);
//--1 Jhone zabija Kenny'ego
Zrób to();
//--2 Gary pomaga Annie
dokument. napisane (--3 + chłopiec + + zrobił +
);
//--3 Jhone pomaga Annie
;
Jeśli prawda)
//jeśli(!fałsz)
{
dokument. napisane (--4 + dobry );
//wykonanie tego bloku zgłosi błąd.
//jesteśmy poza zasięgiem lokalnym
// funkcje doit(), więc dla nas jest ona podana przez var
//zmienna dobro po prostu nie istnieje
}
dokument. napisane (--5 + zły );
//--5 lubi złe dziewczyny
Wynik:
1 Jhone zabija Kenny
-2 Gary pomaga Annie
-3 Jhone pomaga Annie
---5 lubi złe dziewczyny
Wniosek
zmienne lokalne w javascript
- var działa wewnątrz funkcji, deklarując zmienną lokalną. To jest jego główne zadanie.
- JavaScript bardzo różni się od C już tym, że tylko (?) Lokalne zmienne są możliwe wewnątrz funkcji.
- używanie var lub nie używanie w zasięgu globalnym zależy tylko od twojego osobiste doświadczenie. Ale dla mnie lepiej nie być leniwym. w perlu nazywa się to use strict
Ważny. Po pierwsze, vars nie można usunąć (za pomocą usuwania). Po drugie, ich instancja odbywa się na „linii zerowej” (przed pracą „linijka po linii”), gdzie od razu przypisywana jest im wartość undefined i dopiero wtedy zmienna może (lub nie) otrzymać nową wartość:
zmienna glb_1 = 1;
if (false) (var glb_2 = 2; glb_3 = 3;)
alert(glb_1) // utworzona i ustawiona na 1
alert(glb_2) // utworzona i ustawiona na 'undefined'
alert(glb_3) // brak zmiennej (brak var), błąd wywołania
Dzień dobry, fani JavaScript i moi wierni subskrybenci. W dzisiejszym poście opowiem szczegółowo o tym, jak tworzone są zmienne globalne i lokalne w JavaScript. Na pewno podam definicje ważnych pojęć, opowiem o cechach deklarowania i inicjalizacji zmiennych, opiszę czym jest zakres i jak funkcjonują w nim tworzone elementy.
Wszystko to dotyczy najbardziej podstawowej, podstawowej znajomości języka. Bez zrozumienia tego wszystkiego nie będziesz w stanie przejść dalej i rozwijać swoich umiejętności programowania w js. Ponadto kluczowe pojęcia przydadzą Ci się nie tylko w tej specjalizacji, ale także ogólnie w dziedzinie IT. Cóż, zaczynajmy!
Co to jest zmienna i jak jest tworzona?
Zmienna to taki element języka programowania, pod którym alokowany jest obszar pamięci i w którym przechowywane są określone wartości.
Zmienne mogą być duża ilość i wszystkie muszą mieć unikalną nazwę.
Istnieją dwa rodzaje zmiennych: globalne i lokalne. Ich różnica polega tylko na tym, że inny obszar widoczność zmiennych. Tak więc elementy globalne są widoczne w całym kodzie, a elementy lokalne są widoczne tylko na niewielkim obszarze, w którym zostały zadeklarowane.
Nawiasem mówiąc, spróbuj od pierwszego dnia, od pierwszego kodu, nazwać elementy logicznym i zrozumiałymi nazwami. Bo dalej, gdy pracujesz z ważkimi programami, po pewnym czasie nie będziesz pamiętał, co oznacza na przykład „aa1” lub „perem3”.
A tytuł nie ma żadnego sensu! W końcu jest jeszcze połowa kłopotów, nie jest tak trudno zrozumieć twoje pisma. A co zrobisz, jeśli otrzymasz zadanie dokończenia zadań w innym programie, o którym wcześniej nawet nie słyszałeś? Z takimi nazwami, parsowanie wdrażanie oprogramowania zabija dużo dobrego czasu.
Odczytałem zapis, teraz wróćmy do deklaracji zmiennych.
Aby utworzyć zmienną, musisz najpierw wpisać słowo kluczowe var, po którym następuje sama nazwa. Tak to wygląda:
var text = "Witaj, użytkowniku!"
Następnie tekst jest dostępny bez „var”:
text = "nowy tekst."
W takim przypadku wartość zostanie nadpisana.
Dla lepszego zrozumienia rozważmy przykład, który tworzy pojedynczą zmienną. Będziemy odnosić się do jego wartości przed i po przepisaniu.
| 1 2 3 4 | var text = "Witaj, użytkowniku!"; alert(tekst); // wyświetla "Witaj, użytkowniku!" text="Nowy tekst!"; alert(tekst); // wyświetla "Nowy tekst!" |
var text = "Witaj, użytkowniku!"; alert(tekst); // wyświetla "Witaj, użytkowniku!" text="Nowy tekst!"; alert(tekst); // wyświetla "Nowy tekst!"
Cechy obiektów globalnych
Wszystkie tworzone obiekty w kodzie js są podzielone na globalne i lokalne. Powyżej wyjaśniłem, jaka jest między nimi różnica. Przyjrzyjmy się teraz bliżej obiektom globalnym.
Są to wszystkie funkcje i zmienne, które są zadeklarowane na głównej kanwie kodu, tj. nie w niektórych funkcjach. Wszystkie w js automatycznie stają się właściwościami obiektu globalnego, który jest jawnie dostępny w przeglądarkach pod oknem słowa. Rozważ przykład.
var cena = 145; // utwórz zmienną globalną
alert(okno.cena); // odpowiedź: 145
Jak dotąd wszystko jest proste, ale przygotuj się na pułapki. Czasami, nie znając specyfiki zapisywania i przepisywania wartości zmiennych, można nadpisać bardzo ważne parametry. Takie błędy są dość trudne do wyśledzenia i niemożliwe do znalezienia za pomocą kompilatorów. Dlatego dokładnie przeanalizuj poniższy materiał.
Pułapki i zakres
Aby lepiej zrozumieć problem, najpierw pokażę mały program, gdzie w funkcji utworzę zmienną lokalną, a poza jej granicami zmienną globalną.
test funkcji() ( p = 2; powrót p; ) alert(p); // undefined p = "ważny tekst"; alert(p); // wyświetla "ważny tekst" test(); // wywołaj funkcję alert(p); // drukuje 2
Początkowo w funkcji testowej zainicjowałem zmienną lokalną o wartości 2, a następnie utworzyłem globalną zmienną tekstową, która przechowuje kilka ważnych danych.
I tu wyskakuje ten „podwodny blok”.
Po pierwsze, ze względu na to, że wykorzystałem tworzenie elementów zgodnie z zasadami przestarzałego standardu JavaScript, wszystkie zmienne „p” powstały dopiero w momencie przypisania (przy użyciu dyrektywy var od razu tworzone są zmienne z wartością niezdefiniowane, a podczas inicjalizacji poprzez „= » wartość jest nadpisywana).
Po drugie, w tym przypadku js używa istniejącej lub tworzy nową zmienną globalną, aby przypisać wartość do niejawnie utworzonych elementów. Dlatego w powyższym przykładzie po wywołaniu funkcji test nadpisano wartość globalnego „p”.
Zawsze używaj słowa kluczowego var, aby uniknąć awarii. Następnie wszystkie obiekty zostaną zadeklarowane jawnie i zostaną utworzone nowe.
Oto poprawiony przykład:
test funkcji() ( var p = 2; alert (p); powrót p; ) alert(p); // undefined var p = "ważny tekst"; alert(p); // wyświetla "ważny tekst" test(); // wywołaj funkcję, w tym przypadku wypisze 2 alert(p); // drukuj "ważny tekst"
Teraz kod działa poprawnie. Jak widać, zakres lokalnego „p” mieści się w zakresie funkcji test, podczas gdy zakres globalnego znajduje się w pozostałej części kodu.
Kilka słów o stałych
Podobnie jak wszystkie inne języki programowania, JavaScript ma stałe. Dla tych, którzy nie wiedzą, co to jest, dołączę definicję.
Stała to rodzaj zmiennej, której wartość się nie zmienia.
Zgodnie z zasadami składni w js, ich nazwa jest zawsze pisana małymi (dużymi) literami. Na przykład,
var MAIN_COLOR = "#fff"
Nie w języku skryptowym środki techniczne, co uczyniłoby stałą naprawdę stałą. W rzeczywistości są to zwykłe zmienne, które można nadpisać. Jednak zgodnie z zasadami programiści używają tych elementów z wielkie litery w nazwie jako stałe oraz w trakcie pisania kodu nie zmieniaj ich wartości.
Głównym celem stałych jest przechowywanie złożonych ciągów, ważnych liczb lub innych wartości, w których po przepisaniu łatwo jest popełnić literówkę lub w żadnym wypadku nie należy jej zmieniać, lub uprościć kod. Na przykład stałe mogą przechowywać często powtarzające się żądania
Zmienne służą jako „pojemniki” do przechowywania informacji.
Czy pamiętasz algebrę szkolną?
Pamiętasz algebrę szkolną? x=5, y=6, z=x+y
Czy pamiętasz, że litera (np. x) może służyć do przechowywania wartości (np. 5) i że możesz użyć powyższych informacji, aby obliczyć, że wartość z wynosi 11?
Te litery nazywają się zmienne, a zmienne mogą służyć do przechowywania wartości (x=5) lub wyrażeń (z=x+y).
Zmienne JavaScript
Tak jak w algebrze Zmienne JavaScript służą do przechowywania wartości lub wyrażeń.
Zmienna może mieć krótką nazwę, np. x, lub bardziej opisową, np. carname (nazwa samochodu).
Zasady dotyczące nazw zmiennych JavaScript:
- W nazwach zmiennych rozróżniana jest wielkość liter (y i Y to dwie różne zmienne)
- Nazwy zmiennych muszą zaczynać się od litery lub podkreślenia
Komentarz: Ponieważ JavaScript rozróżnia wielkość liter, nazwy zmiennych również rozróżniają wielkość liter.
Przykład
Wartość zmiennej może ulec zmianie podczas wykonywania skryptu. Możesz odwoływać się do zmiennej poprzez jej nazwę, aby wyświetlić lub zmienić jej wartość.
Deklarowanie (tworzenie) zmiennych JavaScript
Tworzenie zmiennych w JavaScript jest częściej określane jako „deklarowanie” zmiennych.
Deklarujesz zmienne JavaScript za pomocą słowa kluczowego var:
Po wykonaniu powyższych sugestii zmienna x będzie zawierać wartość 5 , oraz nazwa samochodu będzie zawierać wartość Mercedes.
Komentarz: Kiedy przypiszesz wartość tekstowa zmienna, umieść ją w cudzysłowie.
Komentarz: Jeśli ponownie zadeklarujesz zmienną, nie straci ona swojej wartości.
Zmienne lokalne JavaScript
Zmienna zadeklarowana wewnątrz Funkcje JavaScript staje się LOKALNY i będą dostępne tylko w ramach tej funkcji. (zmienna ma zasięg lokalny).
Zmienne lokalne o tej samej nazwie można zadeklarować w różnych funkcjach, ponieważ zmienne lokalne są rozpoznawane w funkcji, w której są zadeklarowane.
Zmienne lokalne są niszczone po zakończeniu działania funkcji.
Więcej o funkcjach dowiesz się w późniejszych lekcjach JavaScript.
Zmienne globalne JavaScript
Zmienne zadeklarowane poza funkcją stają się ŚWIATOWY, a wszystkie skrypty i funkcje na stronie mają do nich dostęp.
Zmienne globalne są niszczone po zamknięciu strony.
Jeśli zadeklarujesz zmienną bez użycia "var", zmienna zawsze stanie się ŚWIATOWY.
Przypisywanie wartości niezadeklarowanym zmiennym JavaScript
Jeśli przypiszesz wartości do zmiennych, które nie zostały jeszcze zadeklarowane, zmienne zostaną automatycznie zadeklarowane jako zmienne globalne.
Te sugestie:
Więcej o operatorach dowiesz się w następnej lekcji JavaScript.
Zmienne i stałe w JavaScript. Deklarowanie zmiennych i przypisywanie im wartości. Zmienne globalne i lokalne. Korzystanie ze stałych.
Deklarowanie zmiennych w JavaScript
Nazwy zmiennych w JavaScript mogą składać się z liter, cyfr, znaku $ i znaku _, a nazwa zmiennej nie może zaczynać się od cyfry. Pamiętaj, że JavaScript rozróżnia wielkość liter, a a1 i A1 to różne zmienne. Cyrylica nie jest zalecana, chociaż jest to możliwe.
Zmienne w JavaScript są deklarowane za pomocą słowa kluczowego var:
Var Peremennaya_1 var Peremennaya_2
Używanie zmiennych w JavaScript bez deklaracji nie jest zalecane. Jest to możliwe, ale może prowadzić do błędów.
Przypisywanie wartości do zmiennych
Przypisywanie wartości do zadeklarowanych zmiennych w JavaScript:
Peremennaya_1 = 25 Peremennaya_2 = "Przypisany tekst jest ujęty w cudzysłowy"
Możesz przypisać wartość do zmiennych natychmiast po deklaracji:
Var Peremennaya_1 = 25 var Peremennaya_2 = "Przypisany tekst umieszczamy w prostych cudzysłowach"
Wartość zmiennej w JavaScript może się zmieniać podczas wykonywania programu. Pisząc tekst do zmiennej, musi on być ujęty w proste cudzysłowy.
Zmienne lokalne i globalne
Jeśli zmienna jest zadeklarowana w funkcji, to jest lokalny i będą dostępne (widoczne) tylko w ramach tej funkcji. Kiedy funkcja kończy działanie, lokalne zmienne w JavaScript są niszczone, więc możesz używać zmiennych o tej samej nazwie w różnych funkcjach.
Jeśli zmienna jest zadeklarowana poza funkcjami, to jest światowy i będą dostępne (widoczne) we wszystkich funkcjach na stronie. Zmienne globalne są niszczone w JavaScript po zamknięciu strony.
Stałe w JavaScript
Stałe mają na celu ułatwienie pracy z kodem, gdy musisz użyć powtarzających się wartości lub wyrażeń. Wystarczy raz ustawić wartość stałej i możesz jej używać do woli, wstawiając ją do kodu swoich programów. JavaScript nie ma słowa kluczowego do deklarowania stałych, zamiast stałych używane są zwykłe zmienne. Aby odróżnić stałe od zmiennych, zwyczajowo oznacza się je wielkimi literami, w razie potrzeby używając podkreślenia:
Var DRUG_CHELOVEKA = "Pies"
Podany przykład stałej nie jest do końca kompletny, ponieważ słowo „pies” jest już łatwe do zapamiętania i wstawienia tam, gdzie to konieczne. Możesz używać stałych w JavaScript do pisania i wklejania bardziej złożonych wartości, takich jak trudne do zapamiętania kody, zestawy znaków, długi tekst, adresy internetowe, adresy E-mail, numery telefoniczne, różne współczynniki.
W JavaScript stałe można przepisać jak zmienne, ale jeśli to zrobisz, znaczenie stałych zostanie utracone.