Ի՞նչ է JavaScript բարձրացումը:

Բարձրացնողի անգլերեն սահմանումը

Բարձրացրեք պարանների և ճախարակների միջոցով:

Բարձրացման հայեցակարգային սահմանում

Փոփոխականների և գործառույթների հայտարարագրերը ֆիզիկապես տեղափոխվում են ձեր կոդի վերևում:

Ըստ այս սահմանման, կոդը ստորեւ

console.log(y);
x();
let y = '';
function x () {}

կախարդական կերպով դառնում է

const y = '';
function x () {}
console.log(y);
x();

Ի՞նչ է տեղի ունենում իրականում:

Փոփոխականների և գործառույթների հայտարարագրերը դրվում են հիշողության մեջկազմման փուլում, բայց դրանք մնում են հենց այնտեղ, որտեղ գտնվում են ձեր կոդի մեջ:

Այս բացատրության նպատակով եկեք անվանենք մեր JavaScript կոմպիլյատորը՝ Jessie:

Քայլ 1.

Ջեսսին սկանավորում է փոփոխականների և ֆունկցիաների հայտարարագրերը և բեռնում դրանք դարակների մի կույտում, որը կոչվում է հիշողություն:

Քայլ 2.

Ջեսսին նայում է մեր կոդի մնացած հատվածին և գործարկում դրանք:

Գնդակները հարվածելիս Ջեսին նույնպես կգնա հիշողության մոտ՝ գտնելու հայտարարագրերը։

Վերոնշյալ դեպքում Ջեսսին գնում է հիշողություն և առբերում y-ը մինչև console.log(y) գործարկելը։

Ստորև բերված դեպքում Ջեսին գնում է հիշողություն՝ x ֆունկցիան գտնելու համար, նախքան x(-ը) գործարկելը:

Սովորական գուշակություն:

1. Ջեսին միայն հայտարարություններ է բարձրացնում:

console.log(n); // Jessie cannot find n, throws ReferenceError exception
n = 10;

n-ը վերը նշված օրինակում սկզբնավորումն է, այլ ոչ թե հռչակագիրը:

Ահա, թե ինչ կլինի, եթե չհայտարարեք n.

1. Ջեսին հայտարարություններ է փնտրում:
2. Հայտարարություններ չեն գտնվել
3. Ջեսին հանդիպում է console.log(n)
4. Ջեսին փորձում է հիշողության մեջ n գտնել
5. Ջեսին չի կարողանում գտնել n
6. Հիասթափված Ջեսսին թողնում է ReferenceError

Ահա, թե ինչ տեղի կունենա, եթե դուք հայտարարեք n՝

console.log(n); // 2. undefined is logged
const n = 10; // 1. Jessie puts n into memory

1. Ջեսին հայտարարություններ է փնտրում
2. Ջեսսին տեսնում է n-ը և պահում այն ​​հիշողության մեջ
3. Ջեսսին վազում է մնացած ծածկագրի միջով
4. Ջեսսին հանդիպում է console.log(n)
5. Ջեսին հիշողությունից n է գտնում
6. Ջեսին առաջինին կանչում է console.log(n)
7. Քանի որ n-ը դեռ սկզբնավորված չէ, undefined-ը գրանցված է

Հիմա դուք պետք է մտածեք, թե ինչու է n undefined-ը:

Դա պայմանավորված է նրանով, որ n-ը դեռ սկզբնավորվել չէ:

2. Հայտարարությունները կատարվում են նախքան սկզբնավորումը

console.log(n); // 2. undefined is logged
const n = 10; // 1. Jessie puts n into memory, 3. n is initialised
console.log(n) // 4. 10 is logged

Ահա ամբողջական պատմությունը.

1. Ջեսին հայտարարություններ է փնտրում
2. Ջեսսին տեսնում է n-ը և պահում այն ​​հիշողության մեջ
3. Ջեսսին վազում է մնացած ծածկագրի միջով
4. Ջեսին հանդիպում է առաջինինconsole.log(n)
5. Ջեսին հիշողությունից n է գտնում
6. Ջեսին առաջինին անվանում է console.log(n)
7. Քանի որ n-ը դեռ մեկնարկված չէ, undefined-ը գրանցված է
8. n-ն սկզբնավորվել է հավասար 10ի
9. Ջեսին կանչում է երկրորդինconsole.log(n)
10. 10 գրանցված է

Ամփոփում

• JavaScript կոմպիլյատորը նախ գտնում է բոլոր հայտարարությունները և բեռնում դրանք հիշողության մեջ:
• Այնուհետև JavaScript կոմպիլյատորը գործարկում է ծածկագրի մնացած մասը:
• Քանի որ ներքևում գրված փոփոխականներին և ֆունկցիաներին կարելի է մուտք գործել վերևում գրված կոդում, կապատրանք, որ հայտարարագրերը բարձրացվում են մինչև ձեր կոդի վերևը (Hoisting):

Շնորհակալություն կարդալու համար:

Հիշեք, որ այս գրառմանը մի քանի ծափ տվեք, եթե այն ձեզ դուր եկավ: