ცვლადები და პირობითი ოპერატორები

ცვლადი უფრო საცეცია, ვიდრე ყუთი

ცვლადის შექმნისას და მისთვის მნიშვნელობის მინიჭებისას, კომპიუტერის მეხსიერებაში ინახება ჩვენი ახალი მნიშვნელობას, რომელსაც ცვლადი ებღაუჭება "საცეცით". როდესაც ამ ცვლადს გამოვიყენებთ, წვდომას მოვიპოვებთ მოცემული ცვლადის მიერ "ჩაბღაუჭებულ" მნიშვნელობას. ცვლადისთვის მნიშვნელობის შეცვლისას, ცვლადის საცეცი ერთი მნიშვნელობიდან მეორე მნიშვნელობაზე გადადის. ილუსტრაცია მოცემულია პრეზენტაციაში.

var

ცვლადის შექმნა ასევე შეგვიძლია var keyword-ის გამოყენებით. ჯერ ვწერთ "var"-ს, შემდეგ ცვლადის სახელს, მერე მინიჭების ოპერატორს (=) და ბოლოს მისანიჭებელ მნიშვნელობას. let-ისგან განსხვავებით var-ით შეგვიძლია ორი ერთი და იმავე სახელის მქონე ცვლადის შექმნა.

var x = 10;
console.log(x); // 10
var x = 20;
console.log(x); // 20

let-ისგან განსხვავებით var-ით შექმნილი ცვლადი შეგვიძლია ჯერ გამოვიყენოთ და შემდეგ შევქმნათ, თუმცა ამას რაიმე პრაქტიკული დატვირთვა არ გააჩნია.

console.log(x); // undefined
var x = 10;

let-სა და var-ს შორის კიდევ ერთ განსხვავებას კონსპექტის ბოლოს გაეცნობით.

const

ისეთ ცვლადს, რომლის მნიშვნელობაც ვიცით რომ არ შეიცვლება, ვქმნით const keyword-ით. ასეთი ცვლადის მნიშვნელობის შეცვლისას პროგრამა დაგვირტყავს ერორს.

const PI = 3.14;
PI = 5; // error

Boolean ტიპის მნიშვნელობები

სულ გვაქვს ორი Boolean ტიპის მნიშვნელობა - true და false. true არის ჭეშმარიტი, მაგალითად - დედამიწა მრგვალია და false არის მცდარი, მაგალითად - დედამიწა ბრტყელია.

შედარების ოპერატორები

10 > 5; // true
5 < 10; // true
10 >= 9; // true
3 <= 3; // true
20 == 20; // true
20 == "20"; // true
20 === "20"; // false
10 != 15; // true
10 !== "10"; // true
10 != "10"; // false

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

10 == "10" არის true, რადგან სტრინგი "10" სცენის მიღმა გადაიყვანება რიცხვითი ტიპის მნიშვნელობად და ისე დარდება რიცხვ 10-ს, რაც true-ს გვიბრუნებს. ტიპების ასეთ ავტომატურა გადაყვანას ეწოდება type coercion.

if statements - პირობითი ოპერატორები

პროგრამა ყოველთვის ერთმანეთზე მიწყობილი ინსტრუქციების ერთობლიობა არაა, ზოგჯერ გვჭირდება კონკრეტული ფუნქციონალის განხორციელება, თუ რაიმე პირობა შესრულდება. ზუსტად ამისთვის ვიყენებთ პირობით ოპერატორებს.

if (პირობა - condition) {
  ფუნქციონალი - execution;
}

let x = 10;
if (x > 7) {
  console.log("მეტია 7-ზე");
}

else if

თუ ერთი პირობა არ გვაკმაყოფილებს და გვჭირდება მეორე პირობაც, მაშინ if ჯაჭვს ვაბავთ else if-ს. შეგვიძლია გამოვიყენოთ იმდენი else if ბლოკი რამდენიც დაგვჭირდება.

if (პირობა - condition) {
    ფუნქციონალი - execution
} else if (სხვა პირობა) {
    ფუნქციონალი - execution
}

let x = 30;
if (x > 10) {
  console.log("მეტია 10-ზე");
} else if (x > 5) {
  console.log("მეტია 5-ზე");
}

else

თუ ყველა საჭირო პირობა გვიწერია და კონკრეტული ფუნქციონალი უნდა სესრულდეს ყველა სხვა დანარჩენ შემთხვევაში, ასეთ დროს გამოვიყენებთ else ბლოკს if-else if ჯაჭვის ბოლოს.

if (პირობა - condition) {
    ფუნქციონალი - execution
} else if (სხვა პირობა) {
    ფუნქციონალი - execution
} else {
    ფუნქციონალი - execution
}

let x = 3;
if (x > 5) {
  console.log("მეტია 5-ზე");
} else if (x > 10) {
  console.log("მეტია 10-ზე");
} else {
  console.log("ნაკლებია ან ტოლი 5-ზე.");
}

let vs var პირობით ოპერატორებში

var-ით if, else if ან else ბლოკში შექმნილ ცვლადზე წვდომა შეგვიძლია ამ ბლოკას გარეთაც, რაც კარგი პრაქტიკა არაა. var-ს ისედაც არ ვიყენებთ. let-ით შექმნილი კი მხოლოდ იმ ბლოკში(ფიგურულ ფრჩხილებში) არსებობს, სადაც შეიქმნა.

if (true) {
    let x = 5;
}
console.log(x); ❌

if (true) {
    var x = 5;
}
console.log(x); ✅

Logical operators - ლოგიკური ოპერატორები

ჯავასკრფტში გვაქვს სამი ლოგიკური ოპერატორი - && (და), || (ან), ! (არა-NOT)

• && - "და" ლოგიკური ოპერატორის გამოყენების დროს თუ ერთ-ერთი პირობა მაინც false არის, მთლიანი მოცემულობა false-ია. ხოლო თუ ყველა true არის, მხოლოდ მაშინ იქნება მთლიანი მოცემულება true.

true && true; // true
true && false; // false
false && true; // false

• || - "ან" ლოგიკური ოპერატორის გამოყენების დროს თუ ერთ-ერთი პირობა მაინც არის true, მთლიანი მოცემულობა true გამოვა. ხოლო თუ ყველა false არის, მხოლოდ მაშინ იქნება მთლიანი მოცემულობა false.

true || false; // true
false || true; // true
false || false; // false

• ! - "NOT" ანუ უარყოფის ლოგიკური ოპერატორი ატრიალებს მნიშვნელობას. true-ს ხდის false-ს და პირიქით - false-ს ხდის true-ს.

!true; // false
!false; // true

switch case

if-ის მაგივრად ზოგჯერ შეიძლება გამოვიყენოთ switch, რომელიც უფრო გამოსადეგი არის რაიმე ცვლადის ან გამოსახულების გასატესტად - ანუ ცვლადის მნიშვნელობის შესაბამისად როცა გვინდა რაიმე ფუნქციონალის განხორციელება.

switch (expression) {
  case value1:
    // Code to execute if expression === value1
    break;
  case value2:
    // Code to execute if expression === value2
    break;
  // More cases as needed
  default:
  // Code to execute if none of the cases match
}

switch-ის ფრჩხილებში იწერება გასატესტი გამოსახულება, case-ებით იწერება ის მნიშვნელობა, რომელიც შეიძლება გამოსახულებამ მიიღოს. ქვევით ვუწერთ იმ ფუქნციონალს, რაც გვინდა რომ განხორციელდეს თუ გამოსახულება იმ მნიშვნელობას მიიღებს რაც ქეისში გვიწერია. და ბოლოს იწერება break, რადგან სწორი ქეისის აღმოჩენის შემდეგ აღარ გაგრძელდეს ქვევითა ქეისების ფუქნციონალის შესრულება. ქველა ქეისის მერე იწერება dafault case, რაც იგივე else არის.