ფუნქციური გამონათქვამების ნიუანსები JavaScript-ში
სახელწოდება Function Expression შერქმეულია არა უშედეგოდ. ის რეალურად ამას ნიშნავს - ანუ, რომ ასეთი ფუნქციები არიან რაიმე გამონათქვამის ნაწილი.
მაგალითად, ჩვენ შეგვიძლია მივუმატოთ რაიმე სტრიქონი და უსახელო ფუნქცია:
let str = 'str' + function() {return 3;};
console.log(str); // გამოიტანს 'strfunction() {return 3;}'
რატომ ვხედავთ ასეთ უცნაურ შედეგს,
და არა რიცხვს 3? იმიტომ, რომ მეორე დამატება
- ეს არ არის ფუნქციის მუშაობის შედეგი, არამედ მისი საწყისი
კოდი (რადგან ჩვენ ეს ფუნქცია არ გამოვიძახეთ, უბრალოდ
დავწერეთ).
ანუ სახელწოდება ფუნქციური გამონათქვამი ნიშნავს იმას, რომ ასეთი ფუნქცია იღებს მონაწილეობას რაიმე გამონათქვამში.
ცვლადისთვის მინიჭებაც გამონათქვამია:
let func = function() {
console.log('!');
};
ასევე შეიძლება, მაგალითად, გადავცეთ ფუნქცია
პარამეტრის სახით console.log-ში და ის გამოიტანს
მის საწყის კოდს კონსოლში - ესეც ჩაითვლება
გამონათქვამად:
console.log(function() {return 3;});
რატომ არის ეს მნიშვნელოვანი: იმიტომ, რომ განსხვავება Function Declaration-სა და Function Expression-ს შორის საერთოდ არაა იმაში, რომ პირველი ფუნქცია იქმნება სახელით, ხოლო მეორე თავდაპირველად სახელს არ აქვს. ეს ასე არაა.
მაგალითი. აი ჩვენ გვაქვს ფუნქცია სახელის გარეშე, მაგრამ ამასთან არ მონაწილეობს არცერთ გამონათქვამში (ანუ მასთან არ ხორციელდება არაიმეტორიული მოქმედებები, მარტივად რომ ვთქვათ):
/*
ეს ფუნქცია იქნება Function Declaration,
მაგრამ სინტაქსური შეცდომით:
*/
function() {
console.log('!');
}
ასეთი კოდი საერთოდ გამოიტანს შეცდომას! რატომ: რადგან ფუნქცია არ მონაწილეობს არცერთ გამონათქვამში, ბრაუზერი მას Function Declaration-ად თვლის, მაგრამ ვერ პოულობს მის სახელს და გამოსცემს შეცდომას.
იმისთვის, რომ შეცდომა გაქრეს, საჭიროა ფუნქცია
გავხადოთ რაიმე გამონათქვამის ნაწილი. მაგალითად,
დავწეროთ მის წინ ოპერაცია +:
+function() { // ასეთი კოდი კორექტულია
console.log('!');
};
როგორ მუშაობს ეს: თავისთავად ოპერაცია +
არაფერს არ აკეთებს, ეს იგივეა, რაც დაწეროთ
რიცხვის 3 ნაცვლად რიცხვი +3 - დასაშვებია,
მაგრამ არაფერს არ ცვლის.
მაგრამ ფუნქციის შემთხვევაში - ცვლის. ახლა ჩვენი ფუნქცია აღარაა უბრალოდ დაწერილი, არამედ მონაწილეობს გამონათქვამში. ამიტომ შეცდომა აღარ იქნება. ფუნქციის შესრულების შედეგიც არ იქნება, რადგან ჩვენ ის უბრალოდ დავწერეთ, მაგრამ არ გამოვიძახეთ.
+-ის ნაცვლად შეიძლება ყველაფერი, რაც მოგებულია.
მაგალითად:
-function() { // ასეთი კოდი კორექტულია
console.log('!');
};
!function() { // ასეთი კოდი კორექტულია
console.log('!');
};
ასევე შეიძლება ჩავსვათ ჩვენი ფუნქცია მრგვალ ფრჩხილებში, ამ შემთხვევაში ის ასევე გახდება ფუნქციური გამონათქვამი:
(function() { // ასეთი კოდი კორექტულია
console.log('!');
});
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
function func() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
let func = function() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
+function() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
!function func() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
-function func() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
1 + function func() {
console.log('!');
}
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
(function func() {
console.log('!');
})
განსაზღვრეთ, არის თუ არა წარმოდგენილი ფუნქცია Function Declaration თუ Function Expression:
console.log(
function() {
console.log('!');
}
);
