Ի՞նչ է փոփոխականը:

Հասկանալով փոփոխականները ծրագրավորման մեջ

Ի՞նչ է փոփոխականը:

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

Փոփոխականներին արժեքներ վերագրելը

Փոփոխականներ անվանելը կարող է դժվար լինել. կարող է դժվար լինել փոփոխականների հստակ և հակիրճ անուններ գտնելը: Այնուամենայնիվ, փոփոխականներ անվանելիս կարևոր է առաջնահերթություն տալ նկարագրության և հասկանալի լինելուն: Հիշեք, որ մյուսները, այդ թվում նաև ինքներդ ձեզ, ապագայում պետք է կարդան և հասկանան կոդը: Անունների օգտագործումը, որոնք ճշգրտորեն արտացոլում են փոփոխականի նպատակը, ձեր կոդը կհեշտացնեն կարդալ և պահպանել: Ծրագրավորման մեջ դուք արժեքներ եք վերագրում փոփոխականներին՝ օգտագործելով «=» խորհրդանիշը՝ փոփոխականի անունը ձախ կողմում, իսկ արժեքը՝ աջ:

Օրինակ՝

  let firstName = 'Joe';
    console.log(firstName);
    // Output: Joe

Այստեղ «Joe» տողը վերագրվում է «firstName» փոփոխականին:

Նշում. Մի շփոթեք «=» նշանակման օպերատորը «==» հավասարության օպերատորի հետ: «=» օպերատորը նշանակում է արժեք, իսկ «==»-ը ստուգում է, արդյոք երկու արժեքները հավասար են:

Տվյալների ստացում Օգտատիրոջից

Օգտատիրոջ փոխազդեցությունը թույլատրելու համար կարող եք օգտագործել օգտատերերի մուտքագրումը ձայնագրելու մեթոդներ: JavaScript-ում դա կարելի է անել prompt փաթեթով:

Օրինակ՝

  const prompt = require('prompt');

    prompt.start();
    let { name } = await prompt.get(["name"]);
    console.log(name);

    // Input: Bob
    // Output: Bob

«prompt» ֆունկցիան ընդունում է օգտվողի մուտքը և պահում այն ​​«name» փոփոխականում:

Փոփոխական շրջանակ

Փոփոխականի շրջանակը որոշում է, թե որտեղ է այն հասանելի ծրագրի շրջանակներում: Շրջանակը սահմանվում է նրանով, թե որտեղ է սկզբնավորվում փոփոխականը:

Փոփոխական շրջանակը ֆունկցիաներում

Ֆունկցիաներում, ֆունկցիայի ներսում սկզբնավորվող փոփոխականները հասանելի են միայն այդ ֆունկցիայի ներսում:

Օրինակ՝

let name = 'Somebody Else';

function printFullName(firstName, lastName) {

  let name = firstName + ' ' + lastName;

  console.log(name);

}

printFullName('Peter', 'Henry');  // prints Peter Henry

printFullName('Lynn', 'Blake');   // prints Lynn Blake

console.log(name);                // prints Somebody Else

Այստեղ «printFullName» ֆունկցիայի ներսում «name» փոփոխականն առանձնացված է դրանից դուրս գտնվող «name» փոփոխականից:

Փոփոխական շրջանակ և արգելափակումներ

Բլոկը կոդի մի մասն է, որը հետևում է վերահսկման դրույթներին, ինչպիսիք են՝ «եթե», «for» կամ «while», և սահմանազատված է «{}» գանգուր փակագծերով:

Օրինակ՝

let total = 0;

\[1, 2, 3].forEach(function(number) {

  total += number;

});

console.log(total);  // Output: 6

total = 0;

for (let i = 0; i < 3; i++) {

  total += (i + 1);

}

console.log(total);  // Output: 6

Երկու դեպքում էլ բլոկը կարող է մուտք գործել և փոփոխել բլոկից դուրս սահմանված «ընդհանուր» փոփոխականը: Այնուամենայնիվ, բլոկի ներսում նախաստորագրված փոփոխականները (օրինակ՝ «i» և «համարը») չեն կարող մուտք գործել բլոկի սահմաններից դուրս:

Փոփոխականների տեսակները

JavaScript-ում կան երեք տեսակի փոփոխականներ՝ «var», «let» և «const»:

- var. Հայտարարում է փոփոխականը` ցանկության դեպքում այն ​​սկզբնավորելով որպես արժեք: «var»-ն ունի ֆունկցիայի շրջանակ, այսինքն՝ այն հասանելի է ամբողջ ֆունկցիայի մեջ, որում հայտարարված է:

var varVariable = 'I am a var variable';

- let. Հայտարարում է շրջափակման շրջանակով տեղական փոփոխական՝ ցանկության դեպքում այն ​​սկզբնավորելով որպես արժեք: «let»-ը նախընտրելի է «var»-ից՝ իր բլոկի շրջանակի պատճառով:

let letVariable = 'I am a let variable';

- const. Հայտարարում է բլոկի շրջանակով, միայն կարդալու անվանական հաստատուն: «const» փոփոխականի արժեքը չի կարող փոխվել վերաբաշխման միջոցով:

const constVariable = 'I am a const variable';

Փոփոխական շրջանակի օրինակ

let a = 5;  // variable is initialized in the outer scope

for (let i = 0; i < 3; i++) { 

  // block scope with a for loop

  a = 3;  // a is accessible here, in an inner scope

  let b = 5;  // b is initialized in the inner scope

}

console.log(a);  // Output: 3

console.log(b);  // ReferenceError: b is not defined

Այս օրինակում «a» փոփոխականը հասանելի է բլոկի ներսում և դրսում, մինչդեռ «b»-ը հասանելի է միայն բլոկի ներսում:

Փոփոխականների, շրջանակի և տեսակների հասկանալը հիմնարար է հստակ և արդյունավետ ծրագրեր գրելու համար: Զգուշորեն անվանելով և օգտագործելով փոփոխականներ՝ դուք կարող եք ստեղծել կոդ, որը և՛ ֆունկցիոնալ է, և՛ հեշտ հասկանալի: