სად „ცხოვრობს“ ცვლადი

რას ისწავლი

• რა არის ხილვადობის არე (scope)
• რით განსხვავდება ლოკალური ცვლადი გლობალურისგან
• რატომ არ ჩანს let-ით შექმნილი ცვლადი თავისი ბლოკის გარეთ

ოთახები და ფანჯრები

წარმოიდგინე სახლი. ეზოში დადებული ბურთი ყველა ოთახიდან ჩანს ფანჯრიდან. შენს ოთახში, მაგიდის უჯრაში შენახული რვეული კი მხოლოდ შენს ოთახში ჩანს: ეზოდან მას ვერავინ დაინახავს.

ცვლადებიც ასეა. ხილვადობის არე (scope) არის კოდის ის ნაწილი, საიდანაც ცვლადი ჩანს და შეიძლება მისი გამოყენება.

ლოკალური ცვლადი

ფუნქციის შიგნით შექმნილი ცვლადი და ფუნქციის პარამეტრები ლოკალურია (local): ისინი მხოლოდ ამ ფუნქციის შიგნით არსებობს.

function makeGreeting() {
  let message = "გამარჯობა!";
  console.log(message);   // მუშაობს
}

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

message ფუნქციის „ოთახშია“. როცა ფუნქცია დასრულდება, ის ქრება. გარედან მისი წაკითხვა შეუძლებელია. თუ ფუნქციის შედეგი გარეთ გჭირდება, ცვლადის გამოტანას კი არ ცდილობ, არამედ მნიშვნელობას return-ით აბრუნებ.

გლობალური ცვლადი

ყველა ფუნქციისა და ბლოკის გარეთ შექმნილი ცვლადი გლობალურია (global): ის ყველგან ჩანს, ფუნქციების შიგნითაც.

let playerName = "ბიტი";

function showPlayer() {
  console.log("მოთამაშე:", playerName);
}

showPlayer();   // მოთამაშე: ბიტი

მოსახერხებელი ჩანს, მაგრამ ფრთხილად: თუ ბევრი ფუნქცია ერთსა და იმავე გლობალურ ცვლადს ცვლის, ძნელი ხდება იმის გარკვევა, ვინ შეცვალა და როდის. კარგი ჩვევაა, ფუნქციამ რაც სჭირდება, პარამეტრებით მიიღოს, შედეგი კი return-ით დააბრუნოს.

ბლოკის ხილვადობა

let და const ცვლადები ნებისმიერი ბლოკის, ანუ ფიგურული ფრჩხილების შიგნით „ცხოვრობს“: არა მარტო ფუნქციაში, არამედ if-ში და ციკლშიც.

let age = 15;

if (age >= 13) {
  let label = "მოზარდი";
  console.log(label);   // მუშაობს
}

console.log(label);     // ReferenceError

ამიტომ for (let i = 0; ...)-ის i ციკლის შემდეგ აღარ არსებობს. ეს კარგია: ორ სხვადასხვა ციკლს შეუძლია ერთი და იგივე სახელი i გამოიყენოს და ერთმანეთს ხელი არ შეუშალოს.

ერთი სახელი, ორი ცვლადი

თუ ფუნქციის შიგნით შექმნი ცვლადს, რომელსაც გარე ცვლადის სახელი ჰქვია, შიგნით ახალი, ლოკალური ცვლადი იმოქმედებს, გარე კი ხელუხლებელი დარჩება. ამას დაჩრდილვა (shadowing) ჰქვია:

let color = "ლურჯი";

function paint() {
  let color = "წითელი";
  console.log(color);   // წითელი
}

paint();
console.log(color);     // ლურჯი

ეს შეცდომა არ არის, მაგრამ კოდს აბნევს. სხვადასხვა რამისთვის სხვადასხვა სახელი გამოიყენე.

სცადე თავად

გაუშვი და ნახე შეცდომა. მერე გაასწორე: ფუნქციამ ჯამი დააბრუნოს და ბოლო ხაზმა დაბრუნებული მნიშვნელობა დაბეჭდოს.

ხშირი შეცდომები

• ლოკალური ცვლადის გამოყენება გარეთ. ფუნქციის შედეგი return-ით გამოიტანე და არა ცვლადის სახელით.
• ცვლადის შექმნა if-ის შიგნით და გამოყენება გარეთ. თუ ცვლადი if-ის შემდეგაც გჭირდება, ის if-მდე შექმენი: let price; და ბლოკში მხოლოდ მნიშვნელობა მიანიჭე.
• ზედმეტი გლობალური ცვლადები. რაც ერთ ფუნქციას სჭირდება, მის შიგნით შექმენი.

function average(a, b, c) {
  let result = (a + b + c) / 3;
  return result;
}

let avg = average(7, 8, 9);
console.log("საშუალო:", avg);

მინი-ქვიზი

შეჯამება

• ხილვადობის არე განსაზღვრავს, საიდან ჩანს ცვლადი.
• ფუნქციის შიგნით შექმნილი ცვლადები და პარამეტრები ლოკალურია.
• გლობალური ცვლადი ყველგან ჩანს, მაგრამ ზედმეტად ნუ გამოიყენებ.
• let და const მხოლოდ თავის ბლოკში ჩანს, if-სა და ციკლშიც.