Ուսումնասիրելով JavaScript շարժիչի հիմունքները

Անդրադառնալով JavaScript շարժիչի աշխատանքի հիմնական սկզբունքներին

JavaScript-ը մեկ շղթայով լեզու է, քանի որ մեկ շղթայի վրա կոդ գործարկելիս այն կարող է իսկապես հեշտ լինել, քանի որ մենք ստիպված չենք լինի գործ ունենալ բազմաշերտ միջավայրում առաջացող բարդ սցենարների հետ: փակուղու պես: Քանի որ JavaScript-ը մեկ թելերով լեզու է, այն համաժամանակյա է: Լինելով մեկ շղթա, այն ունի մեկ զանգող փաթեթ:

Babelը այն կոմպիլյատորն է, որը վերցնում է ES6 կոդը և այն թարգմանում ES5:

JS Runtime

Հիշողության կույտ

Մեծ տարածք JS շարժիչի հիշողության մեջ, որտեղ տվյալները կարող են կուտակվել:

Call Stack

Սա այն վայրն է, որտեղ ձեր ամբողջ javascript կոդը մղվում և գործարկվում է մեկ առ մեկ, երբ թարգմանիչը կարդում է ձեր ծրագիրը, և դուրս է գալիս, երբ կատարումն ավարտված է:

Իրադարձությունների հանգույց

JavaScript-ն ունի գործարկման ժամանակի մոդել, որը հիմնված է իրադարձությունների հանգույցի վրա, որը պատասխանատու է կոդի կատարման, իրադարձությունների հավաքագրման և մշակման և հերթագրված ենթաառաջադրանքների կատարման համար:

Հետ կանչի հերթ

Ահա, որտեղ ասինխրոն կոդերը մղվում են և սպասում են, որ դրանք մղվեն զանգերի կույտի իրադարձությունների հանգույցի կողմից:

Վեբ API⏩ համաժամեցում՝

• DOM
• Բերել
• setTimeout ()

Համատեքստ

Կատարման համատեքստ

Յուրաքանչյուր կոչվող ֆունկցիայի համար այն ստեղծվել է կատարման համատեքստ: Ամեն անգամ, երբ մենք գործարկում ենք կոդը, գործարկվում է կատարման համատեքստում:

Գլոբալ կատարման համատեքստ

Կատարման վերջին համատեքստը Գլոբալ կատարման համատեքստն է: Գլոբալ կատարման համատեքստը ձևավորվում է Գլոբալ օբյեկտ(զննարկիչում պատուհանն է) և այսհիմնաբառը:

Javascript Engine-ը զննարկիչում ստեղծում է Global Execution Context:

Լեքսիկական միջավայր

Կատարման համատեքստը ցույց է տալիս, թե որ բառային միջավայրն է ներկայումս գործում: Լեքսիկական շրջանակը որոշում է մեր հասանելի փոփոխականները՝ կախված նրանից, թե որտեղ ենք մենք անվանում մեր գործառույթները: Առաջին բառային միջավայրը գլոբալ միջավայրն է:

Բարձրացում

Կազմման փուլում ֆունկցիայի հռչակագիրը գնում է կատարման գլոբալ համատեքստի վերևում: Javascript-ը վերլուծում է, թե ինչ ֆունկցիա կամ փոփոխական է ստեղծվում և հիշողություն է հատկացնում դրանց համար: Փոփոխականները մասամբ բարձրացված են, և գործառույթները ամբողջությամբ բարձրացված են: Այն փնտրում է «var» կամ «function» հիմնաբառը: Այն չի աշխատի «թող» կամ «կոնստ» համար:

Գործառույթներ

Սահմանում. հայտարարությունների մի շարք, որը կատարում է առաջադրանք կամ հաշվարկում է արժեքը, բայց որպեսզի ընթացակարգը որակվի որպես ֆունկցիա, այն պետք է վերցնի որոշակի մուտք և վերադարձնի ելք, որտեղ առկա է որոշակի ակնհայտ կապ մուտքագրման միջև: և ելքը։ Պարամետրերը ֆունկցիայի փոփոխականներ են:

Functions expression ➡ var canada= function(){}
Function declaration (get hoisted ) ➡ function india(){}
Function execution ➡ india()

Ֆունկցիայի արգումենտները գործառույթին փոխանցված (և ստացված) իրական արժեքներն են

Գործառույթի արգումենտ ➡ արգումենտներ հիմնաբառը օգնում է ստանալ բոլոր փաստարկները ֆունկցիայից: Պետք է օգտագործվի հետևյալ կերպ՝ console.log(Array.from(arguments)) 😀:

Մաքուր ֆունկցիանգործառույթ է, որը չունի կողմնակի ազդեցություններ, և եթե մուտքագրեք, կվերադարձնի նույն արդյունքը: Կողմնակի ազդեցությունները նշանակում են, եթե ֆունկցիան փոփոխում է ֆունկցիայից դուրս որևէ բան, օրինակ. axios զանգեր, զանգվածի մուտացիա, console.logs (որովհետև դա ազդում է փաստաթղթի վրա): Հեշտ է թեստավորել և կազմել, և կանխատեսելի:

• Ֆունկցիան մաքուր է, եթե այն զերծ է կողմնակի ազդեցություններից և վերադարձնում է նույն արդյունքը՝ հաշվի առնելով նույն մուտքը:
• Կողմնակի ազդեցությունները ներառում են. մուտքագրման փոփոխում, HTTP զանգեր, սկավառակի վրա գրել և էկրանին տպում:

Կատարյալ գործառույթները պետք է.

• անել 1 առաջադրանք, ունեն վերադարձի հայտարարություն
• լինել մաքուր, առանց ընդհանուր վիճակի
• անփոփոխ վիճակ (վերադարձրեք գլոբալ պետության նոր պատճենը)
• բաղադրելի, կանխատեսելի։

Իմպերատիվ ընդդեմ հռչակագրի

Իմպերատիվ ծածկագիր, որը մեքենային ասում է, թե ինչ և ինչպես անել: Մեքենայի կոդը հրամայական է: For loop-ն ավելի հրամայական է:

Դեկլարատիվ՝ ինչ անել և ինչ պետք է տեղի ունենա: Ավելի բարձր մակարդակի լեզուն ավելի դեկլարատիվ է, մենք չենք անհանգստանում հիշողության բաշխման մասին և այլն:

Փոփոխական միջավայր / Variable context → յուրաքանչյուր ֆունկցիայի համատեքստ

Շրջանակ

JS-ում շրջանակի 4 տեսակ՝ Block Scope, Global Scope, Function Scope և Module Scope:

Ֆունկցիայից դուրս հայտարարված փոփոխականն ունի Գլոբալ շրջանակ:

Ֆունկցիայի շրջանակն ընդդեմ արգելափակման շրջանակի

Ֆունկցիայի շրջանակըվերաբերում է այն շրջանակին, որը հասանելի է միայն գործառույթներում:

Օգտագործելու համար Block Scope ( ներսում if statement / for loops): Արգելափակման շրջանակը նշանակում է փոփոխականի հայտարարում գանգուր փակագծերի ներսում: — թող — հնարավորություն է տալիս ունենալ բլոկի շրջանակ։

Scope Chain —բոլոր գործառույթներն ունեն գլոբալ բառապաշարային միջավայր, հետևաբար սա մեզ թույլ է տալիս մուտք գործել գլոբալ փոփոխականներ: Լեքսիկական շրջանակը որոշում է, թե ինչ փոփոխականներ կան: Գործառույթները, որոնք ունեն այլ գործառույթներ, որպես իրենց ծնողների վերադարձի բաժնետոմսերի փոփոխականներ:

⚠ var — այն հասանելի է բլոկի շրջանակից դուրս (շրջանակից դուրս նշանակում է {}-ից դուրս)

Գլոբալ փոփոխականներ —այս փոփոխականների հիմնական խնդիրն այն է, որ մեկ այլ բաղադրիչի վրա գտնվող որևէ մեկը կարող է վերագրանցել այս փոփոխականները:

IIFE - անմիջապես կանչեց ֆունկցիայի արտահայտությունը: Կարող է զանգահարել անմիջապես հետո: Դա գործառույթի շրջանակն օգտագործելու տարբերակ է:

(function (){})()

Իրադարձությունների տարածումը մեխանիզմ է, որով մշակվում են Փաստաթղթի օբյեկտի մոդելի (DOM) իրադարձությունները: DOM-ը ներկայացնում է հանգույցների հիերարխիկ ծառանման կառուցվածք, որտեղ իրադարձությունը, որը տեղի է ունենում մեկ հանգույցի վրա, կարող է տարածվել նրա ծնողի, տատիկի և պապիկի և այլ նախնիների հանգույցների վրա:

JavaScript-ում կա իրադարձությունների տարածման երկու հիմնական եղանակ՝ փրփրացող և գրավում:

Փրփրացող մոդելում իրադարձությունը սկսվում է ամենախորը բնադրված տարրից և տարածվում նրա նախնիների միջով: Օրինակ, եթե օգտատերը սեղմում է կոճակը, սեղմման իրադարձությունը նախ կգրանցվի կոճակով, այնուհետև այն կհայտնվի իր մայր տարրերի միջով, մինչև հասնի փաստաթղթի տարրին:

Նկարահանում. նկարահանման մոդելում իրադարձությունը սկսվում է ամենահեռավոր տարրից և տարածվում է իր երեխաների միջով: Օրինակ, եթե օգտատերը սեղմում է կոճակը, սեղմման իրադարձությունը նախ կգրանցվի փաստաթղթի տարրով, այնուհետև այն կտարածվի իր զավակ տարրերի միջով, մինչև հասնի կոճակին:

«այս» հիմնաբառը

this այն օբյեկտն է, որի հատկությունն է ֆունկցիան:

JavaScript-ում this հիմնաբառը վերաբերում է օբյեկտին:

this ունի դինամիկ շրջանակ

Դա կախված է նաև նրանից, թե ինչպես է կոչվում ֆունկցիան:

• Մեթոդներին տալիս է հասանելիություն իրենց օբյեկտներին

• Կատարեք նույն կոդը բազմաթիվ օբյեկտների համար

⚠ Օբյեկտում, եթե մենք ունենք ֆունկցիա, որն իր մեջ ունի մեկ այլ ֆունկցիա՝ սա հիմնաբառով, եթե երկրորդ բառն անվանենք սա, այն չի վերադարձնի օբյեկտը, այլ կվերադարձնի պատուհանի օբյեկտը: Սա կարող է լուծվել arrow ֆունկցիայի կամ return function2.bind(this) միջոցով։ Սա տեղի է ունենում Javascript Engine-ի բառապաշարի ընթերցման պատճառով:

JavaScript-ում call(), apply() և bind() մեթոդները թույլ են տալիս կանչել ֆունկցիա՝ նշված this արժեքով և արգումենտներով:

• call() մեթոդը թույլ է տալիս կանչել ֆունկցիա՝ նշված this արժեքով և արգումենտներով, որոնք տրամադրվում են որպես ստորակետերով բաժանված ցուցակ:
• apply() մեթոդը նման է call() մեթոդին, սակայն արգումենտները փոխանցվում են որպես զանգված:
• bind() մեթոդը վերադարձնում է նոր ֆունկցիա՝ նշված this արժեքով և արգումենտներով՝ մասամբ կամ ամբողջությամբ կապված:

Համատեքստ ընդդեմ շրջանակի

Շրջանակը վերաբերում է փոփոխականների տեսանելիությանը, իսկ համատեքստը վերաբերում է այն օբյեկտին, որի շրջանակներում կատարվում է գործառույթը:

Տեսակները JS-ում.

Պրիմիտիվները (օրինակ՝ թվերը, տողերը և բուլյանները) պահվում են անմիջապես հիշողության մեջ, մինչդեռ ոչ պարզունակները (օրինակ՝ առարկաները և զանգվածները) պահվում են որպես հղումներ։ Պրիմիտիվներն ավելի արդյունավետ են հիշողությունը

Պրիմիտիվներըտվյալներ են, որոնք ներկայացնում են մեկ արժեք հիշողության մեջ: Տվյալների պարզունակ տեսակները փոփոխական չեն: JS-ում պարզունակ տվյալների արժեքը փոխելու համար մենք պետք է այն վերագրենք հիշողության մեջ նոր արժեքի՝ առանց նախորդը փոխելու:

• լար
• համար
• բուլյաններ
• անսահմանված - սահմանմանբացակայություն
• null — արժեքի բացակայություն
• Սիմվոլ:

⚠Բացառությունչսահմանված տեսակ = Օբյեկտ

Ոչ պարզունակ օբյեկտներ են: Օբյեկտը պահում է մեկ բանալի-արժեք զույգի կամ բազմաթիվ բանալի-արժեք զույգերի հղում/հասցե: Երբ մենք վերաբերում ենք օբյեկտին, մենք վերաբերվում ենք հիշողության մեջ գտնվող հասցեին՝ բանալի և արժեք զույգով:

• օբյեկտներ
• զանգվածներ
• գործառույթներ

Զանգվածները և ֆունկցիաներընաև օբյեկտներ են:

Անփոփոխելիություն, որը չի փոխում տվյալները կամ վիճակը: Մենք դա անում ենք՝ պատճենելով տվյալները կամ վիճակը և փոփոխում ենք պատճենը:

Ներկառուցված օբյեկտներ JS-ում.

• null
• չսահմանված
• անսահմանություն / մաթեմատիկա
• Տող
• Թիվ
• Բուլյան

Օբյեկտները փոխանցվում են հղումով:

Առանց obj1-ը փոխելու օբյեկտ2-ը փոխելու միջոց է տարածված օպերատորները: Spread օպերատորներն աշխատում են միայն օբյեկտի առաջին շերտի համար։ Այլ շերտերի համար ավելի լավ է օգտագործել JSON կամ խորը կլոնավորում:

Ինչպե՞ս համեմատել առարկաները:

function shallowEqual(object1, object2) {
   const keys1 = Object.keys(object1);
   const keys2 = Object.keys(object2);
   if (keys1.length !== keys2.length) {
    return false;
}
   for (let key of keys1) {
  if (object1[key] !== object2[key]) {
  return false;
}}
return true;}

Type Coercionնշանակում է, որ JS-ը տեսակը փոխակերպում է այլ տեսակի: Տիպի հարկադրանքը տեղի է ունենում, երբ դուք օգտագործում եք JS-ում «==»: Դա տեղի է ունենում նաև, եթե (1) = ճշմարիտ / եթե (0) = կեղծ:

JavaScript-ը դինամիկ տպագրված լեզու է, սակայն TypeScript-ը ստատիկ տպագրված լեզու է:

«Դինամիկ մուտքագրում» նշանակում է, որ արժեքի տեսակը որոշվում է գործարկման ժամանակ, մինչդեռ «ստատիկ մուտքագրում» նշանակում է, որ արժեքի տեսակը որոշվում է կոմպիլյացիայի ժամանակ:

Ֆունկցիան ընդդեմ օբյեկտներիՖունկցիան կանչվող օբյեկտներ են:

Սահմանել գործառույթ և կանչել

function abc (){} & abc() ➡abc.call()
const obj={ two :function (){return 2 }} ➡obj.two()
const four = new Function ('return 4') ➡ four()

Բարձր պատվերի ֆունկցիա՝

• ֆունկցիա, որն ընդունում է մեկ այլ ֆունկցիա որպես պարամետր
• գործառույթներ, որոնք վերադարձնում են մեկ այլ գործառույթ

• Կլոնավորել օբյեկտները

Դուք կարող եք ապահով կլոնավորել, այնուհետև մուտացնել ձեր մուտքագրումը: Պարզապես թողեք բնօրինակը անձեռնմխելի:

• Spread syntax (… syntax) օբյեկտները մակերևույթ կլոնավորելու ամենահեշտ ձևն է:
• JSON.parse(JSON.stringify(object)) օբյեկտները խորապես կլոնավորելու ամենադյուրին ճանապարհն է:

Փակումներ

Փակումները JS-ի առանձնահատկություններն են, որոնք հոգ են տանում, որ ֆունկցիան հասանելիություն ունենա իրենից դուրս գտնվող փոփոխականներին: փակումը մի ֆունկցիայի համակցություն է, որը միավորված է (կցված) իր շրջապատող վիճակի հղումներով (լեքսիկային միջավայր): Այլ կերպ ասած, փակումը թույլ է տալիս մուտք գործել արտաքին գործառույթի շրջանակը ներքին գործառույթից: JavaScript-ում փակումներ են ստեղծվում ամեն անգամ, երբ ստեղծվում է ֆունկցիա՝ ֆունկցիայի ստեղծման ժամանակ:

Փակման առավելություններն են հիշողության արդյունավետությունը և ինկապսուլյացիան:

Էկապսուլյացիա - թաքցնել տեղեկատվություն, որը պետք չէ դրսում տեսնել: Մեկ այլ ֆունկցիայի մեջ հայտարարված ֆունկցիան ուղղակիորեն չի ենթարկվում գլոբալ շրջանակի:

Հիշողության արդյունավետություն. հիշողության մեջ արժեքները պահելով՝ փակումները կարող են ավելի արդյունավետ լինել հիշողության մեջ, քան գլոբալ փոփոխականների օգտագործումը կամ արժեքների փոխանցումը որպես արգումենտ ֆունկցիաների միջև, քանի որ կարիք չկա անընդհատ տեղաբաշխել և տեղաբաշխել հիշողություն այս արժեքների համար:

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

function createCounter() {
  let count = 0;
  return function() {
    return count++;
  }
}

const counter = createCounter();
console.log(counter()); // 0
console.log(counter()); // 1
console.log(counter()); // 2

const closures = function (){
  let count =0
  return function increment (){
    count ++
    return count
  }
}

const incrementFn=closures()
console.log(incrementFn()) // return 1
console.log(incrementFn()) // return 2 

Նախատիպեր

JavaScript-ում նախատիպային ժառանգությունը նոր օբյեկտներ ստեղծելու մեխանիզմ է, որոնք ժառանգում են հատկություններ և մեթոդներ գոյություն ունեցող օբյեկտներից: Սա արվում է օգտագործելով օբյեկտի նախատիպի հատկությունը, որը մատնանշում է մեկ այլ օբյեկտ, որտեղից ժառանգվում են հատկությունները և մեթոդները:

Object.create() մեթոդն օգտագործվում է հատուկ նախատիպով նոր օբյեկտ ստեղծելու համար, իսկ Object.getPrototypeOf() մեթոդը՝ օբյեկտի նախատիպը ստանալու համար:

Ահա մի քանի օրինակներ, թե ինչպես կարող է օգտագործվել նախատիպային ժառանգությունը JavaScript-ում.

1. Ստեղծելով նոր օբյեկտ, որը ժառանգում է գոյություն ունեցող օբյեկտից.

const parent = {
  name: 'John',
  age: 30,
  sayHello: function() {
    console.log('Hello, my name is ' + this.name);
  }
}

const child = Object.create(parent);
console.log(child.name); // "John"
console.log(child.age); // 30
child.sayHello(); // "Hello, my name is John"

2. Օբյեկտին նոր հատկություններ և մեթոդներ ավելացնելը

const parent = {
  name: 'John',
  age: 30,
  sayHello: function() {
    console.log('Hello, my name is ' + this.name);
  }
}
const child = Object.create(parent);
child.gender = 'female';
child.sayGender = function(){console.log('I am '+ this.gender)}
console.log(child.gender); // "female"
child.sayGender(); // "I am female"

Տեսնելու համար, թե ինչ հատկություններ են ժառանգվում, կարելի է օգտագործել

obj.hasOwnProperty(property)
class Character {
  constructor(name,weapon){
    this.name=name;
    this.weapon=weapon}
  attack(){
      return 'attack with' + this.weapon;
}
}
class Elf extends Character{ // extends the prototype to point to character
  constructor (name,weapon,type){ // constructor gets run when is instaciated a new elf
  super(name,weapon); // extends super class to Character 
  this.type=house}
}
const dolby = new Elf('Doby','cloth', 'house') // use new to create new instances

Դասում extensions օգտագործելիս մենք պետք է օգտագործենք super:

console.log(dolby instance Elf) // true
console.log(dolby instance Character) // true

Dolby-ը դասի օրինակ է:

Ընդլայնում է ժառանգել ինչ-որ դասի իր հատկությունները:

Մասնավոր և հանրային OOP-ում:

class Elf extends Character{ // extends the prototype to point to character
 #age=54 // with hashtag we can add private state
constructor (name,weapon,type){ // constructor gets run when is instaciated a new elf
  super(name,weapon); // extends super class to Character 
  this.type=house}
}

Խոստումներ

Խոստումը առարկա է, որը երբեմն ապագայում կարող է արտադրել մեկ արժեք: Կա՛մ որոշիչ արժեք, կա՛մ մերժման արժեք: Խոստումը կարող է ունենալ երեք կարգավիճակ՝ առկախ, կատարված կամ մերժված:

Խոստումները ծառայում են նույն բաներին, ինչ հետադարձ զանգերը:

const promise = new Promise((resolve,rejects)=>{
  if(true){
    resolve('Stuff Work')}
  else{
    reject('Error, its broke')}
})

promise
.then(result=> result + '!')
.then(result2=>{
  // throw Error
  console.log(result2)}
.catch(()=>console.log(error))

Catch-ն աշխատում է միայն այն դեպքում, եթե որևէ սխալ «նետում» է:

Promise.all([promise1, promise2, promise3])
.then(values=>{
console.log(values})

// Will return and array of responses
// If any of promise fails all of them will fail, will go in a catch

վերադարձնել խոստումը, որը առկախ է: Խոստումները կարող են հաջողվել կամ ձախողվել մեկ անգամ:

ES8 → async/սպասում

Async await-ի օգտագործման նպատակը կոդն ավելի ընթեռնելի և սինխրոն դարձնելն է: Async սպասում են խոստումներ տակ կափարիչը, շարահյուսական շաքար է խոստումների.

Await-ը պետք է օգտագործվի ցանկացած ֆունկցիայի դիմաց, որը խոստում է տալիս:

Սխալները որսալու փոխարեն, համաժամեցված սպասելու փոխարեն, պետք է օգտագործել «փորձել բռնել»:

async function getData() {
  const promise1 = fetch('https://jsonplaceholder.typicode.com/posts/1').then(response => response.json());
  const promise2 = fetch('https://jsonplaceholder.typicode.com/posts/2').then(response => response.json());
  const promise3 = fetch('https://jsonplaceholder.typicode.com/posts/3').then(response => response.json());

  const results = await Promise.all([promise1, promise2, promise3]);
  console.log(results);
}
getData();

Տարածեք օպերատորները ES9 ES2018-ում՝ վերանայելու համար

Աշխատանքի հերթ — կամ microtask que-ն հերթական հերթն է, որը նման է հետադարձ կապի հերթին, որն ունի առաջնահերթություն:

Axios vs Fetch

Axios-ն ունի ավելի պարզ շարահյուսություն՝ համեմատած Fetch API-ի հետ, հատկապես, երբ խոսքը վերաբերում է սխալների մշակման և տվյալների ուղարկման հարցում հարցում: Axios-ը ավտոմատ կերպով սերիականացնում է հարցումների տվյալները որպես JSON, և այն ապահովում է սխալները կարգավորելու ավելի հարմար միջոց:

Axios-ը տրամադրում է հարցումը չեղարկելու ներկառուցված եղանակ, որը կարող է օգտակար լինել որոշակի սցենարներում: Fetch API-ի միջոցով դուք ինքներդ պետք է չեղարկեք՝ օգտագործելով AbortController.

GET հարցումը մարմին չունի:

//Fetch
fetch('https://example.com/api/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer my-secret-token'
  },
  body: JSON.stringify({
    key1: 'value1',
    key2: 'value2'
  })
})
  .then(response => response.json())
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });
// Axios 
axios.post('https://example.com/api/data', {
  key1: 'value1',
  key2: 'value2',
}, {
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer my-secret-token'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

Զուգահեռ կամ թեք կամ մրցավազք համաժամկետ կոդով

Մրցավազք › Զուգահեռ › Հաջորդականություն

Promise.race() ստատիկ մեթոդը ընդունում է մի կրկնվող խոստումներ որպես մուտքագրում և վերադարձնում է մեկ Promise: Այս վերադարձված խոստումը կարգավորվում է առաջին խոստման վերջնական վիճակի հետ, որը հաստատվում է:

Զուգահեռ օգտագործում Promise.all. օգտագործեք Promise.allSettled-ը, որպեսզի սխալ չստանաք, եթե խոստումներից մեկը ձախողվի:

Յուրաքանչյուր ֆունկցիայի համար սպասելիս օգտագործելու հաջորդականությունը, հետևաբար, համաժամանակյա կոդի ներսում համաժամանակյա է:

Բրաուզերը յուրաքանչյուր ներդիրի համար ստեղծում է նոր թեմա:

Սխալների մշակում

Սխալների տեսակները.

• նոր Սխալ
• նոր SyntaxError
• նոր ReferenceError

//Error is a constructor function
new Error('oopsie')

throw new Error(); // Error gets thrown and stops the program, 
// throw is used to display error 

Սխալն ունի երեք հատկություն.

• error.name
• error.message
• error.stack — ստեկի հետքը ստանալու համար

Catch-ը կարևոր է, որպեսզի ծրագիրը չդադարի գործել:

• փորձիր {} catch{}
• բռնել ()

async function (){
  try{
    await(axios.post....)

     }
  catch(err){
    console.log(err.message)
     }

}

Ֆունկցիոնալ ծրագրավորում

Ֆունկցիոնալ ծրագրավորումն առանձնացնում է տվյալները ֆունկցիաներում

• հասկանալի է
• հեշտ է երկարացնել
• հեշտ է հասկանալ
• հեշտ է պահպանել
• արդյունավետ հիշողություն

Ստեղծել այն գաղափարն է, որ ցանկացած տեսակի տվյալների փոխակերպումը պետք է ակնհայտ լինի: Մի քանի գործառույթ միասին կազմելու մեթոդ: Համակարգային դիզայն է: Pipe-ը կարող է փոխել ֆունկցիան կանչելու կարգը:

const compose =(f,g)=>data=>f(g(data))

const multiplyBy3=(num)=>num*3
const makePositive=(num)=>Math.abs(num)

const multiplyBy3AndAbsolute=compose(mutiplyBy3,makePositive)

multiplyBy3AndAbsolute(-50) // return 150

Անգիրացում — Արժեքները պահելու մեթոդ որսալ՝ դրանք հետագայում օգտագործելու համար՝ հավելվածներն արագացնելու համար:

Մոդուլներ

Խիստ ինքնամփոփ և խմբավորված միասին՝ իրենց սեփական ֆունկցիոնալությամբ, որը կառուցված է տեղաշարժվելու և աշխատելու համար:

Ուրախ կոդավորում: 💻