IIFE-ის ქვაქუშები JavaScript-ში

განვიხილოთ კოდის ორი ნაწყვეტი.

პირველი:

let result = 1
+function() {
	return 2;
}();

console.log(result);

მეორე:

let result = 1;
+function() {
	return 2;
}();

console.log(result);

ეს ორი კოდის ნაწყვეტი თითქმის იდენტურია, მაგრამ თუ მათ გაუშვებთ - შედეგი განსხვავებული იქნება. პირველი კოდი კონსოლში გამოიტანს რიცხვს 3, ხოლო მეორე - რიცხვს 1.

რატომ მოხდა ასეთი სხვაობა: მთელი საქმე იმაშია, რომ ერთ შემთხვევაში პირველი ხაზის ბოლოს არ არის მძიმითი, ხოლო მეორე შემთხვევაში - არის.

შეიძლება იკითხოთ: როგორ შეიძლება ასე, ბოლოს და ბოლოს JavaScript-ში მძიმითი ბრძანების ბოლოს არ არის სავალდებულო! სინამდვილეში ეს მთლად ასე არაა. მოდით გავარკვიოთ, რა ხდება ჩვენს თავზე სინამდვილეში.

პირველი კოდი შეგვიძლია გადავწეროთ ასე:

let result = 1 + function() {
	return 2;
}();

console.log(result); // გამოიტანს 3-ს

ახლა დაუყოვნებლივ ცხადი ხდება, რომ ერთიანს ემატება ფუნქციის დაუყოვნებლივ გამოძახების შედეგი, ანუ 2. ამიტომ საბოლოო შედეგი იქნება 3.

თუ კი ერთიანის შემდეგ დავსვამთ მძიმითს, კოდი ინტერპრეტატორის მიერ სხვაგვარად აღიქმება:

// პირველი ბრძანება:
let result = 1;

// მეორე ბრძანება:
+function() {
	return 2;
}();

// მესამე ბრძანება:
console.log(result); // გამოიტანს 1-ს

ანუ ცვლადში მინიჭება და ფუნქციის დაუყოვნებლივ გამოძახება გახდება სხვადასხვა ბრძანება. და ეს ყველაფერი მძიმითის არსებობის გამო!

გამოდის, რომ ამ შემთხვევაში ფუნქციის დაუყოვნებლივ გამოძახება პრინციპში არაფერს აკეთებს - უბრალოდ უშედეგოდ აბრუნებს რიცხვს 2, რომელიც არანაირად არ მოქმედებს ცვლად result-ზე.

მოდით გავარკვიოთ, რატომ შეგვიძლია საერთოდ არ დავწეროთ მძიმითი JavaScript-ში. მოდით გვქონდეს ასეთი კოდი მძიმითების გარეშე:

let result = 1 // result-ში ჩაიწერება 1
let test = 2   // test-ში ჩაიწერება 2

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

მაგრამ შეხედეთ ასეთ კოდს:

let result = 1
+ 2; // result-ში ჩაიწერება 3

ახლა პირველი ხაზის ბოლოს მძიმითი ავტომატურად არ ჩაისვამს, რადგან ინტერპრეტატორი ესმის, რომ მეორე ხაზის ბრძანება არის პირველი ხაზის ბრძანების ნაწილი.

მაგრამ თუ ჩვენ თვითონ დავსვამთ მძიმითს - შედეგი სრულიად სხვა იქნება:

let result = 1; // result-ში ჩაიწერება 1
+ 2; // ბრძანება არაფერს აკეთებს, მაგრამ შეცდომაც არ იქნება

გამოდის, რომ ინტერპრეტატორი თვითონ აყენებს მძიმითს, მხოლოდ იმ შემთხვევაში თუ შემდეგი ბრძანება არ არის წინა ბრძანების ნაწილი.

და ახლა შეხედეთ ამ კოდს:

let result = 1
+function() {
	return 2;
}();

console.log(result);

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