Js փոփոխականների հայտարարություն. Փոփոխականներ, շրջանակներ և փոփոխական բարձրացում JavaScript-ում

Փոփոխականները շատ ծրագրավորման լեզուների հիմնական բաղադրիչն են. դրանք նոր ծրագրավորողների համար ամենակարեւոր հասկացություններից են: JavaScript-ում կան փոփոխականների շատ տարբեր հատկություններ, ինչպես նաև մի քանի կանոն, որոնք պետք է հետևել դրանք անվանելիս: JavaScript-ն ունի երեք հիմնաբառ, որոնք օգտագործվում են փոփոխականը հայտարարելու համար՝ var, let և const, և դրանցից յուրաքանչյուրն ազդում է փոփոխականի մեկնաբանման կոդի մեջ:

Այս ձեռնարկը ձեզ կծանոթացնի փոփոխականներին, կսովորեցնի, թե ինչպես դրանք հայտարարել և անվանել, ինչպես նաև կբացատրի var, let և const տարբերությունը: Բացի այդ, դուք կսովորեք, թե ինչ է փոփոխական բարձրացումը և ինչպես է շրջանակն ազդում փոփոխականի վարքագծի վրա:

Փոփոխականը հիշողության անվանված կտոր է, որն օգտագործվում է տարբեր արժեքներ պահելու համար: Տեղեկատվության մի մասը, որը կարող է մի քանի անգամ հղում կատարել, կարող է պահվել փոփոխականում՝ հետագայում օգտագործելու կամ փոփոխելու համար: JavaScript-ում փոփոխականի ներսում պարունակվող արժեքը կարող է լինել ցանկացած տվյալների տեսակ, ներառյալ համարը, տողը կամ օբյեկտը:

Մինչև ECMAScript 2015 (ES6) լեզվի հստակեցումը, որի վրա հիմնված է JavaScript-ը այս պահին, փոփոխականը հայտարարելու միայն մեկ եղանակ կար՝ օգտագործելով var բանալի բառը։ Ահա թե ինչու հին կոդերի և ձեռնարկների մեծ մասը փոփոխականներ հայտարարելու համար օգտագործում է միայն var: Եկեք նայենք var-ի, let-ի և const-ի միջև եղած տարբերություններին:

Var հիմնաբառը թույլ է տալիս ցուցադրել փոփոխականի գաղափարը: Ստորև բերված օրինակում մենք հայտարարում ենք փոփոխական և արժեք ենք տալիս դրան:

// Օգտվողի անվան նույնացուցիչին հատկացրեք 8 host արժեքը
var օգտվողի անուն = "8host_blog";

Այս արտահայտությունը բաղկացած է մի քանի մասերից.

• Փոփոխականի հայտարարում var բանալի բառի միջոցով;
• Փոփոխականի անուն (կամ նույնացուցիչ), օգտանուն;
• Նշանակման օպերատորը ներկայացված է շարահյուսությամբ =;
• Նշանակված արժեքն է «8host_blog»:

Այժմ դուք կարող եք օգտագործել օգտվողի անվան փոփոխականը ձեր կոդի մեջ: JavaScript-ը կհիշի, որ օգտվողի անունը ներկայացնում է 8host_blog արժեքը:

// Ստուգեք, արդյոք փոփոխականը հավասար է արժեքին
եթե (օգտանուն === «8host_blog») (
console.log (true);
}
ճշմարիտ

Ինչպես նշվեց ավելի վաղ, փոփոխականները կարող են արտահայտվել ցանկացած JavaScript տվյալների տիպով: Այս օրինակում փոփոխականներն արտահայտվում են որպես տող, թիվ, օբյեկտ, բուլյան և զրոյական:

// Տարբեր փոփոխականների նշանակում
var name = «Morty»;
var spartans = 300;
var kingdoms = [ «կաթնասուններ», «թռչուններ», «ձուկ» ];
var poem = (վարդեր՝ «կարմիր», մանուշակներ՝ «կապույտ» );
var հաջողություն = ճշմարիտ;
var ոչինչ = null;

Օգտագործելով console.log կարող եք դիտել ցանկացած փոփոխականի արժեքը.

// Ուղարկեք spartans փոփոխականը կոնսոլին
console.log(spartans);
300

Փոփոխականները պահում են տվյալներ հիշողության մեջ, որոնք հետագայում կարող են օգտագործվել կամ փոփոխվել: Փոփոխականները կարող են նաև վերանշանակվել և նոր արժեք տալ: Ստորև բերված պարզ օրինակը ցույց է տալիս, թե ինչպես կարելի է գաղտնաբառ պահել, այնուհետև թարմացնել փոփոխականում:

// Նշանակել արժեք գաղտնաբառի փոփոխականին
var գաղտնաբառը = «hunter2»;
// Փոփոխական արժեքի վերանշանակում նոր արժեքով
գաղտնաբառ = "hunter3";
console.log (գաղտնաբառ);
«որսորդ 3»

IN իրական ծրագիրԳաղտնաբառը, ամենայն հավանականությամբ, ապահով կերպով կպահվի տվյալների բազայում: Այնուամենայնիվ, այս պարզ օրինակը ցույց է տալիս մի իրավիճակ, երբ դուք կարող եք թարմացնել փոփոխականի արժեքը: Գաղտնաբառի փոփոխականի արժեքը եղել է hunter2, սակայն նրան տրվել է նոր արժեք՝ hunter3, և JavaScript-ն այժմ կօգտագործի նոր արժեքը։

JavaScript-ում փոփոխականների անունները կոչվում են նույնացուցիչներ: Ձեռնարկում կարելի է գտնել նույնացուցիչների անվանման մի քանի կանոններ: Ահա դրանք հակիրճ.

• Փոփոխականների անունները կարող են բաղկացած լինել միայն տառերից, թվերից (0-9), դոլարի նշանից ($) և ընդգծումից (_):
• Փոփոխականների անունները չեն կարող պարունակել բացատ նիշեր:
• Փոփոխականի անունը չպետք է սկսվի թվով:
• Կան մի քանի վերապահված հիմնաբառեր, որոնք չեն կարող օգտագործվել որպես փոփոխականների անուններ:
• Փոփոխականների անունները մեծատառերի զգայուն են:

JavaScript-ն ունի նաև պայման, որով օգտագործվում է camel case-ը var-ով կամ let-ով հայտարարված ֆունկցիաների և փոփոխականների անուններում: Այս դեպքում առաջին բառը գրված է փոքրատառ, և յուրաքանչյուր հաջորդ բառ սկսվում է մեծատառով (բառերը գրվում են առանց նրանց միջև բացատների): Շատ փոփոխականներ, որոնք հաստատուն չեն, կհետևեն այս կոնվենցիային, մի քանի բացառություններով: Փոփոխականների անունները, որոնք հաստատուններ են (հայտարարվում են const բանալի բառով), սովորաբար գրվում են մեծատառ.

Թվում է, թե կան բավականին շատ կանոններ, բայց դա այդպես է թվում միայն առաջին հայացքից։ Հաճախ աշխատելով JavaScript-ով, դուք արագ կհիշեք դրանք:

JavaScript-ն օգտագործում է երեք տարբեր հիմնաբառեր՝ փոփոխականներ հայտարարելու համար, որոնք ավելացնում են բարդության լրացուցիչ շերտ։ Այս հիմնաբառերը տարբերվում են փոփոխական շրջանակով, բարձրացումով և վերանշանակմամբ:

Դուք կարող եք մտածել, թե երեք հիմնաբառերից որն եք օգտագործել ձեր ծրագրերում: Ընդունված պրակտիկա է const-ը հնարավորինս հաճախ օգտագործելը և օղակները ներս թողնելը և վերաբաշխման համար: Ընդհանուր առմամբ, var-ն օգտագործվում է ժառանգական կոդում:

Scope-ը JavaScript-ում վերաբերում է ընթացիկ կոդի համատեքստին, որը որոշում է փոփոխականների հասանելիությունը: Տարածքը կարող է լինել տեղական կամ գլոբալ.

• Գլոբալ փոփոխականները նրանք են, որոնք հայտարարված են բլոկի սահմաններից դուրս:
• Տեղական փոփոխականները նրանք են, որոնք հայտարարված են բլոկի ներսում:

Ստորև բերված օրինակում մենք կստեղծենք գլոբալ փոփոխական:

var արարած = «գայլ»;

Դուք գիտեք, որ փոփոխականները կարող են վերանշանակվել: Տեղական տիրույթում դուք կարող եք ստեղծել նոր փոփոխականներ նույն անունով, ինչ փոփոխականները արտաքին շրջանակում՝ առանց սկզբնական արժեքը փոխելու կամ անտեսելու:

Ստորև բերված օրինակը ստեղծում է գլոբալ փոփոխական տեսակ: Ֆունկցիայի ներսում կա նույն անունով տեղական փոփոխական։ Երբ դրանք ուղարկեք կոնսոլ, կտեսնեք, որ փոփոխականի արժեքը տարբերվում է կախված շրջանակից, բայց սկզբնական արժեքը չի փոխվում։

// Նախաձեռնել գլոբալ փոփոխական
var species = «մարդ»;
ֆունկցիայի փոխակերպում() (
// Նախաձեռնել տեղային, ֆունկցիայի շրջանակով փոփոխական
var species = «գայլ»;
console.log (տեսակ);
}
// Գրանցեք գլոբալ և տեղական փոփոխականները
console.log (տեսակ);
փոխակերպում ();
console.log (տեսակ);
մարդ
մարդագայլ
մարդ

Այս օրինակում տեղական փոփոխականն ունի ֆունկցիայի մակարդակի շրջանակ: Var բանալի բառով հայտարարված փոփոխականները միշտ գտնվում են այդ տիրույթում (այսինքն՝ նրանք ճանաչում են գործառույթները որպես առանձին շրջանակ ունեցող)։ Այսպիսով, տեղական փոփոխականը հասանելի չէ գլոբալ տիրույթում:

Այնուամենայնիվ, նոր let and const հիմնաբառերը շրջափակված են բլոկի մակարդակով: Սա նշանակում է, որ ցանկացած բլոկից ստեղծվում է նոր լոկալ տարածք, ներառյալ ֆունկցիայի բլոկները, if հայտարարությունները և հանգույցների համարիսկ մինչ.

Ֆունկցիոնալ մակարդակի և բլոկի մակարդակի փոփոխականների միջև տարբերությունը պատկերացնելու համար ստեղծեք նոր փոփոխական if բլոկում՝ օգտագործելով let-ը:

var fullMoon = ճշմարիտ;
// Նախաձեռնել գլոբալ փոփոխական
թող տեսակներ = «մարդ»;
եթե (լիալուսին) (
// Նախաձեռնել բլոկային շրջանակով փոփոխական
let species = «գայլ»;

}


Լիալուսին չէ։ Լյուպինը ներկայումս մարդ է:

Այս օրինակում փոփոխական տեսակն ունի մեկ գլոբալ արժեք (մարդ) և մեկ տեղական արժեք (գայլ): Այնուամենայնիվ, եթե դուք օգտագործում եք var, արդյունքը տարբեր կլինի:

// Օգտագործեք var՝ փոփոխականը սկզբնավորելու համար
var species = «մարդ»;
եթե (լիալուսին) (
// Բլոկում նոր փոփոխական ստեղծելու փորձ
var species = «գայլ»;
console.log(`Դա լիալուսին է: Լյուպինը ներկայումս $(տեսակ է):`);
}
console.log(`Դա լիալուսին չէ: Լյուպինը ներկայումս $(տեսակ է):`);
Լիալուսին է։ Լյուպինը ներկայումս մարդագայլ է:
Լիալուսին չէ։ Լյուպինը ներկայումս մարդագայլ է:

Արդյունքում և՛ գլոբալ փոփոխականը, և՛ բլոկի մակարդակի փոփոխականը արտադրում են նույն արժեքը՝ մարդագայլ։ Դա պայմանավորված է նրանով, որ նոր տեղական փոփոխական ստեղծելու փոխարեն var-ը վերահանձնում է նույն փոփոխականը նույն շրջանակում: var-ը չի հասկանում, որ if-ը պետք է լինի այլ, նոր շրջանակի մաս: Ընդհանրապես խորհուրդ է տրվում փոփոխականներ հայտարարել բլոկի մակարդակում, քանի որ դա նվազեցնում է փոփոխական արժեքների ոչ միտումնավոր վերացման վտանգը:

Մինչ այժմ օրինակներից շատերը օգտագործել են var բանալի բառը՝ փոփոխական հայտարարելու և փոփոխականը արժեքով սկզբնավորելու համար։ Հայտարարվելուց և սկզբնավորվելուց հետո արժեքը կարող է հասանելի լինել կամ վերանշանակվել:

Եթե ​​փորձեք օգտագործել փոփոխական նախքան այն հայտարարվելը և սկզբնավորվելը, արդյունքը չի սահմանվի:

console.log (x);
// Փոփոխական հանձնարարություն
var x = 100;
չսահմանված

Այնուամենայնիվ, եթե բաց թողնեք var բանալի բառը, փոփոխականը չի հայտարարվի, այլ միայն սկզբնավորվում է: Սա կվերադարձնի ReferenceError և կդադարեցնի սկրիպտի կատարումը:

// Փորձեք օգտագործել փոփոխական նախքան այն հայտարարելը
console.log (x);
// Փոփոխական հանձնարարություն առանց var
x = 100;
ReferenceError. x-ը սահմանված չէ

Սա պայմանավորված է hoisting-ով, JavaScript-ի վարքագիծ, որտեղ փոփոխականների և ֆունկցիաների հայտարարագրերը տեղափոխվում են վերին մասնրանց տարածքները։ Քանի որ միայն փաստացի հայտարարությունը բարձրացվում է, և ոչ սկզբնավորումը, առաջին օրինակը վերադառնում է անորոշ:

Այս հայեցակարգն ավելի լավ ցուցադրելու համար մենք գրեցինք հետևյալ կոդը և բացատրեցինք, թե ինչպես է JavaScript-ը կարդում այն.

// Մեր գրած կոդը
console.log (x);
var x = 100;
// Ինչպես JavaScript-ը մեկնաբանեց այն
var x;
console.log (x);
x = 100;

Նախքան սկրիպտը կատարելը, JavaScript-ը պահում է x-ը հիշողության մեջ որպես փոփոխական։ Քանի որ փոփոխականը կանչվել է նախքան դրա սահմանումը, արդյունքը վերադարձվում է անորոշ, այլ ոչ թե 100: Այնուամենայնիվ, դա չի առաջացնում ReferenceError կամ դադարեցնում սկրիպտը: Չնայած var բանալի բառը իրականում չի փոխել var-ի գտնվելու վայրը, այն ցույց է տալիս, թե ինչպես է աշխատում բարձրացումը: Այս վարքագիծը կարող է խնդիրներ առաջացնել, քանի որ ծրագրավորողը, ով գրել է այս կոդը, ամենայն հավանականությամբ, ակնկալում է, որ x-ի ելքը լինի ճշմարիտ, այլ ոչ թե անորոշ:

Բարձրացումը կարող է նաև հանգեցնել անկանխատեսելի արդյունքների, ինչպես հետևյալ օրինակում.

var x = 100;
ֆունկցիա ամբարձիչ () (
// Պայման, որը չպետք է ազդի կոդի արդյունքի վրա
եթե (սուտ) (
var x = 200;
}
console.log (x);
}
ամբարձիչ ();
չսահմանված

Այս օրինակում գլոբալ x փոփոխականը 100 է: Կախված if դրույթից, x-ը կարող է փոխվել մինչև 200, բայց քանի որ պայմանը կեղծ էր, այն չպետք է ազդի x-ի արժեքի վրա: Փոխարենը, x-ը բարձրացվեց hoist()-ի մեկնարկից առաջ և արժեքը դարձավ անորոշ:

Այս անկանխատեսելի վարքագիծը կարող է ծրագրում սխալներ առաջացնել: Քանի որ let-ը և const-ը սահմանվում են բլոկի մակարդակում, դրանք չեն բարձրացվի այնպես, ինչպես ստորև բերված օրինակում:

// Նախաձեռնել x-ը գլոբալ տիրույթում
թող x = ճշմարիտ;
ֆունկցիա ամբարձիչ () (
// Նախաձեռնել x-ը ֆունկցիայի տիրույթում
եթե (3 === 4) (
թող x = կեղծ;
}
console.log (x);
}
ամբարձիչ ();
ճշմարիտ

Կրկնվող փոփոխականների հայտարարագրերը, որոնք հնարավոր են var-ով, կառաջացնեն let-ի և const-ի սխալ:

// Var-ով հայտարարված փոփոխականը վերագրանցելու փորձ
var x = 1;
var x = 2;
console.log (x);
2
// Let-ով հայտարարված փոփոխականը վերագրանցելու փորձ
թող y = 1;
թող y = 2;
console.log(y);

Չբռնված SyntaxError. «y» նույնացուցիչն արդեն հայտարարված է
Այսպիսով, var-ով հայտարարված փոփոխականները կարող են ազդվել բարձրացումից: Hoisting-ը JavaScript-ում մեխանիզմ է, որտեղ փոփոխական հայտարարագրերը պահվում են հիշողության մեջ: Սա կարող է հանգեցնել կոդի մեջ չսահմանված փոփոխականների: Let և const հիմնաբառերը լուծում են այս խնդիրը՝ առաջացնելով սխալ, եթե փորձեք օգտագործել փոփոխական նախքան այն հայտարարելը կամ փոփոխականը մեկից ավելի անգամ հայտարարեք:

Ծրագրավորման շատ լեզուներ օգտագործում են հաստատուններ, որոնք արժեքներ են, որոնք հնարավոր չէ փոխել: Այսինքն, հաստատունին վերագրված արժեքները չեն կարող վերանշանակվել:

Ընդհանուր պայմանով, const նույնացուցիչները գրվում են մեծատառով: Սա նրանց տարբերում է այլ փոփոխականներից:

Ստորև բերված օրինակում SPECIES փոփոխականը սկզբնավորվում է որպես հաստատուն՝ օգտագործելով const բանալի բառը: Փոփոխական վերանշանակելու փորձը կհանգեցնի սխալի:

// Նշանակել արժեքը const-ին
const SPECIES = «մարդ»;
// Արժեքը վերահանձնելու փորձ
ՏԵՍԱԿ = «գայլ»;
console.log (ՏԵՍԱԿ);
Չբռնված TypeError. վերագրում հաստատուն փոփոխականին:

Քանի որ const արժեքները չեն կարող վերանշանակվել, դրանք պետք է միաժամանակ հայտարարվեն և սկզբնավորվեն, հակառակ դեպքում սխալ կառաջանա:

// Հայտարարել, բայց մի նախաստորագրել const
const TODO;
console.log (TODO);
Չբռնված սինտաքսի սխալ. Const հայտարարագրում բացակայում է սկզբնավորիչը

Այն արժեքները, որոնք հնարավոր չէ փոխել ծրագրավորման միջոցով, կոչվում են անփոփոխ, իսկ արժեքները, որոնք հնարավոր է փոխել, կոչվում են փոփոխական (ակնհայտորեն): Հաստատուն արժեքները չեն կարող վերանշանակվել, բայց դրանք փոփոխական են, քանի որ const-ով հայտարարված օբյեկտների հատկությունները կարող են փոխվել:

// Ստեղծեք CAR օբյեկտ երկու հատկությամբ
const CAR = (
գույնը՝ «կապույտ»,
գինը՝ 15000 դրամ
}
// Փոփոխել CAR-ի սեփականությունը
Մեքենա.գին = 20000;
console.log (CAR);
(գույնը՝ «կապույտ», գինը՝ 20000 )

Constants-ը թույլ է տալիս ձեզ ասել նախագծի վրա աշխատող այլ ծրագրավորողներին և ինքներդ ձեզ, որ տվյալ փոփոխականը չպետք է վերանշանակվի: Փոփոխական հայտարարելու համար, որը կարող է վերանշանակվել, դուք պետք է օգտագործեք let:

Այս ձեռնարկում դուք իմացաք, թե ինչ է փոփոխականը, ծանոթացաք փոփոխականների անվանման կանոններին և սովորեցիք, թե ինչպես վերանշանակել դրանց արժեքները: Դուք նաև իմացաք փոփոխական շրջանակի և բարձրացման, var բանալի բառի սահմանափակումների և ինչպես թույլ տալ և պահպանել այս խնդիրները վերացնելու մասին:

Var հայտարարությունը հայտարարում է փոփոխական, կամայականորեն սկզբնավորելով այն արժեքի:

Այս ինտերակտիվ օրինակի աղբյուրը պահվում է GitHub պահեստում: Եթե ​​ցանկանում եք նպաստել ինտերակտիվ օրինակների նախագծում, խնդրում ենք կլոնավորել https://github.com/mdn/interactive-examples և ուղարկել մեզ հետաձգման հարցում:

չսահմանված

. Նկարագրություն var-ի հայտարարագրերը, որտեղ էլ որ դրանք լինեն, մշակվում են նախքան որևէ ծածկագրի գործարկումը: Սա կոչվում է բարձրացում, և այն կքննարկվի ստորև: Var-ով հայտարարված փոփոխականի շրջանակը նրա հոսանքն է

Չհայտարարված փոփոխականին արժեք վերագրելը անուղղակիորեն ստեղծում է այն որպես գլոբալ փոփոխական (այն դառնում է գլոբալ օբյեկտի սեփականություն), երբ հանձնարարությունը կատարվում է: Հայտարարված և չհայտարարված փոփոխականների միջև տարբերությունները հետևյալն են.

1. Հայտարարված փոփոխականները սահմանափակվում են կատարման համատեքստում, որտեղ նրանք հայտարարված են: Չհայտարարված փոփոխականները միշտ գլոբալ են:

Ֆունկցիան x() ( y = 1; // Նետում է ReferenceError խիստ ռեժիմում: var z = 2; ) x(); console.log(y); // 1 console.log(z); // Նետում է ReferenceError. z-ը սահմանված չէ x-ից դուրս:

2. Հայտարարված փոփոխականները ստեղծվում են նախքան որևէ կոդի գործարկումը: Չհայտարարված փոփոխականները գոյություն չունեն, քանի դեռ նրանց վերագրվող կոդը չի գործարկվել:

Console.log(a); // «չսահմանված» կամ «» կախված բրաուզերի console.log-ից («դեռ գնում է...»); // դեռ շարունակվում է... var a = 1; console.log(a); // 1 console.log ("sill going..."); // դեռ շարունակվում է...

3. Հայտարարված փոփոխականները իրենց կատարման համատեքստի չկարգավորվող հատկությունն են (գործառույթ կամ գլոբալ): Չհայտարարված փոփոխականները կարգավորելի են (օրինակ՝ կարող են ջնջվել):

Var a = 1; b = 2; ջնջել this.a; // Նետում է TypeError խիստ ռեժիմում: Հակառակ դեպքում չի հաջողվում լուռ: ջնջել this.b; console.log (a, b); // Նետում է ReferenceError: // «b» հատկությունը ջնջվել է և այլևս գոյություն չունի:

Այս երեք տարբերությունների պատճառով փոփոխականները չհայտարարելը, ամենայն հավանականությամբ, կհանգեցնի անսպասելի արդյունքների: Այսպիսով, խորհուրդ է տրվում միշտ հայտարարել փոփոխականներ՝ անկախ նրանից՝ դրանք ֆունկցիայի կամ գլոբալ շրջանակի մեջ են:

var hoisting

Քանի որ փոփոխական հայտարարագրերը (և ընդհանրապես հայտարարությունները) մշակվում են նախքան որևէ կոդի գործարկումը, փոփոխականի հայտարարագրումը կոդի ցանկացած կետում համարժեք է այն վերևում հայտարարելուն: Սա նաև նշանակում է, որ փոփոխականը կարող է թվալ, որ օգտագործվում է նախքան այն հայտարարելը: Այս վարքագիծը կոչվում է «բարձրացում», քանի որ թվում է, որ փոփոխականի հայտարարությունը տեղափոխվել է ֆունկցիայի կամ գլոբալ կոդի վերևում:

Բլա = 2; var bla; // ... անուղղակիորեն հասկացվում է որպես. var bla; բլա = 2;

Այդ պատճառով, խորհուրդ է տրվում փոփոխականները միշտ հայտարարել իրենց շրջանակի վերևում (գլոբալ կոդի վերևում և ֆունկցիայի կոդի վերևում), որպեսզի պարզ լինի, թե որ փոփոխականներն են գործառույթի շրջանակով (տեղական) և որոնք են լուծվում շրջանակի վրա: շղթա.

do_something() (consol.log(bar); // undefined var bar = 111; console.log(bar); // 111 ) // ... անուղղակիորեն հասկացվում է որպես. do_something ֆունկցիա () ( var bar; console .log(bar) // undefined bar = 111;

Ուշադիր եղեք կարգի վրա.

Var x = y, y = «A»; console.log (x + y); //չսահմանված Ա

Այստեղ x-ը և y-ը հայտարարվում են նախքան որևէ ծածկագրի կատարումը, բայց հանձնարարությունները տեղի են ունենում ավելի ուշ: Այն պահին, երբ «x = y»-ը գնահատվում է, y-ն գոյություն ունի, ուստի ReferenceError-ը չի գցվում, և դրա արժեքը անորոշ է: Այսպիսով, x-ին վերագրվում է չսահմանված արժեք: Այնուհետև y-ին վերագրվում է «A" . Consequently, after the first line, x === undefined && y === "A" , hence the result.!}

Նույն օրինակը, ինչպես վերևում, բայց խիստ ռեժիմով.

«օգտագործել խիստ»; var x = 0; ֆունկցիա f() ( var x = y = 1; // Նետում է ReferenceError խիստ ռեժիմում: ) f(); console.log (x, y);

Փոփոխականները, որոնք կարծես անուղղակի գլոբալներ են, կարող են հղումներ լինել արտաքին ֆունկցիայի շրջանակի փոփոխականներին.

Var x = 0; // Հայտարարում է x-ը ֆայլի շրջանակում, այնուհետև նրան տալիս է 0 արժեք. console.log(typeof z); // «չսահմանված», քանի որ z-ն դեռ գոյություն չունի a() ֆունկցիան (var y = 2; // Հայտարարում է y-ը a ֆունկցիայի շրջանակում, այնուհետև նրան տալիս է 2 արժեք, console.log(x, y); // 0 2 ֆունկցիա b() ( x = 3; // 3-ը վերագրում է առկա ֆայլին, որի շրջանակը x. y = 4; // 4-ը վերագրում է առկա արտաքին y-ին. z = 5; // Ստեղծում է նոր գլոբալ փոփոխական z, և նշանակում է 5 արժեք console.log(x, z)

Այս էջի համատեղելիության աղյուսակը ստեղծվում է կառուցվածքային տվյալների հիման վրա: Եթե ​​ցանկանում եք նպաստել տվյալներին, խնդրում ենք ստուգել https://github.com/mdn/browser-compat-data և ուղարկել մեզ հետ կանչելու հարցում:

Թարմացրեք համատեղելիության տվյալները GitHub-ում

Աշխատելով Javascript-ում կարող ենք մուտքագրել թվային, տողային և բուլյան արժեքներ, սակայն նրանք աշխատում են, եթե ծրագիրը պարունակում է անհրաժեշտ տեղեկատվություն։ Այդ նպատակով ստեղծվել են փոփոխականներ, որոնք թույլ են տալիս մեզ պահել տարբեր տեսակի տեղեկատվություն և այն ներկայացնել որպես մի տեսակ կոնտեյներ, որին մենք կարող ենք ցանկացած պահի մուտք գործել և ստանալ այն տեղեկատվությունը, որը գտնվում է դրանում:

Փոփոխականը ստեղծվում է երկու փուլով՝ փոփոխականի հայտարարում և անուն վերագրում։

Նախ, մենք պետք է հայտարարենք փոփոխականը, այսինքն՝ հայտարարենք այն, դա արվում է var բանալի բառի միջոցով։ Հաջորդը մենք գրում ենք հրահանգ, սա փոփոխականի անունն է, նրա անունն այն է, թե ինչպես ենք մուտք գործելու, օրինակ ես կգրեմ dwstv:

Թե ինչ եք անվանել փոփոխականները, իհարկե, կախված է ձեզանից, բայց կան մի քանի կանոններ, որոնք պետք է պահպանվեն, որպեսզի Javascript-ն աշխատի.

• առաջին կանոնը, խուսափեք վերապահված բառեր օգտագործելուց։ JavaScript լեզվի որոշ բառեր օգտագործվում են հենց համակարգում, օրինակ var բառը, որով մենք հայտարարում ենք փոփոխական: Բացի այդ, որոշ բառեր, ինչպիսիք են զգուշացում , փաստաթուղթ , պատուհան , համարվում են վեբ էջի հատուկ հատկություններ։ Եթե ​​փորձեք դրանք օգտագործել որպես փոփոխականներ, սխալի մասին հաղորդագրություն կստանաք: Այստեղ դուք կարող եք տեսնել վերապահված բառերի ցանկը:
• երկրորդ կանոն, փոփոխականի անունը պետք է սկսվի տառով, $ կամ _ խորհրդանիշով: Այսինքն՝ փոփոխականը չի կարող սկսվել թվով կամ կետադրական նշանով. 1dwstv և &dwstv անունները չեն աշխատի, իսկ $dwstv և _dwstv անունները կաշխատեն։
• երրորդ կանոն, փոփոխականի անունը կարող է պարունակել տառեր, թվեր, $ և _ խորհրդանիշներ և չի կարող անվան մեջ օգտագործել բացատներ կամ այլ նիշեր։ հատուկ նշաններ dws&tv և dws tv անվավեր անուններ են, բայց այս ձևաչափը հնարավոր է՝ dws_tv և dwstv1 կամ dws_tv_1:
• չորրորդ կանոն, փոփոխականների անունները մեծատառերի զգայուն են: JavaScript թարգմանիչը տարբեր կերպ է վերաբերվում փոքրատառ և մեծատառ տառերին, ինչը նշանակում է, որ DWSTV փոփոխականը տարբերվում է dwstv փոփոխականից, ինչպես նաև DwStv և Dwstv փոփոխականներից։
• հինգերորդ կանոն, խորհուրդ չի տրվում օգտագործել կիրիլիցայով գրված այլ նիշեր, թեև դրանք կաշխատեն, երաշխավորված չեն և չեն հասկանա այլ երկրների գործընկերները։

Սրանք այն հիմնական հինգ կանոններն են, որոնց ես խորհուրդ եմ տալիս հետևել, բացի դրանցից ես կցանկանայի նաև ասել, ձեր փոփոխականներին հստակ և արտահայտիչ անուններ նշանակեք: Անվանեք փոփոխականները՝ ըստ դրանցում պահվող տվյալների տեսակի, դա կօգնի ձեզ ավելի լավ հասկանալ, թե ինչ է գրված, և, նայելով այդպիսի փոփոխականներին, պարզ կդառնա, թե ինչի մասին է խոսքը։

Փոփոխականներ անվանելիս աշխատեք դրանք հեշտ ընթեռնելի դարձնել: Բազմաթիվ բառեր օգտագործելիս դրանց միջև ընդգծեք կամ յուրաքանչյուր բառ առաջինից հետո սկսեք մեծատառով: Օրինակ՝ dwsTv կամ dws_tv։

Դասի սկզբում մենք նայեցինք, թե ինչից է բաղկացած փոփոխականը, այժմ, երբ մենք գիտենք, թե ինչպես ստեղծել այն, մենք կարող ենք ցանկացած տեսակի տվյալներ պահել դրանում մեր հայեցողությամբ:

Տվյալները փոփոխականի մեջ տեղադրելու համար օգտագործեք հատուկ բնավորություն, հավասարության նշանը (=) կոչվում է նշանակման օպերատոր, քանի որ այն օգտագործվում է փոփոխականին արժեք վերագրելու համար։

Օրինակ՝ dwstv փոփոխականի մեջ դնենք թվային արժեք, բաժանորդների թիվը 8500 է, հայտարարենք var dwstv փոփոխականը;

իսկ երկրորդ տողում մենք դնում ենք dwstv = 8500 արժեքը;

Var dwstv; dwstv = 7200;

Եվ այսպես, առաջին տողով մենք ստեղծեցինք փոփոխական, իսկ երկրորդով մենք պահպանեցինք արժեքը դրա մեջ: Մենք կարող ենք նաև փոփոխական ստեղծել և արժեքներ պահել դրանում՝ օգտագործելով մեկ հայտարարություն, օրինակ՝

Var dwstv = 7200;

Փոփոխականում մենք կարող ենք պահել ցանկացած տեսակի տվյալ, որը մենք անդրադարձել ենք նախորդ դասերում, դրանք կարող են լինել թվային, տողային և տրամաբանական արժեքներ.

Var dwstv = 7200;var դասեր = 'JavaScript'; var youtubeKanal = 'DwsTV'; var subscribers = '7700'; var բովանդակություն = ճշմարիտ;

Var դասեր = 'JavaScript', youtubeKanal = 'DwsTV', բաժանորդներ = '7700', բովանդակություն = ճշմարիտ;

Արժեքները փոփոխականներում պահելուց հետո մենք կարող ենք մուտք գործել այս տվյալները: Դա անելու համար պարզապես օգտագործեք փոփոխականի անունը:

Օրինակ, եթե մենք ցանկանում ենք բացել ազդանշանային երկխոսություն և ցուցադրել kanal փոփոխականում պահված արժեքը, մենք կարող ենք պարզապես գրել փոփոխականի անունը ազդանշանային ֆունկցիայի մեջ։

Զգուշացում (ալիք);

Նկատի ունեցեք, որ մենք չակերտներ չենք դնում փոփոխականների շուրջ, դրանք միայն տողերի համար են, ուստի մենք չենք գրում alert('kanal'), քանի որ դա մեզ կտա kanal բառերը, քան փոփոխականում պահվող արժեքը:

Այժմ, կարծում եմ, հասկանում եք, թե ինչու պետք է տողերը փակվեն չակերտների մեջ. JavaScript թարգմանիչը առանց չակերտների բառերը վերաբերվում է որպես հատուկ օբյեկտներ (օրինակ՝ alert() հրամանը) կամ որպես փոփոխականների անուններ։

Եվ նաև կա մի պահ, երբ մենք հայտարարագրել ենք var բանալի բառով փոփոխական և ցանկանում ենք այն փոխել փոփոխական արժեք, չարժե այն նորից հայտարարել՝ գրելով var բառը, բավական է անվանել փոփոխականի անունը և նրան նոր արժեք վերագրել։

Բաժանորդներ = '10000';

Այս դասի վերջում ուզում եմ ասել, որ որևէ լեզու սովորելով՝ դուք չեք սովորի ծրագրավորել։ Անկասկած, դուք նոր բան կսովորեք, բայց, ամենայն հավանականությամբ, ձեր ուղեղը չի հիշի այս տեղեկատվությունը, քանի որ դուք չեք աշխատում դրա հետ: Առանց պարապելու անհնար է լեզու սովորել, ուստի այս դասից դուք կստանաք փոքրիկ առաջադրանք, որպեսզի տրամադրված տեղեկատվությունը տեղավորվի ձեր մտքում և կարողանաք աշխատել դրա հետ։

Գործնական առաջադրանք.

Ստեղծեք երեք փոփոխական, մեկին նշանակեք թվային արժեք, երկրորդին՝ լարային արժեք, երրորդին՝ տրամաբանական արժեք։ Հայտարարեք բոլոր փոփոխականները մեկ հիմնաբառով var և ցուցադրեք դրանք էջում: Այնուհետև վերասահմանեք փոփոխականը թվային արժեքև ցուցադրեք ստացված արդյունքը՝ օգտագործելով alert() ֆունկցիան։

Հաջորդ տեսանյութի սկզբում մենք կանդրադառնանք այս առաջադրանքը, կիսվեք ձեր արդյունքներով մեկնաբանություններում, գրեք, եթե որևէ մեկը հարցեր ունի։ Եթե ​​ձեզ դուր եկավ դասը և ցանկանում եք աջակցել նախագծին, պարզապես տարածեք այն սոցիալական ցանցերում:

Հաջորդ դասում մենք մանրամասն կանդրադառնանք, թե ինչպես աշխատել տվյալների տեսակների և փոփոխականների հետ, ծանոթանալ մաթեմատիկական գործողություններին և դրանց կատարման կարգին, ինչպես նաև վերլուծել լարային և թվային արժեքների համադրման մեթոդները:

Դասը պատրաստեց Դենիս Գորելովը։

Ծրագրավորողը ցանկանում է ստեղծել գլոբալ փոփոխական ֆիլմ և մեկ այլ փոփոխական, որն ունի նույն անունը, բայց գործում է միայն showBadFilm() ֆունկցիայում։ Ի՞նչ հաղորդագրություն է դուրս գալու showGoodFilm()-ի ազդանշանը: Ի՞նչ հաղորդագրություն կցուցադրվի, եթե այս ֆունկցիան նորից կանչվի, բայց showBadFilm() ֆունկցիան կանչելուց հետո:

Լավ, թե վատ ֆիլմ.

var film = «Red viburnum»;

ֆունկցիա showGoodFilm() ( alert(film + " - լավ ֆիլմ!"); ) function showBadFilm() ( film = "September 11"; alert(film + " - վատ ֆիլմ!"); ) showGoodFilm(); // ինչ կցուցադրի ահազանգը:

• showBadFilm(); // ինչ կցուցադրի ահազանգը:

  showGoodFilm(); // ինչ կցուցադրի ահազանգը:

  Լուծում:

  var film = «Red viburnum»;

  Ուշադրություն դարձրեք, որ showBadFilm() ֆունկցիան չունի var բանալի բառը ֆիլմի փոփոխականից առաջ: Հետևաբար, JavaScript-ը ենթադրում է, որ դուք ցանկանում եք վերացնել գլոբալ փոփոխականի արժեքը, այլ ոչ թե ստեղծել նույն անունով տեղական փոփոխական։ Հետևաբար, showGoodFilm() ֆունկցիան նորից կանչելով կտպվի. «Սեպտեմբերի 11-ը լավ ֆիլմ է»:

Տվյալների տեսակի ստուգում

Ո՞ր պարզունակ տվյալների տեսակն են հետևյալ փոփոխականները. Փորձեք պատասխանել առանց սցենարը գործարկելու:

• Տվյալների տիպի ստուգում var film = «Red Viburnum»;
• var 07_agent = «Գործակալ»;
• var num = 10;

var u = ճշմարիտ;

var x;

զգուշացում (ֆիլմի տեսակ); //???

զգուշացում (տիպ 07_գործակալ); //???

զգուշացում (համարի տեսակ); //???

զգուշացում (u տիպ); //???

զգուշացում (տիպ x); //???

Նույնացուցիչները կարող են լինել կարճ անուններ (օրինակ՝ x և y), կամ ավելի նկարագրական անուններ (տարիք, գումար, ընդհանուր ծավալ):

Ընդհանուր կանոններՓոփոխականների անունների կառուցում (եզակի նույնացուցիչներ) հետևյալն են.

• Անունները կարող են պարունակել տառեր, թվեր, ընդգծումներ և դոլարի նշաններ:
• Անունները պետք է սկսվեն տառով
• Անունները կարող են սկսվել նաև $-ով և _-ով (բայց մենք այն չենք օգտագործի այս ձեռնարկում)
• Անունները մեծատառերի զգայուն են (y և y տարբեր փոփոխականներ են)
• Պահպանված բառերը (օրինակ՝ JavaScript հիմնաբառերը) չեն կարող օգտագործվել որպես անուններ

JavaScript նույնացուցիչները մեծատառերի զգայուն են:

JavaScript-ում հավասար նշանը (=) «հանձնարարություն» օպերատոր է, այլ ոչ թե «հավասար» օպերատոր:

Սա տարբերվում է հանրահաշիվից: Հանրահաշվում իմաստ չունի հետևյալը.

JavaScript-ում, սակայն, սա իմաստ ունի. այն x + 5-ի արժեքը տալիս է x-ին:

(Այն հաշվում է x + 5 արժեքը, իսկ արդյունքը դնում է x-ի մեջ։ x-ի արժեքը մեծանում է 5-ով)

«Հավասար» օպերատորը JavaScript-ում գրված է որպես ==:

JavaScript փոփոխականները կարող են պարունակել թվեր, ինչպիսիք են 100 և տեքստային արժեքներինչպես «Ջոն Դոուն»:

Ծրագրավորման մեջ տեքստային արժեքները կոչվում են տեքստային տողեր:

JavaScript-ը կարող է աշխատել տարբեր տեսակներտվյալներ, բայց առայժմ միայն թվեր և տողեր մտածել:

Տողերը գրվում են կրկնակի կամ միայնակ մեջբերումներ. Թվերը գրվում են առանց չակերտների։

Եթե ​​թվի շուրջ չակերտներ դնեք, այն կդիտարկվի որպես տեքստային տող:

JavaScript-ում փոփոխականի ստեղծումը կոչվում է փոփոխականի «հայտարարում»:

Դուք հայտարարում եք JavaScript փոփոխական var հիմնաբառով.

Հայտարարվելուց հետո փոփոխականը արժեք չունի: (Տեխնիկապես իմաստը որոշված ​​չէ)

Փոփոխականին արժեք վերագրելու համար օգտագործեք հավասարության նշանը.

carName = «Volvo»;

Դուք կարող եք նաև արժեք վերագրել փոփոխականին՝ այն հայտարարելիս.

var carName = «Volvo»;

Ստորև բերված օրինակում մենք ստեղծում ենք carName անունով փոփոխական և դրան վերագրում «Volvo» արժեքը։

Այնուհետև մենք «արտադրում ենք» արժեքը HTML տարրի ներսում id="demo"-ով:

var carName = «Volvo»;
document.getElementById(«դեմո»).innerHTML = carName;

Դուք կարող եք բազմաթիվ փոփոխականներ հայտարարել մեկ հայտարարության մեջ:

Սկսեք հայտարարությունը var-ով և բաժանեք փոփոխականները ստորակետներով.

Հռչակագիրը կարող է ընդգրկել մի քանի տող.

IN համակարգչային ծրագրեր, փոփոխականները հաճախ հայտարարվում են առանց արժեքի։ Արժեքը կարող է լինել ինչ-որ բան, որը պետք է հաշվարկվի, կամ ինչ-որ բան, որը հետագայում կտրամադրվի որպես օգտագործողի մուտքագրում:

Առանց արժեքի հայտարարված փոփոխականը կունենա չսահմանված արժեք:

Այս հայտարարությունը կատարելուց հետո carName փոփոխականի արժեքը չսահմանված կլինի: