დასახელებული ფუნქციური გამონათქვამები JavaScript-ში

დავუშვათ, გვაქვს ასეთი ფუნქციური გამონათქვამი:

let test = function() {
	console.log('!');
};

test(); // გამოიტანს '!'

მივცეთ ჩვენს ფუნქციას სახელი func:

let test = function func() {
	console.log('!');
};

test();

როგორც უკვე იცით, ამ სახელით ფუნქციას მიმართვა არ შეიძლება:

let test = function func() {
	console.log('!');
};

test(); // გამოიტანს '!'
func(); // დააბრუნებს შეცდომას

მაშინ რათა აქვს სახელი ფუნქციას, თუ ის ხელმიწყობელი არ არის? საქმე იმაშია, რომ ეს სახელი იქნება ხელმიუწყობელი ფუნქციის გარეთ, მაგრამ ხელმიწყობელი ამ ფუნქციის შიგნით.

შევამოწმოთ:

let test = function func() {
	console.log(func); // ფუნქცია გამოიტანს საკუთარ წყარო კოდს
};

test(); // ვიძახებთ ფუნქციას

დავუძახოთ ჩვენი ფუნქცია მისი შიგნიდან:

let test = function func() {
	console.log('!'); // ვწერთ '!'
	func(); // ვიძახებთ საკუთარ თავს
};

test();

თუ ეს კოდი გავუშვებთ, კონსოლში გამოჩნდება უსასრულო რაოდენობის ჩანაწერი.

სინამდვილეში, ჩვენი ფუნქცია შეიძლება გამოიძახოს საკუთარი თავი არა მხოლოდ როგორც func, არამედ როგორც test:

let test = function func() {
	console.log('!');
	test(); // ვიძახებთ საკუთარ თავს
};

test();

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

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

ასეთ Function Expression-ებს ფუნქციის სახელით ეწოდება დასახელებული ფუნქციური გამონათქვამები.