Asynchronous Programming JavaScript-ում (մաս 1/5) — 4 Հիմնական լուծումներ

Asynchronous պարադիգմը անփոխարինելի է JavaScript-ի համար

Սինխրոն ընդդեմ ասինխրոն

JS-ը մեկ շղթայական լեզու է: Այլ կերպ ասած, JS կոդը կատարվում է տող առ տող կատարման կույտի ներսում: Ինչպես գիտենք, կույտերը FILO են (First In Last Out), այսինքն, քանի դեռ նախորդ առաջադրանքը չի ավարտվել, հաջորդը պետք է սպասի իր հերթին:

Այս դիզայնի առավելությունն այն է, որ այն կարելի է հեշտությամբ հասնել, իսկ կատարման միջավայրը բավականին պարզ է: Բացասական կողմն այն է, որ եթե առաջադրանքներից մեկը հավերժ է պահանջում, մնացածը պետք է հերթ կանգնի: Օրինակ, արտաքին տեսքից զննարկիչը օգտատիրոջ համար «մեռած» է թվում, ինչը հաճախ հանգեցնում է օգտվողի անբավարար փորձի: Դրա հիմքում ընկած պատճառը կարող է լինել այն, որ կոդի բլոկը աշխատում է անսահման հանգույցով, և այդպիսով ամբողջ ծրագիրը խրված է:

JS-ը ներկայացնում է ասինխրոն պարադիգմ այս ծուղակը լուծելու համար: Ասինխրոն զանգերը վերաբերում են նրան, որ մեկ առաջադրանքը չի կատարվում միանգամից (սինխրոն), այլ բաժանվում է տարբեր փուլերի (ասինխրոն): Յուրաքանչյուր առաջադրանք ունի մեկ կամ մի քանի հետադարձ զանգ: Օրինակ, http հարցումները մեծապես հիմնված են ասինխրոն օրինաչափության վրա: Դրանք վարվում են ասինխրոն կերպով, քանի որ հարցումն ուղարկելուց հետո պատասխանն անմիջապես չի վերադառնա: Հետևաբար, հետադարձ զանգերն օգտագործվում են պատասխանը բռնելու համար, իսկ մնացած տրամաբանությունը մշակվում է հետադարձ զանգի ներսում:

Զանգեր

Սա ասինխրոն ծրագրավորման ամենահին լուծումներից մեկն է: Ենթադրենք, կան 2 գործառույթներ f1 և f2, և վերջինս պետք է սպասի, որ առաջինը արդյունք վերադարձնի, որպեսզի այն օգտագործի:

f1()
f2()

Եթե ​​f1-ի գործարկման համար երկար ժամանակ է պահանջվում, մենք կարող ենք ռեֆակտորել f2-ը և այն վերածել f1-ի հետ կանչի:

function f1(callback) {
   setTimeout(function () {
     // f1’s code
     // ..
     callback()
   }, 2000)
}

Երբ f1 կանչվում է, որպես փաստարկ օգտագործվում է f2:

f1(f2)

Օգտագործելով այս մեթոդը, f1-ը չի դառնա հավելվածի արգելափակող, և սա շատ բարդ տրամաբանությունը դադարեցնելու խելացի միջոց է մինչև հիմնական տրամաբանության ընթացքը:

Pro. հետադարձ զանգերը պարզ են հասկանալի և կիրառելի:

Դեմ. երբ տրամաբանությունը չափազանց բարդ է դառնում, հետադարձ զանգերը դժվարանում են կարդալ և պահպանել, երբ յուրաքանչյուր մաս դառնում է խիստ զուգակցված:

Իրադարձությունների վրա հիմնված ծրագրավորում

Մեկ այլ լուծում հիմնված է իրադարձությունների վրա. Անկախ նրանից, թե առաջադրանքը կատարվում է ամբողջությամբ, հիմնված է որոշակի տեսակի իրադարձության տեղի ունենալ-չլինելու վրա:

Սկզբում մենք կցում ենք իրադարձություն f1-ին:

f1.on(‘done’, f2)

Կոդի այս տողը նշանակում է, որ երբ «կատարված» իրադարձությունը գործարկվի, կկանչվի f2:

Հաջորդը, եկեք վերամշակենք f1-ը:

function f1() {
   setTimeout(function () {
     // f1’s code
     f1.trigger(‘done’)
   }, 2000)
}

f1.trigger('done') նշանակում է գործարկել «կատարված» իրադարձությունը f1-ի տրամաբանությունը գործարկելուց անմիջապես հետո, և f2-ը հետևում և կատարում է համապատասխանաբար:

Pro. այս օրինաչափությունը հեշտ է հասկանալի, հեշտ է անջատվել, և, հետևաբար, մոդուլյարացումը կարող է օգտագործվել դրա հետ մեկտեղ:

Դեմ. ամբողջ հավելվածը դառնում է իրադարձությունների վրա հիմնված, և տրամաբանական հոսքը դառնում է անհասկանալի և դժվար հասկանալի:

Հրապարակել/Բաժանորդագրվել

Մենք կարող ենք իրադարձություններին վերաբերվել որպես ազդանշանների: Ենթադրենք, որ կա ազդանշանային կենտրոն, և այն ազդանշան է հրապարակում, երբ առաջադրանքն ավարտվում է, որպեսզի մյուս առաջադրանքները կարողանան բաժանորդագրվել այս ազդանշանին և գործել համապատասխանաբար: Սա, այսպես կոչված, հրապարակել/բաժանորդագրվել օրինակ կամ դիտորդի օրինաչափություն է:

Օգտագործելով Ben Alman’s Tiny Pub/Sub-ը որպես օրինակ:

Նախ, f2-ը բաժանորդագրվում է «կատարված» ազդանշանին ազդանշանային կենտրոնի միջոցով:

jQuery.subscribe(‘done’, f2)

Հաջորդը, վերաշարադրեք f1 հետևյալը.

function f1() {
   setTimeout(function () {
     // f1’s code
     jQuery.publish(‘done’)
   }, 2000)
}

F1-ի կոդը գործարկելուց հետո այն հրապարակում է «կատարված» ազդանշան, և քանի որ f2-ը բաժանորդագրվել է նույն ազդանշանին, այն գործարկվում է դրանից հետո:

Բացի այդ, f2-ը կարող է նաև չեղարկել բաժանորդագրությունը կատարումից հետո։

jQuery.unsubscribe(‘done’, f2)

Pro. այս օրինաչափությունը նման է իրադարձությունների վրա հիմնված օրինաչափությանը, բայց մի փոքր ավելի լավ է այնպես, որ մենք կարող ենք ավելի ամբողջական պատկերացում կազմել հավելվածի մասին՝ ազդանշանի միջոցով ազդանշանների և բաժանորդների թվի հաշվառման միջոցով: կենտրոն.

Խոստումներ

Խոստումներ են առաջարկվել CommonJS խմբի կողմից ասինխրոն ծրագրավորման համար ստանդարտացված լուծում տրամադրելու վերաբերյալ: Պարզ ասած, յուրաքանչյուր ասինխրոն առաջադրանք վերադարձնում է խոստացված օբյեկտ, և այս օբյեկտն ունի այնուհետև ֆունկցիա, որն ընդունում է հետ կանչերը որպես փաստարկներ: Օրինակ՝ f1/f2-ի համար խոստումներ օգտագործելով.

f1().then(f2)

f1-ը պետք է վերաշարադրվի հետևյալով.

function f1() {
   var dfd = $.Deferred()
   setTimeout(function () {
   // f1’s code
   did.resolve()
  }, 2000)
 return did.promise
}

Pro. խոստումների օգտագործման ամենաակնհայտ առավելությունն այն է, որ հետադարձ զանգերը շղթայված են միմյանց հետ, ինչը հեշտացնում է կոդը կարդալը: Բացի այդ, հզոր API-ների մի ամբողջ շարք հասանելի է օգտագործման համար:

Օրինակ՝ օգտագործելով բազմաթիվ հետադարձ զանգեր:

f1().then(f2).then(f3)

Նաև կարգավորեք սխալները հետ կանչերի միջոցով:

f1().then(f2).fail(f3)

Կա բոնուս, որը գալիս է խոստումների օգտագործման հետ, որոնք նախորդ օրինաչափությունները չեն կարող ապահովել: Այսինքն, եթե առաջադրանքն ավարտվելուց ՀԵՏՈ հետադարձ զանգը կցվում է, այս հետ կանչը անմիջապես կանչվում է: Այս դեպքում, դուք չպետք է անհանգստանաք, որ բացակայում եք իրադարձությունների մշակիչի կարգավորումը կամ ազդանշանի բաժանորդագրվելը: Թեև իսկապես կա ուսուցման կոր՝ խոստումներ վերցնելու համար:

Հղում:

• http://www.ruanyifeng.com/blog/2012/12/asynchronous＿javascript.html