В JavaScript има три обхвата: глобален, функционален обхват и блоков обхват. Променлив обхват- това е района програмен кодпрограма, в която променливите и функциите са видими и могат да се използват. Глобалният обхват се нарича още код от най-високо ниво.
Глобални променливи
Променлива, декларирана извън функция или блок, се нарича глобална променлива. Глобалната променлива е достъпна навсякъде в изходния код:
varnum = 5; функция foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 (конзола. log(num); // 5)
Локални променливи
Променлива, декларирана във функция, се нарича локална променлива. Локална променлива е достъпна навсякъде в тялото на функцията, в която е декларирана. Локална променлива се създава всеки път, когато се извиква нова функция и се унищожава, когато излезе (когато функцията приключи):
Функция foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typeof num); // недефиниран
Локална променлива има предимство пред глобална променлива със същото име, което означава, че локалната променлива ще се използва във функцията, а не глобалната:
var x = "глобален"; // Глобална променлива функция checkscope() ( var x = "local"; // Локална променлива със същото име като глобалния document.write(x); // Използва се локална променлива, а не глобална) checkscope(); // => "местен" Опитайте »
Блокиране на променливи
Променлива, декларирана вътре в блок с ключова думанека, се нарича блок. Блокова променлива е достъпна навсякъде в блока, в който е декларирана:
letnum = 0; ( let num = 5; console.log(num); // 5 ( let num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0
Повторно обявяване
Ако декларирате отново променлива със същото име (в същия обхват), като използвате ключовата дума var, тогава нищо няма да се случи:
Вара = 10; var a; дневник на конзолата(a); // десет
Ако повторното деклариране е последвано от инициализация, тогава такава инструкция действа като нормално присвояване на нова стойност:
Вара = 10; var a = 5; // Същото като a = 5; дневник на конзолата(a); // 5
Ако декларирате отново променлива със същото име (в същия обхват), като използвате ключовата дума let, ще се появи грешка:
Вара = 10; нека а; // Грешка.
Верига от обхвати
Разгледайте следния пример:
varnum = 5; функция foo() ( var num2 = 10; функция bar() ( var num3 = 15; ) )
В този код има три обхвата: глобален обхват, обхват на функция foo() и обхват на функция bar(). Променливата num и функцията foo() са дефинирани в глобалния обхват. Променливата num2 и функцията bar() са дефинирани в обхвата на функцията foo(), а променливата num от глобалния обхват също е налична в нея. Обхватът на функцията bar() съдържа една променлива num3, която е достъпна само във функцията bar(). В обхвата на функцията bar() променливите от другите два обхвата също са достъпни, защото те са нейният родител. Веригата на обхвата за този пример е показана на фигурата по-долу:
На фигурата различни обхвати са показани с правоъгълници с различни цветове. Вътрешният обхват във веригата на обхвата може да има достъп до всичко от външните обхвати, но външните обхвати не могат да имат достъп до нищо от вътрешните обхвати.
Веригата на обхвата е подредена. Интерпретаторът търси във веригата на обхвата идентификатори навън, а не навътре. Това означава, че търсенето на име започва от обхвата, където е осъществен достъп до идентификатора. Ако името на идентификатора бъде намерено, търсенето се прекратява. Ако името не може да бъде намерено в текущия обхват, търсенето се извършва в следващия (външен) обхват и т. н. Така ще се използва идентификаторът от обхвата, в който е намерено. Ако идентификаторът не бъде намерен в нито един от обхватите, JavaScript ще генерира грешка:
var str = "глобален"; varnum = 5; функция foo() ( var str = "local"; // Използване на локална променлива str num = 10; // Използване на глобална променлива num // alert(x); // Грешка. Променливата x не е в никакъв обхват) foo() ; предупреждение (str); // "глобален" сигнал (брой); // десет
Ако присвоите стойност на недекларирана променлива в тялото на функцията, тогава по време на извикването на функцията, ако няма променлива със същото име в глобалния обхват, ще бъде създадена нова глобална променлива:
Функция foo() ( num = 2; ) foo(); // Създадена нова глобална променлива num alert(num); // 2
Лифт реклами
В JavaScript декларираните променливи са достъпни навсякъде спрямо техния обхват, което означава, че променливите са видими дори преди да бъдат декларирани в кода. Тази функция на JavaScript неофициално се нарича повдигане: програмен кодсе държи така, сякаш декларациите на променливи са имплицитно повдигнати (без инициализация) до самия връх на техния обхват.
Разгледайте следния кодов фрагмент:
var str = "глобален"; функция foo() ( alert(str); // undefined var str = "local"; alert(str); // "local" ) foo();
Разглеждайки кода, някой може да си помисли, че първото предупреждение трябва да изведе низа "global", тъй като декларацията на локалната променлива str все още не е изпълнена. Действителният резултат обаче е недефиниран. Благодарение на повдигането на декларацията, функцията по-горе е еквивалентна на реализацията по-долу, в която декларацията на променливата се издига в горната част на функцията:
Функция foo() ( var str; // Декларация на локална променлива в началото на функцията alert(str); // Тук е налична, но не е инициализирана str = "local"; // Тук е инициализирана alert( str); // И тук има очакваната стойност - "local")
Същото важи и за глобалния обхват, променливата, декларирана в долната част, е достъпна в горната част:
Сигнал (брой); // undefined var num = 10; предупреждение (брой); // десет
Какво представляват глобалните променливи: променливите са "видими" във всеки момент от изпълнението на програмата, навсякъде от където могат да бъдат прочетени и презаписани.Обикновено глобалните променливи се дефинират в самото начало на програмата, извън всички блокове (())
в случай на Js те се задават след скрипта или всички функции
здравей = Здравей ; // задайте глобална променлива и я проверете
документ. writeln (->1 + здравей + всеки
); //->1 Здравейте на всички
ако е вярно)
//ако(false)
{
var hello = Здравей Доли и ; //това също е глобално
свят = свят; //глобален
var cont = , продължаваме //global
документ. writeln (->1.2 + здравей + свят + прод. +
);
//1.2 Здравейте Доли и свят, продължаваме
}
документ. writeln (->2 + здравей + свят + прод. +
);
//->2 Здравейте Доли и свят, продължаваме
ако е вярно, получаваме отговора
->1 Здравейте на всички
->1.2 Здравейте Доли и свят, продължаваме
->2 Здравейте Доли и свят, продължаваме
прекъсвания на изпълнението
Така се оказва, че използването на var не влияе по никакъв начин на глобалния обхват. Променлива, спомената в скрипт извън процедурите, се счита за глобална дори ако е поставена в скоби () около if while за блок и други обхвати ще останат глобални дори вътре в цикли
Изводи, накратко
- за променливи, използвани в глобалния обхват, присъствието на var не е важно.
- Блоковете след if while for не създават локален обхват (както правят на други езици)
момче = Джон;
направи = убива Кени; //така че имаме 2 глобални променливи
функция doit()
{
//print вече е преминал --1 и ние променяме данните променяме данните
вар момче = Гари; // създаване на локал
направи = помогна на Ани; // промяна на глобалния
;
документ. writeln (--2 + момче + + направи +
);
//--2 Гари помага на Ани
;
//сега вътре във функцията задаваме локалните и глобалните променливи
var good = той беше добро момче
; // локал!
лошо = той харесва лоши момичета
; //глобален
}
;
документ. writeln(--1+момче++направи+
);
//--1 Джон убива Кени
направи го();
//--2 Гари помага на Ани
документ. writeln (--3 + момче + + направи +
);
//--3 Джон помага на Ани
;
ако е вярно)
//ако(!false)
{
документ. writeln (--4 + добро);
//изпълнението на този блок ще доведе до грешка.
//вече сме извън локалния обхват
// doit() функции, така че за нас се дава чрез var
//променлива good просто не съществува
}
документ. writeln (--5 + лошо);
//--5 той харесва лоши момичета
Резултат:
1 Джон убива Кени
--2 Гари помага на Ани
--3 Джон помага на Ани
--5 той харесва лоши момичета
Заключение
локални променливи в javascript
- var работи вътре във функция, като декларира локална променлива. Това е основната му задача.
- Javascript е много различен от C вече по това, че само (?) Локални променливи са възможни във функция.
- използването на var или неизползване в глобален обхват зависи само от вашия личен опит. Но за мен е по-добре да не мързелуваш. в perl се нарича use strict
важно. Първо, променливите не могат да бъдат изтрити (чрез delete). Второ, тяхното инстанциране се извършва на „нулевия ред“ (преди работата „ред по ред“), където веднага им се присвоява недефинирана стойност и едва тогава променливата може (или не може) да получи нова стойност:
променлива glb_1 = 1;
if (false) (var glb_2 = 2; glb_3 = 3;)
alert(glb_1) // инстанциран и зададен на 1
alert(glb_2) // инстанциран и зададен на 'undefined'
alert(glb_3) // изобщо не е променлива (няма var), грешка при повикване
Добър ден, фенове на JavaScript и мои верни абонати. В днешната публикация ще ви разкажа подробно как JavaScript глобалипроменливи и местни. Определено ще дам дефиниции на важни термини, ще говоря за характеристиките на декларирането и инициализирането на променливи, ще опиша какво е обхват и как функционират създадените елементи в него.
Всичко това важи за най-елементарните, основни познания по езика. Без да разберете всичко това, няма да можете да продължите напред и да развиете уменията си за програмиране в js. Освен това ключовите концепции ще ви бъдат полезни не само в тази специализация, но и като цяло в ИТ сферата. Е, да започваме!
Какво е променлива и как се създава?
Променливата е такъв елемент от езика за програмиране, под който се разпределя област от паметта и в която се съхраняват определени стойности.
Променливите могат да бъдат голяма сумаи всички те трябва да са с уникално име.
Има два вида променливи: глобални и локални. Разликата им е само в различна областвидимост на променливите. И така, глобалните елементи са видими в целия код, а локалните елементи са видими само в малка област, където са били декларирани.
Между другото, опитайте се още от първия ден, от първия си код, да назовавате елементите с логични и разбираеми имена. Защото по-нататък, когато работите с тежки програми, след известен период от време няма да си спомните какво означава например „aa1“ или „perem3“.
И заглавието няма абсолютно никакъв смисъл! Има още половината от проблемите, в крайна сметка не е толкова трудно да се разберат вашите писания. И какво ще направите, ако ви бъде дадена задача да завършите задачи в друга програма, за която дори не сте чували преди? С такива имена, разбор софтуерна реализацияубива много добро време.
Прочетох нотацията, сега да се върнем към декларацията на променливите.
За да създадете променлива, първо трябва да напишете ключова дума вар, последвано от самото име. Ето как изглежда:
var text = "Здравей, потребител!"
След това текстът се осъществява без "var":
text = "нов текст."
В този случай стойността ще бъде презаписана.
За по-добро разбиране разгледайте пример, който създава една променлива. Ще се позоваваме на неговата стойност преди и след пренаписване.
| 1 2 3 4 | var text = "Здравей, потребител!"; предупреждение (текст); // отпечатва "Hello, user!" text="Нов текст!"; предупреждение (текст); // отпечатва "Нов текст!" |
var text = "Здравей, потребител!"; предупреждение (текст); // отпечатва "Hello, user!" text="Нов текст!"; предупреждение (текст); // отпечатва "Нов текст!"
Характеристики на глобалните обекти
Всички създадени обекти в js кода са разделени на глобални и локални. По-горе обясних каква е разликата между тях. Сега нека разгледаме по-отблизо глобалните обекти.
Всички те са функции и променливи, които са декларирани в основното платно на кода, т.е. не в някои функции. Всички те в js автоматично стават свойства на глобалния обект, който е изрично достъпен в браузърите под думата window. Помислете за пример.
променлива цена = 145; // създаване на глобална променлива
предупреждение (window.price); // отговор: 145
Дотук всичко е просто, но се пригответе за клопките. Понякога, без да знаете особеностите на запазването и пренаписването на стойностите на променливите, можете да презапишете много важни параметри. Такива грешки са доста трудни за проследяване и невъзможно за намиране с помощта на компилатори. Затова внимателно анализирайте следния материал.
Клопки и обхват
За да разберем по-добре проблема, първо ще покажа малка програма, където ще създадем локална променлива във функцията, а след това извън нейните граници - глобална.
функция test() ( p = 2; връща p; ) alert(p); // undefined p = "важен текст"; предупреждение (p); // отпечатва "важен текст" test(); // извикване на функцията alert(p); // отпечатва 2
Първоначално в тестовата функция инициализирах локална променлива със стойност 2 и след това създадох глобална текстова променлива, която съхранява някои важни данни.
И тук изскача този „подводен блок“.
Първо, поради факта, че използвах създаването на елементи според правилата на остарелия стандарт на JavaScript, всички „p“ променливи бяха създадени само по време на присвояването (когато използвах директивата var, променливите се създават веднага със стойността недефиниран и по време на инициализация чрез „= » стойността се презаписва).
Второ, в този случай js използва съществуваща или създава нова глобална променлива, за да присвои стойност на неявно създадени елементи. Следователно, в горния пример, след извикване на тестовата функция, стойността на глобалното "p" беше презаписана.
Винаги използвайте ключовата дума var, за да избегнете срив. След това всички обекти ще бъдат декларирани изрично и ще бъдат създадени нови.
Ето коригирания пример:
функция test() ( var p = 2; alert (p); return p; ) alert(p); // undefined var p = "важен текст"; предупреждение (p); // отпечатва "важен текст" test(); // извикване на функцията, в този случай тя ще отпечата 2 alert(p); // печат "важен текст"
Сега кодът работи правилно. Както можете да видите, обхватът на локалното "p" е в обхвата на тестовата функция, докато обхватът на глобалния е в останалата част от кода.
Няколко думи за константите
Както всички други езици за програмиране, JavaScript има константи. За тези, които не знаят какво е това, ще приложа определение.
Константата е вид променлива, чиято стойност не се променя.
Според правилата на синтаксиса в js името им винаги се изписва с малки (главни) букви. Например,
var MAIN_COLOR = "#fff"
Не на скриптов език технически средства, което би направило константата наистина постоянна. Всъщност те са обикновени променливи, които могат да бъдат презаписани. Въпреки това, според правилата, разработчиците използват тези елементи с главни буквив името като константи и в хода на писане на кода не променят стойността си.
Основната цел на константите е да съхраняват сложни низове, важни числа или други стойности, в които, когато се пренаписват, е лесно да се направи печатна грешка или в никакъв случай не трябва да се променят, или да се опрости кодът. Например константите могат да съхраняват често повтарящи се заявки за
Променливите служат като "контейнери" за съхраняване на информация.
Помните ли училищната алгебра?
Помните ли училищната алгебра? x=5, y=6, z=x+y
Спомняте ли си, че буква (като x) може да се използва за съхраняване на стойност (като 5) и че можете да използвате информацията по-горе, за да изчислите, че стойността на z е 11?
Тези букви се наричат променливи, а променливите могат да се използват за съхраняване на стойности (x=5) или изрази (z=x+y).
JavaScript променливи
Точно както в алгебрата, JavaScript променливите се използват за съхраняване на стойности или изрази.
Променливата може да има кратко име като x или по-описателно име като carname (име на кола).
Правила за имена на променливи в JavaScript:
- Имената на променливите са чувствителни към главни и малки букви (y и Y са две различни променливи)
- Имената на променливите трябва да започват с буква или долна черта
коментар:Тъй като JavaScript е чувствителен към главни и малки букви, имената на променливите също са чувствителни към главни и малки букви.
Пример
Стойността на променлива може да се промени по време на изпълнение на скрипта. Можете да се обърнете към променлива по нейното име, за да покажете или промените нейната стойност.
Деклариране (създаване) на JavaScript променливи
Създаването на променливи в JavaScript е по-често наричано "деклариране" на променливи.
Вие декларирате JavaScript променливи с ключова дума вар:
След изпълнение на предложенията по-горе, променливата хще съдържа стойността 5 , и име на колатаще съдържа стойността Мерцедес.
коментар:Когато възложите текстова стойностпроменлива, оградете я в кавички.
коментар:Ако декларирате отново променлива, тя няма да загуби стойността си.
Локални променливи на JavaScript
Променлива, декларирана вътре JavaScript функциистава МЕСТЕНи ще бъде достъпен само в рамките на тази функция. (променливата има локален обхват).
Можете да декларирате локални променливи с едно и също име в различни функции, тъй като локалните променливи се разпознават във функцията, в която са декларирани.
Локалните променливи се унищожават, когато функцията излезе.
Ще научите повече за функциите в следващите уроци по JavaScript.
Глобални променливи на JavaScript
Променливите, декларирани извън функцията, стават ГЛОБАЛЕНи всички скриптове и функции на страницата имат достъп до тях.
Глобалните променливи се унищожават, когато затворите страницата.
Ако декларирате променлива без да използвате "var", променливата винаги става ГЛОБАЛЕН.
Присвояване на стойности на недекларирани JavaScript променливи
Ако присвоите стойности на променливи, които все още не са декларирани, променливите автоматично ще бъдат декларирани като глобални променливи.
Тези предложения:
Ще научите повече за операторите в следващия урок по JavaScript.
Променливи и константи в JavaScript. Деклариране на променливи и присвояване на стойности към тях. Глобални и локални променливи. Използване на константи.
Деклариране на променливи в JavaScript
Имената на променливите в JavaScript могат да се състоят от букви, цифри, знака $ и знака _ и името на променливата не може да започва с число. Имайте предвид, че JavaScript е чувствителен към главни и малки букви и a1 и A1 са различни променливи. Кирилицата не е препоръчителна, но е възможна.
Променливите в JavaScript се декларират с ключовата дума var:
Var Premennaya_1 var Peremennaya_2
Не се препоръчва използването на променливи в JavaScript без декларация. Това е възможно, но може да доведе до грешки.
Присвояване на стойност на променливи
Присвояване на стойност на декларирани променливи в JavaScript:
Peremennaya_1 = 25 Peremennaya_2 = "Присвоеният текст е ограден в прави кавички"
Можете да присвоите стойност на променливи веднага след декларирането:
Var Peremennaya_1 = 25 var Peremennaya_2 = "Ограждаме зададения текст в равни кавички"
Стойността на променлива в JavaScript може да се промени по време на изпълнение на програмата. Когато пишете текст към променлива, тя трябва да бъде затворена в равни кавички.
Локални и глобални променливи
Ако една променлива е декларирана във функция, значи е така местени ще бъдат достъпни (имат видимост) само в рамките на тази функция. Когато дадена функция излезе, локалните променливи в JavaScript се унищожават, така че можете да използвате променливи с едно и също име в различни функции.
Ако една променлива е декларирана извън функциите, тогава е така глобалени ще бъдат достъпни (имат видимост) във всички функции на страницата. Глобалните променливи се унищожават в JavaScript, когато страницата се затвори.
Константи в JavaScript
Константиса предназначени да улеснят работата с код, когато трябва да използвате повтарящи се стойности или изрази. Достатъчно е да зададете стойност на константата веднъж и можете да я използвате колкото искате, като я вмъкнете в кода на вашите програми. JavaScript няма ключова дума за деклариране на константи; вместо константи се използват обикновени променливи. За да се разграничат константите от променливите, е обичайно да се обозначават с главни букви, като се използва долна черта, ако е необходимо:
Променлива DRUG_CHELOVEKA = "Куче"
Даденият пример за константа не е съвсем пълен, тъй като думата „куче“ вече е лесна за запомняне и вмъкване, където е необходимо. Можете да използвате константи в JavaScript, за да пишете и поставяте по-сложни стойности, като например трудни за запомняне кодове, набори от знаци, дълъг текст, уеб адреси, адреси електронна поща, телефонни номера, различни коефициенти.
В JavaScript константите могат да бъдат пренаписани като променливи, но ако направите това, тогава значението на константите се губи.