Font size
WorksheetsFunction, Scope and Closure
Total questions: 67
Worksheet time: 36mins
რომელი ვარიანტია სწორი Function Declaration?
const greet = function() { }
function greet() { }
() => console.log("Hi")
let greet = () => { }
რომელი მახასიათებელია მხოლოდ Function Declaration-ისთვის?
შეგიძლიათ გამოიძახო მის დაწერამდე
არ აქვს სახელი
ინახება ცვლადში
ყოველთვის ანონიმურია
რა გამოიტანს კოდი?
sayHi();
function sayHi() {
console.log("Hello");
}
Error
Hello
Undefined
Nothing
Function Declaration–ის hoisting როგორ მუშაობს?
მხოლოდ ცვლადი იწევა ზემოთ
მთელი ფუნქცია იწევა ზემოთ
სრულად არ ხდება hoisting
მხოლოდ return იწევა
შეგიძლიათ თუ არა ფუნქცია function declaration-ით შექმნა სხვა ფუნქციის შიგნით?
დიახ
არა
რომელი აღწერს სწორად function declaration-ის სქოუპს?
ყოველთვის გლობალურია
დამოკიდებულია სად შეიქმნა
ყოველთვის ბლოკურია
ყოველთვის მოდულარულია
რომელი მაგალითი აჩვენებს ფუნქციის დეკლარაციის გამოყენებას კონტექსტში?
if (true) {
function test() { return 1; }
}
console.log(typeof test);
"function"
"undefined"
"number"
Error
Function Declaration და Function Expression-ის განსხვავება ძირითადად არის…
სინტაქსი
hoisting
scope
ყველა ზემოთ ჩამოთვლილი
Function Declaration-ში რა ტიპის ფუნქციაა განსაზღვრული?
მხოლოდ ანონიმური
მხოლოდ სახელდებული
ორივე
არც ერთი
True or False: Function Declaration შეიძლება იყოს arrow function ფორმატით.
True
False
რომელი არის Function Expression-ის სწორი მაგალითი?
function greet() { }
let greet = function() { }
const greet() => { }
greet() = function { }
Function Declaration და Function Expression-hoisting-ის თვალსაზრისით: რომელია hoisted?”
Declaration იწევა ზემოთ, Expression — არა.
Expression იწევა ზემოთ, Declaration — არა.
რა გამოიტანს:
sayHello();
var sayHello = function() {
console.log("Hi");
};
Hi
Undefined
Error
არაფერი
True or False: Function Expression-ს ყოველთვის უნდა ჰქონდეს სახელი.
True
False
რა ტიპის მნიშვნელობა ინახება ცვლადში Function Expression-ის დროს?
primitive
reference (object)
number
undefined
როგორ შეგვიძლია ფუნქციის გამოძახება Function Expression-ის შემთხვევაში?
მხოლოდ მის განსაზღვრის შემდეგ
ნებისმიერი ადგილას
მხოლოდ შიდა ფუნქციიდან
ვერაფრით
როგორ შეგვიძლია ფუნქციის გამოძახება Function Expression-ის შემთხვევაში?
მხოლოდ მის განსაზღვრის შემდეგ
ნებისმიერ ადგილას
მხოლოდ შიდა ფუნქციიდან
ვერაფრით
რა არის IIFE (Immediately Invoked Function Expression)?
function() { }();
(function() { })();
{function() { }}();
function()() { };
Function Expression-ის მაგალითში რა ტიპის ფუნქციას ვიღებთ?
const sayHi = function greet() { console.log("Hi") }
სახელდებულ
ანონიმურ
ორმაგად განსაზღვრულ
არასწორი სინტაქსი
True or False: Function Expression–ით შექმნილი ფუნქცია ვერ გადაიწერება სხვა მნიშვნელობით.
True
False
Arrow function-ს არ აქვს საკუთარი:
scope
this
return
პარამეტრები
რომელი სინტაქსი სწორია?
let sum = (a, b) => a + b;
let sum(a, b) => { a + b; }
let sum = a, b => return a + b;
function => {}
რა გამოიტანს:
const add = (a,b) => a+b;
console.log(add(2,3));
5
6
7
8
Arrow function-ში რა არის განსხვავებული “this”-ის ქცევაში?
იგი იღებს this-ს გარე scope-იდან.
იგი აქვს საკუთარი this.
იგი არ აქვს this.
იგი ყოველთვის undefined-ია.
Arrow function შეიძლება იყოს:
Constructor
Generator
არც ერთი
ორივე
True or False: Arrow function-ს ავტომატურად აქვს return თუ {} არ არის გამოყენებუ
True
False
Arrow function შეიძლება იყოს:
Constructor
Generator
არც ერთი
ორივე
რა გამოიტანს: const say = () => console.log(this); say();
Window/Global Object
Function Object
Undefined
Error
Arrow function-ის გამოყენების უპირატესობაა:
მოკლე სინტაქსი
ავტომატური binding “this”-ზე
ორივე
არც ერთი
Arrow function-ში arguments ობიექტის ქცევა როგორია?
არ არსებობს
ყოველთვის ცარიელია
ერთი და იგივეა რაც parent scope-ში
ავტომატურად იქმნება
True or False: Arrow function-ს შეიძლება ჰქონდეს default parameters.
True
False
რა განსხვავებაა Function და Block scope შორის?
Function scope ვრცელდება მთელ ფუნქციაზე, Block scope კი {} შიგნით.
Block scope ვრცელდება მთელ ფუნქციაზე, Function scope კი {} შიგნით.
True or False: let და const ბლოკური scope-ის მქონეა.
True
False
რას გამოიტანს: if (true) { var x = 5; } console.log(x);
5
Error
რას გამოიტანს: if (true) { let y = 5; } console.log(y);
5
Error
რომელი მექანიზმი ქმნის ახალ scope-ს?
ფუნქცია
ციკლი
{} ბლოკი
ყველა ზემოთ ჩამოთვლილი
რომელი მექანიზმი ქმნის ახალ scope-ს?
ფუნქცია
ციკლი
{} ბლოკი
ყველა ზემოთ ჩამოთვლილი
როგორ შეგვიძლია დავიცვათ ცვლადები გლობალური დაბინძურებისგან?
ფუნქციებში ჩავდოთ
var გამოვიყენოთ
console.log გამოვიყენოთ
ყველგან დავწეროთ let
True or False: Function Scope ყოველთვის მოიცავს მის parent block-ს.
True
False
Lexical Scope ნიშნავს:
Scope განისაზღვრება ფუნქციის გამოძახების დროს
Scope განისაზღვრება ფუნქციის დაწერის ადგილით
Scope განისაზღვრება კომპილაციის დროს
Scope საერთოდ არ არსებობს
True or False: შიდა ფუნქციას აქვს წვდომა გარე ფუნქციის ცვლადებზე.
True
False
რომელი შემთხვევა არღვევს lexical scoping-ს?
A) eval()
B) hoisting
C) recursion
D) const usage
ყველა ფუნქციას აქვს საკუთარი lexical environment.
True
False
რომელი აღწერს სწორი კავშირის პრინციპს?
A) Child → Parent → Global
B) Global → Parent → Child
C) Random
D) მხოლოდ Global
რა არის Scope Chain JavaScript-ში?
A) ფუნქციის არგუმენტების სია
B) მექანიზმი, რომელიც აერთიანებს სკოუფებს და აძლევს ცვლადებზე წვდომას
C) DOM-ის სტრუქტურა
D) ცვლადების ტიპების სია
როგორ მუშაობს Scope Chain lookup?
A) ცვლადს ეძებს მხოლოდ მიმდინარე ბლოკში
B) ცვლადს ეძებს ქვემოდან ზემოთ — შიდა → გარე → გლობალურ სკოუფამდე
C) მხოლოდ გლობალურ ცვლადებში ეძებს
D) შემთხვევითა
რა გამოიტანს კოდი: let a = 10; function outer() { let b = 20; function inner() { console.log(a + b); } inner(); } outer();
10
20
30
Error
Scope Chain-ში როცა ცვლადი ვერ მოიძებნა არც ერთ დონეზე, რა ხდება?
იქმნება ავტომატურად
აგდებს ReferenceError-ს
აბრუნებს undefined-ს
გლობალურად ქმნის ცვლადს
რომელი პრინციპით ეძებს JS ცვლადებს?
Parent → Child
Global → Local
Local → Parent → Global
Random
True or False: Scope Chain არსებობს მხოლოდ ფუნქციების შემთხვევაში.
True
False
როგორ უკავშირდება Scope Chain და Lexical Scope ერთმანეთს?
Scope Chain იქმნება Lexical Scope-ის საფუძველზე
Lexical Scope მუშაობს Scope Chain-ის შემდეგ
ორი განსხვავებული მექანიზმია
Scope Chain გამოიყენება მხოლოდ async ფუნქციებში
რა გამოიტანს: let x = 5; function a() { let y = 10; function b() { let z = 15; console.log(x + y + z);
რა გამოიტანს: let x = 5; function a() { let y = 10; function b() { let z = 15; console.log(x + y + z); } b(); } a();
15
30
25
Error
რომელ ფუნქციას არ ექნება წვდომა გარე scope-ში არსებულ ცვლადზე?
ჩვეულებრივ Function Declaration-ს
Arrow function-ს
Global scope-ში აღწერილს
eval()–ში აღწერილს, როცა strict mode-ია ჩართული
რატომ არის Scope Chain მნიშვნელოვანი JS-ში?
ეხმარება კოდს ცვლადების პოვნაში და მოდულურობაში
აჩერებს hoisting-ს
ამცირებს შესრულების სიჩქარეს
საჭირო არაა თანამედროვე JS-ში
Closure ნიშნავს:
ფუნქციას რომელიც იძახებს საკუთარ თავს
შიდა ფუნქციას რომელსაც აქვს წვდომა გარე ფუნქციის ცვლადებზე
ფუნქციას რომელიც აბრუნებს undefined
არაფერი განსაკუთრებულს
True or False: Closure ინახავს ცვლადების მნიშვნელობებს, არა ბმულს (reference).
True
False
Closure-ს გამოყენების ტიპური შემთხვევებია:
მონაცემთა ინკაფსულაცია
private ცვლადების შექმნა
ფუნქციური მოდულები
ყველა ზემოთ ჩამოთვლილი
რომელი აღწერს closure-ის მეხსიერების პრობლემას?
memory leak
hoisting
blocking
garbage collection
Closure შეიძლება შეიქმნას:
მხოლოდ function declaration-ით
ნებისმიერი ფუნქციის ტიპით
მხოლოდ arrow function-ით
მხოლოდ IIFE-ით
როგორ შეგვიძლია გავწყვიტოთ closure reference?
გავანულოთ ცვლადი
გამოვიძახოთ delete
ჩავანაცვლოთ null-ით
ყველა ზემოთ ჩამოთვლილი
როგორ მუშაობს Lexical Scope-ში lookup chain?
ფუნქცია ეძებს ცვლადებს მხოლოდ საკუთარ სხეულში, სხვა scopes–ში ვერ მიწვდება.
ფუნქცია ეძებს ცვლადებს მეორედ მოსვლით მთელი კოდის execution დროს, runtime–ზე ცვლილებებს უყურებს.
ფუნქცია ეძებს ცვლადებს თავისი განსაზღვრის ადგილიდან ზემოთ მდებარე scopes-ში, სანამ არ იპოვის ან არ დასრულდება Global Scope.
ფუნქცია ეძებს ცვლადებს ქვედა ფუნქციებში, სადაც შეიძლება იმყოფებოდეს.
რას გამოიტანს:
const a = 5;
function x() {
const b = 10;
return function() {
return a + b;
}
}
console.log(x()());
5
10
15
x
როგორ ეწოდება Lexical Scope-ზე დაფუძნებულ მეხსიერების შენარჩუნებას?
Hoisting
Closure
Callback
Prototype inheritance
რატომ არის მნიშვნელოვანი Lexical Scope JS-ში?
იცავს ცვლადებს გლობალური კონფლიქტებისგან
განაპირობებს Hoisting–ს
ქმნის asynchronous ფუნქციებს
განსაზღვრავს HTML ელემენტების სტილს
რასგამოიტანს:
function makeCounter() {
let count = 0;
return function() {
count++;
return count;
}
}
const counter = makeCounter();
console.log(counter());
console.log(counter());
0 და 1
1 და 2
1
2
რატომ არ იკარგება “count”-ის მნიშვნელობა ზემოთ მოცემულ მაგალითში?
იმიტომ, რომ count რეგულარულად ასინქრონულად შენახულა
რადგან count გლობალური ცვლადია
იმიტომ, რომ inner ფუნქცია ქმნის closure, რომელიც ინახავს outer scope–ის ცვლადს
იმიტომ, რომ JavaScript ავტომატურად ინახავს ყველა ცვლადს ფუნქციის დასრულების შემდეგ
