Հոդվածներ

5.4. Լոգարիթմական գործառույթներ


Ուսուցման նպատակները

  • Լոգարիթմականից վերափոխել ցուցիչաձևի:
  • Փոխակերպել ցուցիչից լոգարիթմական ձևի:
  • Գնահատեք լոգարիթմները:
  • Օգտագործեք սովորական լոգարիթմներ:
  • Օգտագործեք բնական լոգարիթմներ:

2010 թվականին Հայիթիում տեղի ունեցավ խոշոր երկրաշարժ ՝ ավերելով կամ վնասելով ավելի քան 285,000 տուն: Մեկ տարի անց մեկ այլ, ավելի ուժեղ երկրաշարժ ավերեց Honապոնիայի Հոնսու քաղաքը ՝ ավերելով կամ վնասելով ավելի քան 332,000 շենքեր,ինչպես նկարում պատկերված ( PageIndex {1} ): Չնայած երկուսն էլ զգալի վնաս պատճառեցին, 2011-ի երկրաշարժը 100 անգամ ուժեղ էր Հայիթիի երկրաշարժից: Որտեղի՞ց գիտենք: Երկրաշարժերի ուժգնությունը չափվում է այնպիսի մասշտաբով, որը հայտնի է որպես Ռիխտերի սանդղակ: Հաիթիում տեղի ունեցած երկրաշարժը Ռիխտերի սանդղակով գրանցեց 7.0մինչդեռ ճապոնական երկրաշարժը գրանցել է 9.0:

Ռիխտերի սանդղակը բազային տասը լոգարիթմական սանդղակ է: Այլ կերպ ասած, (8 ) մագնիտուդով երկրաշարժը կրկնակի անգամ մեծ չէ, քան (4 ) մագնիտուդով երկրաշարժը: Դա է

[10 ^ {8−4} = 10 ^ 4 = 10,000 չհամարվող ]

անգամ այնքան լավ! Այս դասում մենք կուսումնասիրենք Ռիխտերի մասշտաբի բնույթն ու տասը բազայի գործառույթը, որոնցից դա կախված է:

Լոգարիթմականից էքսպոնենտալ ձևի փոխակերպում

Երկրաշարժերի ուժգնությունը վերլուծելու կամ երկու տարբեր երկրաշարժերի մեծությունները համեմատելու համար մենք պետք է կարողանանք փոխակերպել լոգարիթմական և էքսպոնենցիալ ձևերի միջև: Օրինակ ՝ ենթադրենք, որ մի երկրաշարժից ազատված էներգիայի քանակը 500 անգամ ավելի մեծ է, քան մյուսից ազատված էներգիայի քանակը: Մենք ուզում ենք հաշվարկել մեծության տարբերությունը: Այս խնդիրը ներկայացնող հավասարումն է (10 ​​^ x = 500 ), որտեղ (x ) ներկայացնում է Ռիխտերի սանդղակի մեծությունների տարբերությունը: Ինչպե՞ս կլուծեինք (x ) - ի համար:

Մենք դեռ չենք սովորել ցուցիչ հավասարումների լուծման մեթոդ: Մինչ այժմ քննարկված հանրահաշվական գործիքներից ոչ մեկը բավարար չէ (10 ​​^ x = 500 ) լուծելու համար: Մենք գիտենք, որ ({10} ^ 2 = 100 ) և ({10} ^ 3 = 1000 ), ուստի պարզ է, որ (x ) պետք է որևէ արժեք լինի 2-ից 3-ի միջև, քանի որ (y = {10} ^ x ) ավելանում է: Լուծումը ավելի լավ գնահատելու համար կարող ենք ուսումնասիրել գծապատկեր, ինչպես նկարում ( PageIndex {1} ):

Գրաֆիկից գնահատելը, սակայն, անճիշտ է: Հանրահաշվական լուծում գտնելու համար մենք պետք է նոր գործառույթ ներմուծենք: Դիտեք, որ Գծապատկերում ( PageIndex {2} ) գծապատկերն անցնի հորիզոնական գծի թեստը: (Y = b ^ x ) ցուցիչ գործառույթը մեկ-մեկ է, ուստի դրա հակադարձը ՝ (x = b ^ y ) նույնպես ֆունկցիա է: Ինչպես լինում է բոլոր հակադարձ գործառույթների դեպքում, մենք պարզապես փոխանակում ենք (x ) և (y ) և լուծում ենք (y ) - ի համար ՝ գտնելու հակադարձ ֆունկցիան: (Y ) որպես (x ) գործառույթ ներկայացնելու համար մենք օգտագործում ենք (y = { log} _b (x) ) ձևի լոգարիթմական ֆունկցիա: Հիմքը (b ) լոգարիթմ համարի այն արտահայտիչն է, որով մենք պետք է բարձրացնենք (b ) ՝ այդ թիվը ստանալու համար:

Մենք կարդում ենք լոգարիթմական արտահայտությունը. «Լոգարիթմը (b ) - ի (x ) բազայով հավասար է (y )», կամ, պարզեցված, «log հիմքը (b ) - ի (x ) ) է (y ) »: Կարող ենք նաև ասել. « (B ) (y ) - ի հզորությանը հասցվածը (x ) է», քանի որ տեղեկամատյանները ցուցանմուշներ են: Օրինակ, (32 ) բազայի (2 ) լոգարիթմը (5 ) է, քանի որ (5 ) այն արտահայտիչն է, որին մենք պետք է դիմենք (2 ) ՝ (32 ) ստանալու համար: Քանի որ (2 ^ 5 = 32 ), մենք կարող ենք գրել ({ log} _232 = 5 ): Մենք կարդում ենք սա, քանի որ «(32 ) - ի տեղեկամատյանների բազան (2 ) =" (5 ") է:

Լոգարիթմական ձևի և դրա համապատասխան ցուցիչ ձևի միջև կապը կարող ենք արտահայտել հետևյալ կերպ.

[ start {align} log_b (x) = y Leftrightarrow b ^ y = x, b> 0, b neq 1 end {align} ]

Նկատի ունեցեք, որ հիմքը (b ) միշտ դրական է:

Քանի որ լոգարիթմը ֆունկցիա է, այն ամենաճիշտ գրվում է որպես ( log_b (x) ) ՝ օգտագործելով փակագծեր ֆունկցիայի գնահատումը նշելու համար, ինչպես դա անում էինք (f (x) ) - ով: Այնուամենայնիվ, երբ մուտքագրումը մեկ փոփոխական է կամ թիվ, ընդունված է տեսնել փակագծերը իջած և արտահայտությունը գրված առանց փակագծերի, ինչպես ( log_bx ): Նկատի ունեցեք, որ շատ հաշվիչներ պահանջում են փակագծեր (x ) - ի շուրջ:

Լոգարիթմերի նշումը կարող ենք նկարագրել հետևյալ կերպ.

Ուշադրություն դարձրեք, որ, համեմատելով լոգարիթմի ֆունկցիան և ցուցիչ ֆունկցիան, մուտքն ու ելքը փոխարկվում են: Սա նշանակում է, որ (y = log_b (x) ) և (y = b ^ x ) հակադարձ գործառույթներ են:

Լոգարիթմական ֆունկցիայի սահմանում

Դրական թվի (b ) լոգարիթմի հիմքը բավարարում է հետևյալ սահմանումը:

Համար (x> 0 ), (b> 0 ), (b ≠ 1 ),

[ start {align} y = { log} _b (x) text {համարժեք է} b ^ y = x end {align} ]

որտեղ,

  • մենք կարդում ենք ({ log} _b (x) ) որպես «լոգարիթմ (x ) բազայի (b ) հիմքով» կամ (x ) - ի «log հիմք (b )»: «
  • լոգարիթմը (y ) այն արտահայտիչն է, որին պետք է բարձրացնել (b ) ՝ (x ) ստանալու համար:

Բացի այդ, քանի որ լոգարիթմական և ցուցիչ գործառույթները փոխում են (x ) և (y ) արժեքները, ցուցիչ գործառույթի տիրույթն ու տիրույթը փոխվում են լոգարիթմական ֆունկցիայի համար: Հետեւաբար,

  • լոգարիթմի գործառույթի տիրույթը (b ) բազայի հետ ((0, անպիտան) ) է:
  • լոգարիթմի գործառույթի միջակայքը (b ) բազայի հետ կազմում է ((- անպիտան, անպիտան) ):

Հարց-պատասխան. Կարո՞ղ ենք վերցնել բացասական թվի լոգարիթմը:

Ոչ. Քանի որ ցուցիչ ֆունկցիայի հիմքը միշտ դրական է, այդ բազայի ոչ մի ուժ չի կարող երբևէ բացասական լինել: Մենք երբեք չենք կարող վերցնել բացասական թվի լոգարիթմը: Բացի այդ, մենք չենք կարող վերցնել զրոյի լոգարիթմը: Հաշվիչները կարող են բացասական թվի մատյան դուրս բերել, երբ գտնվում են բարդ ռեժիմում, բայց բացասական թվի մատյանը իրական թիվ չէ:

Ինչպե՞ս. Հաշվի առնելով լոգարիթմական ձևով հավասարում ({ log} _b (x) = y ), այն փոխարկեք էքսպոնենտալ ձևի

  1. Ուսումնասիրեք (y = { log} _bx ) հավասարումը և նույնականացրեք (b ), (y ) և (x ):
  2. Վերաշարադրել ({ log} _bx = y ) որպես (b ^ y = x ):

Օրինակ ( PageIndex {1} ). Լոգարիթմական ձևից վերափոխում է ցուցիչ ձևի

Ստորև ցուցիչ տեսքով գրեք հետևյալ լոգարիթմական հավասարումները:

  1. ({ log} _6 ( sqrt {6}) = dfrac {1} {2} )
  2. ({ log} _3 (9) = 2 )

Լուծում

Սկզբում որոշեք (b ), (y ) և (x ) արժեքները: Դրանից հետո, գրեք հավասարումը (b ^ y = x ) տեսքով:

  1. ({ log} _6 ( sqrt {6}) = dfrac {1} {2} )

    Այստեղ (b = 6 ), (y = dfrac {1} {2} ) և (x = sqrt {6} ): Հետեւաբար, ({ log} _6 ( sqrt {6}) = dfrac {1} {2} հավասարումը համարժեք է

    (6 ^ { tfrac {1} {2}} = sqrt {6} )

  2. ({ log} _3 (9) = 2 )

    Այստեղ (b = 3 ), (y = 2 ) և (x = 9 ): Հետեւաբար, ({ log} _3 (9) = 2 ) հավասարումը համարժեք է

(3^2=9)

Ercորավարժություններ ( PageIndex {1} )

Ստորև ցուցիչ տեսքով գրեք հետևյալ լոգարիթմական հավասարումները:

  1. ({ log} _ {10} (1,000,000) = 6 )
  2. ({ log} _5 (25) = 2 )
Պատասխանել ա

({ log} _ {10} (1,000,000) = 6 ) համարժեք է ({10} ^ 6 = 1,000,000 )

Պատասխան բ

({ log} _5 (25) = 2 ) համարժեք է (5 ^ 2 = 25 )

Էքսպոնենտալից լոգարիթմական ձևի փոխակերպում

Էքսպոնենտներից լոգարիթմներ փոխարկելու համար մենք հետևում ենք նույն քայլերին: Մենք նույնացնում ենք հիմքը (b ), էքսպոնենտը (x ) և ելքը (y ): Դրանից հետո մենք գրում ենք (x = { log} _b (y) ):

Օրինակ ( PageIndex {2} ). Էքսպոնենտալ ձևից վերափոխվում է լոգարիթմական ձևի

Գրեք հետևյալ ցուցիչ հավասարումները լոգարիթմական տեսքով:

  1. (2^3=8)
  2. (5^2=25)
  3. ({10} ^ {- 4} = dfrac {1} {10,000} )

Լուծում

Սկզբում որոշեք (b ), (y ) և (x ) արժեքները: Դրանից հետո, գրեք հավասարումը (x = { log} _b (y) ձևով:

  1. (2^3=8)

    Այստեղ (b = 2 ), (x = 3 ) և (y = 8 ): Հետեւաբար, (2 ^ 3 = 8 ) հավասարումը համարժեք է ({ log} _2 (8) = 3 ):

  2. (5^2=25)

    Այստեղ (b = 5 ), (x = 2 ) և (y = 25 ): Հետեւաբար, (5 ^ 2 = 25 ) հավասարումը համարժեք է ({ log} _5 (25) = 2 ):

  3. ({10} ^ {- 4} = dfrac {1} {10,000} )

    Այստեղ (b = 10 ), (x = −4 ) և (y = dfrac {1} {10,000} ): Հետևաբար, ({10} ^ {- 4} = dfrac {1} {10,000} ) հավասարումը համարժեք է ({ log} _ {10} ձախ ( dfrac {1} {10,000} ) աջ) = - 4 ):

Ercորավարժություններ ( PageIndex {2} )

Գրեք հետևյալ ցուցիչ հավասարումները լոգարիթմական տեսքով:

  1. (3^2=9)
  2. (5^3=125)
  3. (2 ^ {- 1} = dfrac {1} {2} )
Պատասխանել ա

(3 ^ 2 = 9 ) համարժեք է ({ log} _3 (9) = 2 )

Պատասխան բ

(5 ^ 3 = 125 ) համարժեք է ({ log} _5 (125) = 3 )

Պատասխան գ

(2 ^ {- 1} = dfrac {1} {2} ) համարժեք է ({ log} _2 ձախ ( dfrac {1} {2} աջ) = - 1 )

Լոգարիթմերի գնահատում

Քառակուսիները, խորանարդները և թվերի արմատները իմանալը թույլ է տալիս մտավոր գնահատել շատ լոգարիթմեր: Օրինակ ՝ հաշվի առեք ({ log} _28 ): Մենք հարցնում ենք. «Ո՞ր արտահայտչի համար պետք է բարձրացնել (2 ) 8-ը ստանալու համար»: Քանի որ մենք արդեն գիտենք (2 ^ 3 = 8 ), դրանից հետեւում է, որ ({ log} _28 = 3 ):

Այժմ մտածեք լուծել մտավոր ({ log} _749 ) և ({ log} _327 ) մտքերը:

  • Մենք հարցնում ենք. «Ո՞ր արտահայտչի համար պետք է բարձրացնել (7 ), որպեսզի ստանանք (49 )»: Մենք գիտենք (7 ^ 2 = 49 ): Հետևաբար, ({ log} _749 = 2 )
  • Մենք հարցնում ենք. «Ո՞ր արտահայտչի համար պետք է բարձրացնել (3 ), որպեսզի ստանանք (27 )»: Մենք գիտենք (3 ^ 3 = 27 ): Հետևաբար, ( log_ {3} 27 = 3 )

Նույնիսկ որոշ թվացյալ ավելի բարդ լոգարիթմերը կարելի է գնահատել առանց հաշվիչի: Օրինակ ՝ եկեք մտավոր գնահատենք ( log _ { ce {2/3}} frac {4} {9} ):

  • Մենք հարցնում ենք. «Ի՞նչ արտահայտչի պետք է բարձրացնել ( ce {2/3} ), որպեսզի ստանանք ( ce {4/9} ): ”Մենք գիտենք (2 ^ 2 = 4 ) և (3 ^ 2 = 9 ), ուստի [{ ձախ ( dfrac {2} {3} աջ)} ^ 2 = dfrac {4} {9} nonumber ] Հետևաբար, [{ log} _ { ce {2/3}} ձախ ( dfrac {4} {9} աջ) = 2: չհամարվող ]

Ինչպե՞ս. Հաշվի առնելով ձևի լոգարիթմը (y = { log} _b (x) ), գնահատիր այն մտավոր կերպով

  1. Վերաշարադրել փաստարկը (x ) որպես (b ) ուժ ՝ (b ^ y = x ):
  2. Օգտագործեք (b ) նույնացնելու (y ) լիազորությունների վերաբերյալ նախկին գիտելիքները ՝ հարցնելով. «Ո՞ր արտահայտչի համար պետք է բարձրացնել (b ) ՝ (x ) ստանալու համար»:

Օրինակ ( PageIndex {3} ). Լոգարիթմների մտավոր լուծում

Լուծեք (y = { log} _4 (64) ) ՝ առանց հաշվիչ օգտագործելու:

Լուծում

Սկզբից մենք վերաշարադրում ենք լոգարիթմը էքսպանենսիվ տեսքով ՝ (4 ^ y = 64 ): Հաջորդը, մենք հարցնում ենք. «Ի՞նչ արտահայտչի պետք է բարձրացնել (4 ), որպեսզի ստանանք (64 )»:

Մենք գիտենք

(4^3=64)

Հետեւաբար,

({ log} _4 (64) = 3 )

Ercորավարժություններ ( PageIndex {3} )

Լուծեք (y = { log} _ {121} (11) ) ՝ առանց հաշվիչ օգտագործելու:

Պատասխանել

({ log} _ {121} (11) = dfrac {1} {2} ) (հիշեցնելով, որ ( sqrt {121} = {(121)} ^ { tfrac {1} {2} } = 11) )

Օրինակ ( PageIndex {4} ). Փոխադարձության լոգարիթմի գնահատում

Գնահատեք (y = { log} _3 ձախ ( dfrac {1} {27} աջ) ) ՝ առանց հաշվիչ օգտագործելու:

Լուծում

Նախ `մենք լոգարիթմը վերաշարադրում ենք ցուցիչ տեսքով. (3 ^ y = dfrac {1} {27} ): Հաջորդը, մենք հարցնում ենք. «Ի՞նչ արտահայտչի պետք է բարձրացնել (3 ), որպեսզի ստանանք ( dfrac {1} {27} )»:

Մենք գիտենք (3 ^ 3 = 27 ), բայց ի՞նչ պետք է անենք, որ ստացվի փոխադարձը, ( dfrac {1} {27} ): Վերհիշողների հետ աշխատելուց հետ կանչեք, որ (b ^ {- a} = dfrac {1} {b ^ a} ): Մենք օգտագործում ենք այս տեղեկատվությունը գրելու համար

[ start {align *} 3 ^ {- 3} & = dfrac {1} {3 ^ 3} & = dfrac {1} {27} end {align *} ]

Հետևաբար, ({ log} _3 ձախ ( dfrac {1} {27} աջ) = - 3 ):

Exորավարժություններ ( PageIndex {4} )

Գնահատեք (y = { log} _2 ձախ ( dfrac {1} {32} աջ) ) ՝ առանց հաշվիչ օգտագործելու:

Պատասխանել

({ log} _2 ձախ ( dfrac {1} {32} աջ) = - 5 )

Օգտագործելով սովորական լոգարիթմներ

Երբեմն կարող է տեսնել, որ առանց հիմքի գրված է լոգարիթմ: Այս դեպքում մենք ենթադրում ենք, որ հիմքը (10 ​​) է: Այլ կերպ ասած, ( log (x) ) արտահայտությունը նշանակում է ({ log} _ {10} (x) ) արտահայտությունը: Մենք կոչում ենք բազայի (- 10 ) լոգարիթմ ա ընդհանուր լոգարիթմ, Բաժնի սկզբում նշված Ռիխտերի սանդղակը չափելու համար օգտագործվում են ընդհանուր լոգարիթմներ: Աստղերի պայծառությունն ու թթուների և հիմքերի pH- ը չափելու կշեռքում օգտագործվում են նաև սովորական լոգարիթմներ:

Համընդհանուր լոգարիթմի սահմանում

Ընդհանուր լոգարիթմը լոգարիթմ է `հիմքով (10 ​​): Մենք գրում ենք ({ log} _ {10} (x) ) պարզապես որպես ( log (x) ): (X ) դրական թվի ընդհանուր լոգարիթմը բավարարում է հետևյալ սահմանումը:

Համար (x> 0 ),

[ start {align} y = { log} (x) text {համարժեք է} {10} ^ y = x end {align} ]

Մենք կարդում ենք ( log (x) ) ՝ որպես «լոգարիթմը (x ) բազայի (10 ​​) հիմքով» կամ «log բազային (10 ​​) (x )»:

Լոգարիթմը (y ) այն արտահայտիչն է, որին պետք է բարձրացվի (10 ​​) ՝ (x ) ստանալու համար:

Ինչպե՞ս. Հաշվի առնելով ձևի ընդհանուր լոգարիթմը (y = log (x) ), գնահատիր այն մտովի

  1. Վերափոխեք (x ) փաստարկը որպես (10 ​​) ուժ ՝ ({10} ^ y = x ):
  2. Օգտագործեք (10 ​​) - ի լիազորությունների վերաբերյալ նախկին գիտելիքները ` (y ) նույնականացնելու համար` հարցնելով. «Ո՞ր ցուցիչին պետք է բարձրացնել (10 ​​), որպեսզի ստանանք (x )»:

Օրինակ ( PageIndex {5} ). Ընդհանուր լոգարիթմի արժեքը մտավոր գտնելով

Գնահատեք (y = մատյան (1000) ) ՝ առանց հաշվիչ օգտագործելու:

Լուծում

Սկզբից մենք վերաշարադրում ենք լոգարիթմը էքսպենսենսիվ տեսքով. ({10} ^ y = 1000 ): Հաջորդը, մենք հարցնում ենք. «Ո՞ր արտահայտչի համար պետք է բարձրացնել (10 ​​), որպեսզի ստացվի (1000 )»: Մենք գիտենք

({10}^3=1000)

Հետեւաբար, ( տեղեկամատյան (1000) = 3 ):

Exորավարժություններ ( PageIndex {5} )

Գնահատեք (y = log (1,000,000) ):

Պատասխանել

( տեղեկամատյան (1,000,000) = 6 )

Ինչպե՞ս. Հաշվի առնելով ընդհանուր լոգարիթմը (y = log (x) ձևի հետ, գնահատեք այն ՝ օգտագործելով հաշվիչ

  1. Մամուլ [LOG].
  2. Մուտքագրեք (x ) - ի համար տրված արժեքը, որին հաջորդում է [ ) ].
  3. Մամուլ [Մուտքագրեք].

Օրինակ ( PageIndex {6} ). Հաշվիչ օգտագործելով ընդհանուր լոգարիթմի արժեքը

Հաշվիչի միջոցով գնահատեք (y = տեղեկամատյան (321) ) մինչև չորս տասնորդական կետ:

Լուծում

  • Մամուլ [LOG].
  • Մուտքագրեք 321, որին հաջորդում է [ ) ].
  • Մամուլ [Մուտքագրեք].

Կլորացնելով չորս տասնորդական կետ, ( log (321) ≈2.5065 ):

Վերլուծություն

Նկատի ունեցեք, որ ({10} ^ 2 = 100 ) և որ ({10} ^ 3 = 1000 ): Քանի որ (321 ) գտնվում է (100 ) և (1000 ) միջև, մենք գիտենք, որ ( log (321) ) պետք է լինի ( log (100) ) և ( log ( 1000) ): Սա մեզ տալիս է հետևյալը.

(100<321<1000)

(2<2.5065<3)

Ercորավարժություններ ( PageIndex {6} )

Հաշվիչի միջոցով գնահատեք (y = տեղեկամատյան (123) ) մինչև չորս տասնորդական կետ:

Պատասխանել

( տեղեկամատյան (123) ≈2.0899 )

Օրինակ ( PageIndex {7} ). Իրական աշխարհի ցուցիչ մոդելի վերաշարադրում և լուծում

Մեկ երկրաշարժից ազատված էներգիայի քանակը (500 ) անգամ ավելի մեծ էր, քան մյուսից արտանետված էներգիայի քանակը: ({10} ^ x = 500 ) հավասարումը ներկայացնում է այս իրավիճակը, երբ (x ) Ռիխտերի սանդղակի մեծությունների տարբերությունն է: Մոտակա հազարերորդը ո՞րն էր մեծությունների տարբերությունը:

Լուծում

Մենք սկսում ենք լոգարիթմական տեսքով վերաշարադրելով ցուցիչ հավասարումը:

({10} ^ x = 500 )

( մատյան (500) = x ) Օգտագործեք ընդհանուր մատյանի սահմանումը:

Հաջորդը մենք գնահատում ենք լոգարիթմը `օգտագործելով հաշվիչ.

  • Մամուլ [LOG].
  • Մուտքագրեք (500 ), որին հաջորդում է [ ) ].
  • Մամուլ [Մուտքագրեք].
  • Մոտակա հազարերորդ, ( log (500) ≈2.699 ):

Մագնիտուդների տարբերությունը մոտավորապես (2.699 ) էր:

Exորավարժություններ ( PageIndex {7} )

Մեկ երկրաշարժից արձակված էներգիայի քանակը (8500 ) անգամ ավելի մեծ էր, քան մյուսից արտանետված էներգիայի քանակը: ({10} ^ x = 8500 ) հավասարումը ներկայացնում է այս իրավիճակը, երբ (x ) - Ռիխտերի սանդղակի մեծությունների տարբերությունն է: Մոտակա հազարերորդը ո՞րն էր մեծությունների տարբերությունը:

Պատասխանել

Մագնիտուդների տարբերությունը մոտավորապես (3.929 ) էր:

Օգտագործելով բնական լոգարիթմներ

Լոգարիթմների համար առավել հաճախ օգտագործվող հիմքը (e ) է: Բազային (ե ) լոգարիթմերը կարևոր են հաշվում և որոշ գիտական ​​կիրառություններում: նրանք կոչվում են բնական լոգարիթմներ, Հիմքի (e ) լոգարիթմը, ({ log} _e (x) ), ունի իր սեփական նշումը, ( ln (x) ): ( Ln (x) ) - ի մեծագույն արժեքները կարելի է գտնել միայն հաշվիչի միջոցով: Հիմնական բացառությունն այն է, որ քանի որ (1 ) լոգարիթմը ցանկացած հիմքում միշտ (0 ) է, ( ln1 = 0 ): Այլ բնական լոգարիթմների համար մենք կարող ենք օգտագործել ( ln ) ստեղնը, որը կարելի է գտնել գիտական ​​հաշվիչների մեծ մասում: Մենք կարող ենք նաև գտնել (e ) ցանկացած ուժի բնական լոգարիթմ ՝ օգտագործելով լոգարիթմների հակադարձ հատկությունը:

ԲՆԱԿԱՆ ԼՈԳԱՐԻԹՄԻ ՍԱՀՄԱՆՈՒՄ

Բնական լոգարիթմը լոգարիթմ է ՝ հիմքով (e ): Մենք գրում ենք ({ log} _e (x) ) պարզապես որպես ( ln (x) ): Դրական թվի բնական լոգարիթմը (x ) բավարարում է հետևյալ սահմանումը:

Համար (x> 0 ),

(y = ln (x) ) համարժեք է (e ^ y = x )

Մենք կարդում ենք ( ln (x) ) որպես «լոգարիթմ (x ) բազայի (e ) հիմքով» կամ « (x ) բնական լոգարիթմ»:

Լոգարիթմը (y ) այն արտահայտիչն է, որին պետք է բարձրացնել (e ) ՝ (x ) ստանալու համար:

Քանի որ (y = e ^ x ) և (y = ln (x) ) գործառույթները հակադարձ գործառույթներ են, ( ln (e ^ x) = x ) գործառույթները բոլորի համար (x ) և (e ^ { ln (x)} = x ) համար (x> 0 ):

Ինչպե՞ս. Հաշվի առնելով բնական լոգարիթմ ՝ (y = ln (x) ձևով, գնահատեք այն ՝ օգտագործելով հաշվիչ

  1. Մամուլ [LN].
  2. Մուտքագրեք (x ) - ի համար տրված արժեքը, որին հաջորդում է [ ) ].
  3. Մամուլ [Մուտքագրեք].

Օրինակ ( PageIndex {8} ). Հաշվիչի միջոցով բնական լոգարիթմի գնահատում

Հաշվիչի միջոցով գնահատեք (y = ln (500) ) չորս տասնորդական կետ:

Լուծում

  • Մամուլ [LN].
  • Մուտքագրեք (500 ), որին հաջորդում է [ ) ].
  • Մամուլ [Մուտքագրեք].

Կլորացնելով չորս տասնորդական կետի ՝ ( ln (500) ≈6.2146 )

Ercորավարժություններ ( PageIndex {8} )

Գնահատեք ( ln (−500) ):

Պատասխանել

Իրական թվերի բազմության մեջ հնարավոր չէ վերցնել բացասական թվի լոգարիթմը:

Լրատվամիջոցներ

Մուտք գործեք այս առցանց ռեսուրսը ՝ լոգարիթմներով լրացուցիչ հրահանգների և պրակտիկայի համար:

  • Լոգարիթմների ներածություն

Հիմնական հավասարումներ

Լոգարիթմական ֆունկցիայի սահմանում (X> 0 ), (b> 0 ), (b ≠ 1 ), (y = { log} _b (x) ), եթե և միայն եթե ((^ ^ = x) )
Ընդհանուր լոգարիթմի սահմանումFor (x> 0 ), (y = log (x) ) եթե և միայն եթե ({10} ^ y = x ):
Բնական լոգարիթմի սահմանում (X> 0 ), (y = ln (x) ) համար, եթե և միայն եթե (e ^ y = x ):

Հիմնական հասկացություններ

  • Էքսպոնենտալ ֆունկցիայի հակադարձը լոգարիթմական ֆունկցիա է, իսկ լոգարիթմական ֆունկցիայի հակադարձը ՝ էքսպոնենտալ ֆունկցիա:
  • Լոգարիթմական հավասարումները կարող են գրվել համարժեք ցուցիչ տեսքով ՝ օգտագործելով լոգարիթմի սահմանում: Տեսեք օրինակ ( PageIndex {1} ):
  • Էքսպոնենտալ հավասարումները կարող են գրվել իրենց համարժեք լոգարիթմական տեսքով ՝ օգտագործելով լոգարիթմի սահմանման տե՛ս Օրինակ ( PageIndex {2} ):
  • Լոգարիթմական ֆունկցիաները `հիմքով (b ) կարող են գնահատվել մտավոր կերպով` օգտագործելով (b ) ուժերի նախկին գիտելիքները: Տե՛ս Օրինակ ( PageIndex {3} ) և Օրինակ ( PageIndex {4} ):
  • Ընդհանուր լոգարիթմերը կարող են գնահատվել մտավոր կերպով `օգտագործելով (10 ​​) ուժերի նախկին գիտելիքները: Տեսեք օրինակ ( PageIndex {5} ):
  • Երբ ընդհանուր լոգարիթմերը չեն կարող մտավոր գնահատվել, կարելի է օգտագործել հաշվիչ: Տեսեք օրինակ ( PageIndex {6} ):
  • Հիմքի (10 ​​) հետ կապված իրական ցուցիչ խնդիրները կարող են վերաշարադրվել որպես ընդհանուր լոգարիթմ, այնուհետև գնահատվել հաշվիչի միջոցով: Տեսեք օրինակ ( PageIndex {7} ):
  • Բնական լոգարիթմերը կարելի է գնահատել `օգտագործելով հաշվիչ Օրինակ ( PageIndex {8} ).

Գծապատկերային լոգարիթմական գործառույթներ [5.4] 2. Տրված է f (x) = 4 (2) *: ա Գտեք f & # x27 (x): Նշում. Ձեր գործառույթը պետք է լինի մեկ լոգարիթմ, ուստի անհրաժեշտության դեպքում օգտագործեք բազային բանաձևի փոփոխությունը:

help_outline

Պատկերի արտագրումփակել

Գծապատկերային լոգարիթմական գործառույթներ [5.4] 2. Տրված է f (x) = 4 (2) *: ա Գտեք f & # x27 (x): Նշում. Ձեր գործառույթը պետք է լինի մեկ լոգարիթմ, ուստի անհրաժեշտության դեպքում օգտագործեք բազային բանաձևի փոփոխությունը:


Լուան դինամիկ մուտքագրված լեզու է: Սա նշանակում է, որ փոփոխականները չունեն միայն տիպեր, որոնք ունեն արժեքները: Լեզուում տիպի սահմանումներ չկան: Բոլոր արժեքներն իրենց տեսակն են կրում:

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

Lua- ում կա ութ հիմնական տեսակ. զրո, բուլյան, թիվ, լարային, գործառույթ, օգտագործողի տվյալները, թել, և սեղան, Տեսակը զրո ունի մեկ միասնական արժեք, զրո, որի հիմնական հատկությունը պետք է տարբերվի ցանկացած այլ արժեքից, այն հաճախ ներկայացնում է օգտակար արժեքի բացակայություն: Տեսակը բուլյան ունի երկու արժեք, կեղծ և ճիշտ, Երկուսն էլ զրո և կեղծ պայման դնել, դրանք հավաքականորեն կոչվում են կեղծ արժեքներ, Otherանկացած այլ արժեք պայմանն իրական է դարձնում: Չնայած իր անվանը, կեղծ հաճախ օգտագործվում է որպես այլընտրանք դրան զրո, առանցքային տարբերությամբ, որ կեղծ աղյուսակում իրեն պահում է որպես սովորական արժեք, մինչդեռ ա զրո աղյուսակում բացակայում է բանալին:

Տեսակը թիվ ներկայացնում է ինչպես ամբողջ թվեր, այնպես էլ իրական (լողացող կետով) թվեր ՝ օգտագործելով երկու ենթատեսակ. ամբողջ թիվ և բոց, Ստանդարտ Lua- ն օգտագործում է 64-բիթանոց ամբողջական թվեր և կրկնակի ճշգրտությամբ (64-բիթանոց) բոցեր, բայց կարող եք նաև կազմել Lua- ն այնպես, որ այն օգտագործի 32-բիթանոց ամբողջ թվեր և (կամ) մեկ ճշգրտությամբ (32-բիթանոց) լողացողներ: 32 բիթ ունեցող տարբերակը ինչպես ամբողջ թվերի, այնպես էլ բոցերի համար հատկապես գրավիչ է փոքր մեքենաների և ներկառուցված համակարգերի համար: (Տե՛ս LUA_32BIT մակրո ֆայլում luaconf.h ֆայլում:)

Եթե ​​այլ բան չի նշվում, ամբողջ արժեքները մանիպուլյացիայի ժամանակ որևէ հորդում է փաթաթվել շուրջ, ըստ երկու լրացումների թվաբանության սովորական կանոնների: (Այլ կերպ ասած, իրական արդյունքը եզակի ներկայացուցչական ամբողջ թիվն է, որը հավասար է մոդուլի 2 ն մաթեմատիկական արդյունքին, որտեղ ն ամբողջ տիպի բիթերի քանակն է:)

Lua- ն ունի հստակ կանոններ այն մասին, թե երբ է օգտագործվում յուրաքանչյուր ենթատեսակ, բայց նաև փոխվում է դրանց միջև ինքնաբերաբար, ըստ անհրաժեշտության (տես. & Աղանդ 3.4.3): Հետեւաբար, ծրագրավորողը կարող է ընտրել հիմնականում անտեսել ամբողջ թվերի և բոցերի միջև եղած տարբերությունը կամ ստանձնել ամբողջական վերահսկողություն յուրաքանչյուր համարի ներկայացման վրա:

Տեսակը լարային ներկայացնում է բայթերի անփոփոխ հաջորդականություններ: Lua- ն 8-բիթանոց մաքուր է. Տողերը կարող են պարունակել ցանկացած 8-բիթ արժեք, ներառյալ ներկառուցված զրոները (' 0'): Lua- ն նաև կոդավորող-ագնոստիկ է. Այն ենթադրություն չի անում լարի պարունակության վերաբերյալ: Lua- ի ցանկացած տողի երկարությունը պետք է տեղավորվի Lua ամբողջ թիվում:

Lua- ն կարող է զանգահարել (և շահարկել) Lua- ով գրված գործառույթները և C- ով գրված գործառույթները (տե՛ս & աղանդ 3.4.10): Երկուսն էլ ներկայացված են ըստ տեսակի գործառույթ.

Տեսակը օգտագործողի տվյալները տրամադրվում է, որպեսզի կամայական C տվյալները պահվեն Lua փոփոխականներում: Օգտագործողի տվյալների արժեքը ներկայացնում է հում հիշողության բլոկ: Օգտագործողի տվյալների երկու տեսակ կա. լրիվ օգտագործողի տվյալները, որը հիշողության բլոկով օբյեկտ է, որը կառավարվում է Լուայի կողմից, և թույլ օգտագործողի տվյալներ, որը պարզապես C ցուցիչի արժեք է: Userdata- ն Lua- ում չունի նախորոշված ​​գործողություններ, բացառությամբ նշանակման և ինքնության թեստի: Օգտագործելով մետատվական նյութեր, ծրագրավորողը կարող է սահմանել գործառնություններ օգտագործողի տվյալների ամբողջական արժեքների համար (տե՛ս & աղանդ 2.4): Օգտատիրոջ տվյալների արժեքները Lua- ում հնարավոր չէ ստեղծել կամ փոփոխել, միայն C API- ի միջոցով: Սա երաշխավորում է ընդունող ծրագրի և C գրադարանների պատկանող տվյալների ամբողջականությունը:

Տեսակը թել ներկայացնում է կատարման անկախ թելեր և այն օգտագործվում է կոտրուկներ իրականացնելու համար (տե՛ս & աղանդ 2.6): Lua- ի թելերը կապված չեն օպերացիոն համակարգի թելերի հետ: Lua- ն աջակցում է կորուտիններին բոլոր համակարգերում, նույնիսկ նրանց, որոնք բնիկ չեն աջակցում թելեր:

Տեսակը սեղան իրականացնում է ասոցիատիվ զանգվածներ, այսինքն ՝ զանգվածներ, որոնք կարող են որպես ինդեքս ունենալ ոչ միայն թվեր, այլ ցանկացած Lua արժեք, բացառությամբ զրո և NaN: (Ոչ մի թիվ հատուկ լողացող կետի արժեք է, որն օգտագործվում է IEEE 754 ստանդարտի կողմից `չսահմանված թվային արդյունքներ ներկայացնելու համար, օրինակ` 0/0): Աղյուսակները կարող են լինել տարասեռ այսինքն ՝ դրանք կարող են պարունակել բոլոր տեսակի արժեքներ (բացառությամբ զրո) Արժեքի հետ կապված ցանկացած բանալի զրո չի համարվում աղյուսակի մաս: Ընդհակառակը, ցանկացած բանալի, որը սեղանի մաս չէ, ունի կապված արժեք զրո.

Աղյուսակները Lua- ի տվյալների կառուցման միակ մեխանիզմն են, որոնք կարող են օգտագործվել սովորական զանգվածներ, ցուցակներ, խորհրդանիշների աղյուսակներ, հավաքածուներ, գրառումներ, գծապատկերներ, ծառեր և այլն ներկայացնելու համար: Գրառումները ներկայացնելու համար Lua- ն օգտագործում է դաշտի անվանումը որպես ցուցիչ: Լեզուն աջակցում է այս ներկայացուցչությանը `a.name- ն տրամադրելով որպես շարահյուսական շաքար [[անվան]] համար: Lua- ում կան սեղաններ ստեղծելու մի քանի հարմար եղանակներ (տե՛ս & աղյուսակ 3.4.9):

Indուցանիշների նման, աղյուսակի դաշտերի արժեքները կարող են լինել ցանկացած տեսակի: Մասնավորապես, քանի որ գործառույթները առաջին կարգի արժեքներ են, աղյուսակի դաշտերը կարող են պարունակել գործառույթներ: Այսպիսով, սեղանները կարող են նաև կրել մեթոդները (տես & աղանդ 3.4.11):

Աղյուսակների ինդեքսավորումը հետևում է լեզվի հում հավասարության սահմանմանը: A [i] և a [j] արտահայտությունները նշանակում են նույն աղյուսակի տարրը, եթե և միայն եթե i և j հավասար են հումքի (այսինքն ՝ հավասար են առանց մետամոդների): Մասնավորապես, ինտեգրալ արժեքներով բոցերը հավասար են դրանց համապատասխան ամբողջ թվերին (օրինակ ՝ 1.0 == 1): Երկիմաստություններից խուսափելու համար ցանկացած բոց, որն օգտագործվում է որպես ստեղն, որը հավասար է ամբողջ թվին, վերափոխվում է այդ ամբողջ թիվ: Օրինակ, եթե դուք գրում եք [2.0] = true, աղյուսակում տեղադրված բանալին կլինի ամբողջ թիվ 2-ը:

Աղյուսակները, գործառույթները, շղթաները և (լրիվ) օգտագործողի տվյալների արժեքներն են առարկաներ: փոփոխականները իրականում չեն պարունակել միայն այս արժեքները հղումներ նրանց. Նշանակումը, պարամետրի փոխանցումը և ֆունկցիայի վերադարձը միշտ շահարկում են հղումները այդպիսի արժեքներին, այդ գործողությունները չեն ենթադրում որևէ տեսակի կրկնօրինակ:

Գրադարանի գործառույթի տեսակը վերադարձնում է տրված արժեքի տեսակը նկարագրող տող (տես տեսակը):


Ի՞նչ նորություն կա Swift 5.4-ում:

Բազմաթիվ փոփոխական պարամետրեր, բարելավված անուղղակի անդամների շարահյուսություն, արդյունքների ստեղծողներ և ավելին:

Swift 5.4-ն իր հետ բերում է կազմման որոշ հսկայական բարելավումներ, այդ թվում `կոդերի ավելի լավ լրացում սխալներով արտահայտություններում և մեծ արագացումներ` հավելյալ կազմման համար: Այնուամենայնիվ, այն նաև ավելացնում է որոշ կարևոր նոր առանձնահատկություններ և ճշգրտումներ, ուստի եկեք դրանց մեջ փորփրենք այստեղ

Հովանավորվում է SwiftUI- ի համար պատրաստված դիզայնի գործիք: Սկսեք ձեր դիզայնի հաջորդ թարմացումը ներկառուցված SwiftUI դիզայնի ձևանմուշներով: Խնայեք ժամանակը ՝ շրջանցելով զարգացման լիարժեք միջավայր ստեղծելու անհրաժեշտությունը: Ձևավորեք անվճար մինչև 5 ֆայլ կամ ստացեք անսահմանափակ ֆայլերի ամբողջական տարի և ավելին ՝ 29,99 դոլարով:

Անդամների անուղղակի շարահյուսության բարելավում

SE-0287- ը բարելավում է Swift- ի անուղղակի անդամ արտահայտություններ օգտագործելու ունակությունը, այնպես որ պարզապես մեկ ստատիկ անդամի համար պարզապես աջակցություն ունենալը կարող եք կատարել դրանց շղթաներ:

Swift- ը միշտ ունեցել է հասարակ արտահայտությունների համար անուղղակի անդամ շարադասություն օգտագործելու հնարավորություն, օրինակ, եթե ցանկանում եք SwiftUI- ում ինչ-որ տեքստ գունավորել, ապա կարող եք օգտագործել .red- ը, քան Color.red- ը:

Swift 5.4-ից առաջ սա չէր աշխատում ավելի բարդ արտահայտությունների հետ: Օրինակ, եթե ցանկանում եք, որ ձեր կարմիր գույնը մի փոքր թափանցիկ լինի, ապա ձեզ հարկավոր է գրել սա.

Swift 5.4-ից հետո կազմողը ի վիճակի է հասկանալ բազմաթիվ շղթայված անդամներ, ինչը նշանակում է, որ Գույնի տեսակը կարելի է եզրակացնել.

Բազմաթիվ փոփոխական պարամետրեր գործառույթներում

SE-0284- ը ներմուծեց գործառույթներ ունենալու, բաժանորդագրերի և սկզբնականացման ունակությունները `բազմակի փոփոխական պարամետրեր օգտագործելու համար, քանի դեռ փոփոխական պարամետրին հաջորդող բոլոր պարամետրերը ունեն պիտակ: Swift 5.4-ից առաջ այս իրավիճակում կարող էիք ունենալ միայն մեկ տատանողական պարամետր:

Այսպիսով, այս բարելավման պայմաններում մենք կարող ենք գրել մի ֆունկցիա, որն ընդունում է փոփոխական պարամետրը, որը պահպանում է գոլերի պահերը ֆուտբոլային խաղում, գումարած երկրորդ փոփոխական պարամետրը, որը վաստակում է գոլ խփած խաղացողների անունները.

Այդ գործառույթը զանգահարելու համար տրամադրեք արժեքների երկու բազմությունները որպես փոփոխական պարամետրեր ՝ համոզվելով, որ առաջին փոփոխականներից հետո բոլոր պարամետրերը պիտակավորված են.

Ստեղծելով փոփոխականներ, որոնք կոչում են համանուն գործառույթ

Swift 5.4-ից հետո հնարավոր է ստեղծել տեղական փոփոխական `զանգահարելով համանուն ֆունկցիա: Դա կարող է անհասկանալի թվալ, բայց իրականում դա խնդիր է, որին մենք անընդհատ հարվածում ենք:

Օրինակ, սա ստեղծում է կառուցվածք գույնի (forRow :) մեթոդով, որը կանչվում և նշանակվում է տեղական փոփոխականին, որը կոչվում է գույն.

Նման օգտագործումը թույլատրվում է միայն Swift 5.4-ից և ավելի ուշ: Swift- ի ավելի վաղ տարբերակներում այն ​​կստեղծեր շրջանաձեւ տեղեկանք, քանի որ Swift- ը չէր կարող տարբերակել տեղական գույնի հաստատունը և գույնը (forRow :) եղանակը, որով նա զանգահարում էր. Դուք կտեսնեիք «Փոփոխականն օգտագործվում է իր սկզբնական արժեքի մեջ» սխալը: ,

Դա սովորաբար հանգեցնում էր նրան, որ կամ օգտագործում ենք self.color (forRow: 1989), որպեսզի հասկանալի լինի, որ մենք նկատի ունենք մեթոդի զանգը, կամ էլ տեղական արժեքը պարզապես անվանենք մեկ այլ բան, ինչպիսին է colorForRow- ը:

Բարեբախտաբար Swift 5.4-ը լուծում է դա և թույլ է տալիս մեզ օգտագործել ավելի բնական անվանում:

Այս փոփոխությունը թույլ է տալիս նաև կազմել հատկությունների և գլոբալ փոփոխականների տեղական պատճեններ: Օրինակ, մենք կարող ենք վերցնել օգտագործողի անվան հատկության պատճենը, որը կոչվում է նաև օգտագործողի անուն, օրինակ ՝

Քանի որ սա վերաբերում է նաև գլոբալ փոփոխականներին, այդ նույն կոդն աշխատում է շատ լավ, նույնիսկ առանց կառուցվածքի:

Արդյունքներ կառուցողները

Գործառույթներ ստեղծողները ոչ պաշտոնապես ժամանել են Swift 5.1, բայց մինչև Swift 5.4 նրանք նրանք պաշտոնապես անցել են Swift Evolution առաջարկի գործընթացը որպես SE-0289, որպեսզի քննարկվեն և զտվեն: Որպես այդ գործընթացի մի մաս, դրանք վերանվանվեցին `որպես արդյունք կառուցողներ, որպեսզի ավելի լավ արտացոլեն իրենց իրական նպատակը, և նույնիսկ ձեռք բերեցին որոշ նոր գործառույթներ:

Նախ և առաջ, ամենակարևոր մասը. Արդյունքների ստեղծողները մեզ թույլ են տալիս քայլ առ քայլ ստեղծել նոր արժեք `անցնելով մեր ընտրած հաջորդականությունը: Դրանք սնուցում են SwiftUI- ի տեսակետների ստեղծման համակարգի մեծ մասերը, այնպես որ երբ մենք ունենք ներբեռնված բազմատեսակ VStack, Swift- ը դրանք լուռ խմբավորում է ներքին TupleView տեսակի մեջ, որպեսզի դրանք պահվեն որպես VStack- ի մեկ երեխա - ստացվում է դիտումների հաջորդականությունը մեկ տեսքի մեջ:

Արդյունք ստեղծողները արժանի են իրենց մանրամասն հոդվածին, բայց ես գոնե ուզում եմ ձեզ մի քանի փոքր կոդերի օրինակներ բերել, որպեսզի կարողանաք տեսնել դրանք գործողության մեջ:

Ահա մի գործառույթ, որը վերադարձնում է մեկ տող.

Դա հիանալի է ստացվում, բայց ի՞նչ կլիներ, եթե ունենայինք մի քանի լարեր, որոնք ցանկանում էինք միանալ միասին: Likeիշտ այնպես, ինչպես SwiftUI- ը, գուցե ցանկանանք բոլորին անհատապես տրամադրել և պարզել, որ Swift- ը.

Ինքնին, այդ ծածկագիրը չի գործելու, քանի որ Swift- ն այլևս չի հասկանում, թե ինչ նկատի ունենք: Այնուամենայնիվ, մենք կարող ենք ստեղծել արդյունք կառուցող, որը կհասկանա, թե ինչպես վերափոխել մի քանի տողեր մեկ տողի ՝ օգտագործելով ցանկացած փոխակերպում, որը մենք ուզում ենք, ինչպես հետևյալը.

Նույնիսկ եթե դա փոքր քանակությամբ կոդ է, բացելու շատ բան կա.

  • @ResultBuilder հատկանիշը Swift- ին ասում է, որ հետևյալ տեսակը պետք է վերաբերվի որպես արդյունք կառուցողի: Նախկինում այս վարքագիծը ձեռք էր բերվել @_functionBuilder- ի միջոցով, որն ընդգծում էր, որ սա նախատեսված չէ ընդհանուր օգտագործման համար:
  • Յուրաքանչյուր արդյունք ստեղծող պետք է ապահովի առնվազն մեկ ստատիկ մեթոդ, որը կոչվում է buildBlock (), որը պետք է վերցնի ինչ-որ տվյալների և վերափոխի դրանք: Վերոնշյալ օրինակը զրոյական կամ ավելի տողեր է վերցնում, միանում է նրանց և հետ է ուղարկում որպես մեկ լար:
  • Վերջնական արդյունքն այն է, որ մեր SimpleStringBuilder կառուցվածքը դառնում է արդյունքի ստեղծող, ինչը նշանակում է, որ մենք կարող ենք օգտագործել @SimpleStringBuilder- ը ցանկացած վայրում, որտեղ մեզ անհրաժեշտ են իր լարային միացման ուժերը:

Ոչինչ չի խանգարում մեզ ուղղակիորեն օգտագործել SimpleStringBuilder.buildBlock () - ը,

Այնուամենայնիվ, քանի որ մենք օգտագործեցինք @resultBuilder անոտացիան մեր SimpleStringBuilder կառուցվածքի հետ, մենք կարող ենք նաև այն կիրառել գործառույթների վրա, ինչպիսին է սա.

Նկատեք, թե ինչպես մեզ այլևս պետք չեն ստորակետերը յուրաքանչյուր տողի վերջում - @resultBuilder- ը ավտոմատ կերպով վերափոխում է makeSentence- ի յուրաքանչյուր հայտարարությունը մեկ տողի ՝ օգտագործելով SimpleStringBuilder- ը:

Գործնականում արդյունքի կառուցողները ունակ են զգալիորեն ավելին իրականացնել ՝ ավելի շատ մեթոդներ ավելացնելով ձեր կառուցողի տեսակին: Օրինակ, մենք կարող ենք ավելացնել / կամ այլ աջակցություն մեր SimpleStringBuilder- ին ՝ ավելացնելով երկու լրացուցիչ մեթոդ, որոնք նկարագրում են, թե ինչպես ենք ուզում փոխել տվյալները: Մեր ծածկագրում մենք առհասարակ չենք ցանկանում վերափոխել մեր տողերը, այնպես որ կարող ենք դրանք անմիջապես հետ ուղարկել:

Ես գիտեմ, որ կարծես թե մենք գրեթե ոչ մի աշխատանք չենք կատարել, բայց հիմա մեր գործառույթները կարողանում են օգտագործել պայմանները.

Նմանապես, մենք կարող ենք օղակների աջակցություն ավելացնել ՝ ավելացնելով buildArray () մեթոդը մեր կառուցողի տեսակին.

Եվ հիմա մենք կարող ենք օգտագործել օղակների համար.

Դա մեզ համարյա մոգության պես է, քանի որ արդյունքների ստեղծման համակարգը գրեթե ամբողջ աշխատանքն է կատարում մեզ համար, և չնայած որ մեր օրինակը բավականին պարզ էր, հուսով եմ, որ կարող եք համտեսել այն հզոր էներգիայի արդյունքի, որը շինարարները բերում են Swift- ին:

Հարկ է ավելացնել, որ Swift 5.4-ը ընդլայնում է արդյունքների կառուցման համակարգը `պահպանելու համար պահված հատկությունների վրա դրված ատրիբուտները, ինչը ավտոմատ կերպով կարգավորում է անուղղակի անդամի սկզբնավորիչը` գործվածքների համար `արդյունքի կառուցիչը կիրառելու համար:

Սա հատկապես օգտակար է SwiftUI- ի հատուկ դիտումների համար, որոնք օգտագործում են արդյունքների ստեղծողներ, ինչպիսին է այս մեկը.

Եթե ​​ցանկանում եք տեսնել արդյունքների ստեղծողների ավելի առաջադեմ, իրական աշխարհում օրինակներ, գործի մեջ պետք է ստուգեք GitHub- ի Awesome Function Builders պահոցը:

Տեղական գործառույթներն այժմ աջակցում են գերբեռնվածությանը

SR-10069- ը խնդրեց գործառույթները տեղական համատեքստերում ծանրաբեռնելու հնարավորությունը, ինչը գործնականում նշանակում է, որ այժմ բնադրված ֆունկցիաները կարող են ծանրաբեռնված լինել, որպեսզի Swift- ն ընտրի, թե որն է գործարկել `օգտագործվող տեսակների հիման վրա:

Օրինակ, եթե մենք ուզում էինք պատրաստել մի քանի պարզ բլիթներ, մենք կարող ենք գրել այսպիսի կոդ.

Նախքան Swift 5.4-ը, ավելացնել () երեք եղանակները կարող էին ծանրաբեռնված լինել միայն այն դեպքում, եթե դրանք չեն տեղադրվել makeCookies- ի ներսում (), բայց Swift 5.4-ից հետո գործառույթի գերբեռնվածությունն աջակցվում է նաև այս պարագայում:

Swift 5.4- ը նաև թույլ է տալիս զանգահարել տեղական գործառույթները նախքան դրանք հայտարարվելը, ինչը նշանակում է, որ անհրաժեշտության դեպքում այժմ կարող ենք գրել այսպիսի կոդ.

Հատկությունների փաթաթիչներն այժմ աջակցվում են տեղական փոփոխականների համար

Անշարժ գույքի փաթաթաները առաջին անգամ ներկայացվել են Swift 5.1-ում որպես հատկություններ լրացուցիչ ֆունկցիոնալություն հեշտ և բազմակի օգտագործելու եղանակով կցելու միջոց, բայց Swift 5.4 – ում նրանց վարքագիծը տարածվել է ՝ օգտագործելով դրանք որպես գործառույթների տեղական փոփոխականներ:

Օրինակ, մենք կարող ենք ստեղծել գույքի փաթաթան, որը կապահովի, որ դրա արժեքը երբեք չի իջնի զրոյի տակ.

Եվ Swift 5.4-ից սկսած մենք կարող ենք այդ հատկության փաթաթան օգտագործել սովորական գործառույթի ներսում, այլ ոչ թե պարզապես հատկությանը կցել: Օրինակ, մենք կարող ենք գրել այնպիսի խաղ, որտեղ մեր խաղացողը կարող է միավորներ վաստակել կամ կորցնել, բայց նրանց հաշիվը երբեք չպետք է իջնի 0-ից:

Փաթեթներն այժմ կարող են հայտարարել գործարկվող թիրախներ

SE-0294- ը Swift Package- ի կառավարիչ օգտագործող հավելվածների համար ավելացնում է թիրախային նոր տարբերակ `թույլ տալով մեզ հստակ հայտարարել գործադիր թիրախ:

This is particularly important for folks who want to use SE-0281 (using @main to mark your program’s entry point), because it didn’t play nicely with Swift Package Manager – it would always look for a main.swift file.

With this change, we can now remove main.swift and use @main instead. Նշում: You must specify // swift-tools-version:5.4 in your Package.swift file in order to get this new functionality.

Trying it yourself

Swift 5.4 is available through Xcode 12.5, which is available from the Mac App Store.

Which features of Swift 5.4 are դու most looking forward to?

SPONSORED A design tool made for SwiftUI. Kick-start your next design update with built-in SwiftUI design templates. Save time by skipping the need to set up a full development environment. Design for free with up to 5 files or get a full year of unlimited files and more for $29.99.

About the author

Paul Hudson is the creator of Hacking with Swift, the most comprehensive series of Swift books in the world. He's also the editor of Swift Developer News, the maintainer of the Swift Knowledge Base, and a speaker at Swift events around the world. If you're curious you can learn more here.


5.4: Logarithmic Functions

The composition of a function with its inverse returns the starting value, x.

This concept will be used to solve equations involving exponentials and logarithms.

Now that we have a basic idea of a logarithmic function, let's take a closer look at its graph.

Let's examine the function:

The value of բ (the 2) is referred to as the base of the logarithm.

Notice that x must be positive.

Նշում: In a linear graph, the " rate of change " remains the same across the entire graph.
In a logarithmic graph, the "rate of change" increases (or decreases) across the graph.

For help with logarithms on
your calculator,
click here.

For "other bases" use the following "change of base" conversion:


Or use logBASE( template at MATH &rarr arrow down to A:logBASE(.

The graphs of functions of the form have certain characteristics in common.

• graph crosses the x-axis at (1,0)

• when բ > 1, the graph increases

• when 0 < բ < 1, the graph decreases

• the domain is all positive real numbers (never zero)

• the range is all real numbers

• graph passes the vertical line test for functions

• graph passes the horizontal line test for functional inverse.

• graph is asymptotic to the y-axis - gets very, very close to the y-axis but, in this case, does not touch it or cross it.

We know that transformations have the ability to move functions by sliding them, reflecting them, stretching them, and shrinking them. Let's see how these changes will affect the logarithmic function:

Parent function:

Translation y = logբ(x - h) + k
horizontal by h: vertical by k:


Domain: x > h
Range: x &isin Real numbers

All 3 transformations combined: y = a logբ(x - h) + k

By examining the nature of the logarithmic graph, we have seen that the parent function will stay to the right of the x-axis, unless acted upon by a transformation.
• The parent function , y = logբ x, will always have an x-intercept of one , occurring at the ordered pair of (1,0).
Կա ոչ y-intercept with the parent function since it is asymptotic to the y-axis (approaches the y-axis but does not touch or cross it).

• The transformed parent function of the form y = alogբ x, will also always have a x-intercept of 1 , occurring at the ordered pair of (1, 0). Note that the value of ա may be positive or negative.
Like the parent function, this transformation will be asymptotic to the y-axis, and will have ոչ y-intercept.


• If the transformed parent function includes a vertical or horizontal shift , all bets are off. The horizontal shift will affect the possibility of a y-intercept and the vertical shift will affect the x-intercept. In this situation, you will need to examine the graph carefully to determine what is happening.

• The end behavior of a transformed parent function is not always consistent, but is dependent upon the nature of the transformation. Consider this example:

For the transformed equation

the horizontal shift of +5 will push the
asymptote line to the left five units.
Thus the end behavior will be:

Ի y-interceptորտեղ x = 0, is
y =log 2 (0 + 5) + 4 &asymp 6.321928095.
Ի x-intercept, where y = 0, is
approximately -4.94 (from the graph's table) .



Don't confuse log graphs
with square root graphs.
At fist glance, these two graphs appear to be similar. But the square root graph is actually ending, while the log graph is not.


End Behavior of a Function

The end behavior of a polynomial function is the behavior of the graph of f ( x ) as x approaches positive infinity or negative infinity.

The degree and the leading coefficient of a polynomial function determine the end behavior of the graph.

The leading coefficient is significant compared to the other coefficients in the function for the very large or very small numbers. So, the sign of the leading coefficient is sufficient to predict the end behavior of the function.

Leading Coefficient

To predict the end-behavior of a polynomial function, first check whether the function is odd-degree or even-degree function and whether the leading coefficient is positive or negative.

Find the end behavior of the function x 4 − 4 x 3 + 3 x + 25 .

The degree of the function is even and the leading coefficient is positive. So, the end behavior is:

f ( x ) → + ∞ , as x → − ∞ f ( x ) → + ∞ , as x → + ∞

The graph looks as follows:

Download our free learning tools apps and test prep books

Names of standardized tests are owned by the trademark holders and are not affiliated with Varsity Tutors LLC.

4.9/5.0 Satisfaction Rating over the last 100,000 sessions. As of 4/27/18.

Media outlet trademarks are owned by the respective media outlets and are not affiliated with Varsity Tutors.

Award-Winning claim based on CBS Local and Houston Press awards.

Varsity Tutors does not have affiliation with universities mentioned on its website.

Varsity Tutors connects learners with experts. Instructors are independent contractors who tailor their services to each client, using their own style, methods and materials.


Logarithmic Differentiation

The method of differentiating functions by first taking logarithms and then differentiating is called logarithmic differentiation . We use logarithmic differentiation in situations where it is easier to differentiate the logarithm of a function than to differentiate the function itself. This approach allows calculating derivatives of power, rational and some irrational functions in an efficient manner.

Consider this method in more detail. Let (y = fleft( x ight)). Take natural logarithms of both sides:

Next, we differentiate this expression using the chain rule and keeping in mind that (y) is a function of (x.)

It’s seen that the derivative is

The derivative of the logarithmic function is called the logarithmic derivative of the initial function (y = fleft( x ight).)

This differentiation method allows to effectively compute derivatives of power-exponential functions, that is functions of the form

where (uleft( x ight)) and (vleft( x ight)) are differentiable functions of (x.)

In the examples below, find the derivative of the function (yleft( x ight)) using logarithmic differentiation.


5.4: Logarithmic Functions

We know that the sign of the derivative tells us whether a function is increasing or decreasing for example, when $f'(x)>0$, $f(x)$ is increasing. The sign of the second derivative $f''(x)$ tells us whether $f'$ is increasing or decreasing we have seen that if $f'$ is zero and increasing at a point then there is a local minimum at the point, and if $f'$ is zero and decreasing at a point then there is a local maximum at the point. Thus, we extracted information about $f$ from information about $f''$.

We can get information from the sign of $f''$ even when $f'$ is not zero. Suppose that $f''(a)>0$. This means that near $x=a$, $f'$ is increasing. If $f'(a)>0$, this means that $f$ slopes up and is getting steeper if $f'(a) Figure 5.4.1. $f''(a)>0$: $f'(a)$ positive and increasing, $f'(a)$ negative and increasing.

Now suppose that $f''(a) 0$, this means that $f$ slopes up and is getting less steep if $f'(a) Figure 5.4.2. $f''(a) Example 5.4.1 Describe the concavity of $ds f(x)=x^3-x$. $ds f'(x)=3x^2-1$, $f''(x)=6x$. Since $f''(0)=0$, there is potentially an inflection point at zero. Since $f''(x)>0$ when $x>0$ and $f''(x) 0$.

Note that we need to compute and analyze the second derivative to understand concavity, so we may as well try to use the second derivative test for maxima and minima. If for some reason this fails we can then try one of the other tests.


Lesson 4

In this lesson, students work with graphs and tables that represent functions in addition to the equations and descriptions used previously. They learn the conventions of graphing the independent variable (input) on the horizontal axis and the dependent variable (output) on the vertical axis and that each coordinate point represents an input-output pair of the function.

By matching contexts and graphs and reading information about functions from graphs and tables, students become familiar with the different representations and draw connections between them.

Ուսուցման նպատակները

Let’s connect equations and graphs of functions.

Ուսուցման թիրախները

CCSS ստանդարտներ

Glossary Entries

A dependent variable represents the output of a function.

For example, suppose we need to buy 20 pieces of fruit and decide to buy apples and bananas. If we select the number of apples first, the equation (b=20-a) shows the number of bananas we can buy. The number of bananas is the dependent variable because it depends on the number of apples.

An independent variable represents the input of a function.

For example, suppose we need to buy 20 pieces of fruit and decide to buy some apples and bananas. If we select the number of apples first, the equation (b=20-a) shows the number of bananas we can buy. The number of apples is the independent variable because we can choose any number for it.

A radius is a line segment that goes from the center to the edge of a circle. A radius can go in any direction. Every radius of the circle is the same length. We also use the word radius to mean the length of this segment.

For example, (r) is the radius of this circle with center (O) .

Expand Image

Տպել ձևաչափված նյութերը

Ուսուցիչների կողմից վավեր էլեկտրոնային հասցե ունեցող ուսուցիչները կարող են սեղմել այստեղ `գրանցվելու կամ մուտք գործելու համար` Cool Down- ի, Ուսուցչի ուղեցույցի և PowerPoint նյութերի անվճար հասանելիության համար:

Լրացուցիչ ռեսուրսներ

IM 6–8 մաթեմատիկան ի սկզբանե մշակվել է Open Up Resources- ի կողմից և հեղինակ է Illustrative Mathematics®- ի, իսկ հեղինակային իրավունքը հեղինակավոր է 2017-2019թթ. ՝ Open Up Resources- ի կողմից: Այն լիցենզավորված է Creative Commons Attribution 4.0 միջազգային լիցենզիայով (CC BY 4.0): ՄԵՐ 6-8 մաթեմատիկական ուսումնական ծրագիրը հասանելի է https://openupresources.org/math-curriculum/ կայքում:

IM 6–8 մաթեմատիկայի հարմարեցումներն ու թարմացումները Պատկերազարդ մաթեմատիկայի կողմից հեղինակային իրավունքի 2019 թ. Են, և լիցենզավորված են Creative Commons Attribution 4.0 միջազգային լիցենզիայի ներքո (CC BY 4.0):

Անգլերեն լեզվի սովորողների լրացուցիչ օժանդակություններ ավելացնելու հարմարեցումները հեղինակային իրավունքի 2019 թ. Կողմից բացված ռեսուրսների կողմից, և լիցենզավորված են Creative Commons Attribution 4.0 միջազգային լիցենզիայով (CC BY 4.0):

Անգլերենի գնահատումների երկրորդ փաթեթը (նշվում է որպես «Բ» սահմանված) հեղինակային իրավունքի պաշտպանության իրավունքի իրավունքի պահպանման իրավունքը 2019 թ.

«B» գնահատականների իսպաներեն թարգմանությունը հեղինակային իրավունքով պատկանող Illustrative Mathematics- ի կողմից պաշտպանված է 2020 թվականին, և լիցենզավորված են Creative Commons Attribution 4.0 միջազգային լիցենզիայով (CC BY 4.0):

Պատկերավոր մաթեմատիկայի անունն ու պատկերանշանը ենթակա չեն Creative Commons լիցենզիայի և չեն կարող օգտագործվել առանց Illustrative Mathematics- ի նախնական և արտահայտված գրավոր համաձայնության:

Այս կայքը ներառում է հանրային տիրույթի պատկերներ կամ բացահայտ լիցենզավորված պատկերներ, որոնք պաշտպանված են իրենց համապատասխան տերերի կողմից: Բաց լիցենզավորված պատկերները մնում են իրենց համապատասխան լիցենզիաների պայմանների ներքո: Տե՛ս պատկերի վերագրման բաժինը ՝ լրացուցիչ տեղեկությունների համար:


5.4: Logarithmic Functions

The ECMAScript 2017 feature 𠇊sync Functions” was proposed by Brian Terlson.

5.1 Overview #

5.1.1 Variants #

The following variants of async functions exist. Note the keyword async everywhere.

  • Async function declarations: async function foo() <>
  • Async function expressions: const foo = async function () <>
  • Async method definitions: let obj = < async foo() <>>
  • Async arrow functions: const foo = async () => <>

5.1.2 Async functions always return Promises #

Fulfilling the Promise of an async function:

Rejecting the Promise of an async function:

5.1.3 Handling results and errors of asynchronous computations via await #

The operator await (which is only allowed inside async functions) waits for its operand, a Promise, to be settled:

  • If the Promise is fulfilled, the result of await is the fulfillment value.
  • If the Promise is rejected, await throws the rejection value.

Handling a single asynchronous result:

Handling multiple asynchronous results sequentially:

Handling multiple asynchronous results in parallel:

5.2 Understanding async functions #

Before I can explain async functions, I need to explain how Promises and generators can be combined to perform asynchronous operations via synchronous-looking code.

For functions that compute their one-off results asynchronously, Promises, which are part of ES6, have become popular. One example is the client-side fetch API, which is an alternative to XMLHttpRequest for retrieving files. Using it looks as follows:

5.2.1 Writing asynchronous code via generators #

co is a library that uses Promises and generators to enable a coding style that looks more synchronous, but works the same as the style used in the previous example:

Every time the callback (a generator function!) yields a Promise to co, the callback gets suspended. Once the Promise is settled, co resumes the callback: if the Promise was fulfilled, yield returns the fulfillment value, if it was rejected, yield throws the rejection error. Additionally, co promisifies the result returned by the callback (similarly to how then() does it).

5.2.2 Writing asynchronous code via async functions #

Async functions are basically dedicated syntax for what co does:

Internally, async functions work much like generators.

5.2.3 Async functions are started synchronously, settled asynchronously #

This is how async functions are executed:

  1. The result of an async function is always a Promise p . That Promise is created when starting the execution of the async function.
  2. The body is executed. Execution may finish permanently via return or throw . Or it may finish temporarily via await in which case execution will usually continue later on.
  3. The Promise p is returned.

While executing the body of the async function, return x resolves the Promise p with x , while throw err rejects p with err . The notification of a settlement happens asynchronously. In other words: the callbacks of then() and catch() are always executed after the current code is finished.

The following code demonstrates how that works:

You can rely on the following order:

  1. Line (A): the async function is started synchronously. The async function’s Promise is resolved via return .
  2. Line (C): execution continues.
  3. Line (B): Notification of Promise resolution happens asynchronously.

5.2.4 Returned Promises are not wrapped #

Resolving a Promise is a standard operation. return uses it to resolve the Promise p of an async function. That means:

  1. Returning a non-Promise value fulfills p with that value.
  2. Returning a Promise means that p now mirrors the state of that Promise.

Therefore, you can return a Promise and that Promise won’t be wrapped in a Promise:

Intriguingly, returning a rejected Promise leads to the result of the async function being rejected (normally, you𠆝 use throw for that):

That is in line with how Promise resolution works. It enables you to forward both fulfillments and rejections of another asynchronous computation, without an await :

The previous code is roughly similar to – but more efficient than – the following code (which unwraps the Promise of anotherAsyncFunc() only to wrap it again):

5.3 Tips for using await #

5.3.1 Don’t forget await #

One easy mistake to make in async functions is to forget await when making an asynchronous function call:

In this example, value is set to a Promise, which is usually not what you want in async functions.

await can even make sense if an async function doesn’t return anything. Then its Promise is simply used as a signal for telling the caller that it is finished. For example:

The await in line (A) guarantees that step1() is completely finished before the remainder of foo() is executed.

5.3.2 You don’t need await if you 𠇏ire and forget” #

Sometimes, you only want to trigger an asynchronous computation and are not interested in when it is finished. The following code is an example:

Here, we don’t care when individual writes are finished, only that they are executed in the right order (which the API would have to guarantee, but that is encouraged by the execution model of async functions – as we have seen).

The await in the last line of asyncFunc() ensures that the function is only fulfilled after the file was successfully closed.

Given that returned Promises are not wrapped, you can also return instead of await writer.close() :

Both versions have pros and cons, the await version is probably slightly easier to understand.

5.3.3 await is sequential, Promise.all() is parallel #

The following code make two asynchronous function calls, asyncFunc1() and asyncFunc2() .

However, these two function calls are executed sequentially. Executing them in parallel tends to speed things up. You can use Promise.all() to do so:

Instead of awaiting two Promises, we are now awaiting a Promise for an Array with two elements.

5.4 Async functions and callbacks #

One limitation of async functions is that await only affects the directly surrounding async function. Therefore, an async function can’t await in a callback (however, callbacks can be async functions themselves, as we’ll see later on). That makes callback-based utility functions and methods tricky to use. Examples include the Array methods map() and forEach() .

5.4.1 Array.prototype.map() #

Let’s start with the Array method map() . In the following code, we want to download the files pointed to by an Array of URLs and return them in an Array.

This does not work, because await is syntactically illegal inside normal arrow functions. How about using an async arrow function, then?

There are two issues with this code:

  • The result is now an Array of Promises, not an Array of strings.
  • The work performed by the callbacks isn’t finished once map() is finished, because await only pauses the surrounding arrow function and httpGet() is resolved asynchronously. That means you can’t use await to wait until downloadContent() is finished.

We can fix both issues via Promise.all() , which converts an Array of Promises to a Promise for an Array (with the values fulfilled by the Promises):

The callback for map() doesn’t do much with the result of httpGet() , it only forwards it. Therefore, we don’t need an async arrow function here, a normal arrow function will do:

There is one small improvement that we still can make: This async function is slightly inefficient – it first unwraps the result of Promise.all() via await , before wrapping it again via return . Given that return doesn’t wrap Promises, we can return the result of Promise.all() directly:

5.4.2 Array.prototype.forEach() #

Let’s use the Array method forEach() to log the contents of several files pointed to via URLs:

Again, this code will produce a syntax error, because you can’t use await inside normal arrow functions.

Let’s use an async arrow function:

This does work, but there is one caveat: the Promise returned by httpGet() is resolved asynchronously, which means that the callbacks are not finished when forEach() returns. As a consequence, you can’t await the end of logContent() .

If that’s not what you want, you can convert forEach() into a for-of loop:

Now everything is finished after the for-of loop. However, the processing steps happen sequentially: httpGet() is only called a second time after the first call is finished. If you want the processing steps to happen in parallel, you must use Promise.all() :

map() is used to create an Array of Promises. We are not interested in the results they fulfill, we only await until all of them are fulfilled. That means that we are completely done at the end of this async function. We could just as well return Promise.all() , but then the result of the function would be an Array whose elements are all undefined .

5.5 Tips for using async functions #

5.5.1 Know your Promises #

The foundation of async functions is Promises. That’s why understanding the latter is crucial for understanding the former. Especially when connecting old code that isn’t based on Promises with async functions, you often have no choice but to use Promises directly.

For example, this is a “promisified” version of XMLHttpRequest :

The API of XMLHttpRequest is based on callbacks. Promisifying it via an async function would mean that you𠆝 have to fulfill or reject the Promise returned by the function from within callbacks. That’s impossible, because you can only do so via return and throw . And you can’t return the result of a function from within a callback. throw has similar constraints.

Therefore, the common coding style for async functions will be:

  • Use Promises directly to build asynchronous primitives.
  • Use those primitives via async functions.

5.5.2 Immediately Invoked Async Function Expressions #

Sometimes, it𠆝 be nice if you could use await at the top level of a module or script. Alas, it’s only available inside async functions. You therefore have several options. You can either create an async function main() and call it immediately afterwards:

Or you can use an Immediately Invoked Async Function Expression:

Another option is an Immediately Invoked Async Arrow Function:

5.5.3 Unit testing with async functions #

The following code uses the test-framework mocha to unit-test the asynchronous functions asyncFunc1() and asyncFunc2() :

However, this test always succeeds, because mocha doesn’t wait until the assertions in line (B) and line (C) are executed.

You can fix this by returning the result of the Promise chain, because mocha recognizes if a test returns a Promise and then waits until that Promise is settled (unless there is a timeout).

Conveniently, async functions always return Promises, which makes them perfect for this kind of unit test:

There are thus two advantages to using async functions for asynchronous unit tests in mocha: the code is more concise and returning Promises is taken care of, too.

5.5.4 Don’t worry about unhandled rejections #

JavaScript engines are becoming increasingly good at warning about rejections that are not handled. For example, the following code would often fail silently in the past, but most modern JavaScript engines now report an unhandled rejection:


Դիտեք տեսանյութը: Logaritmi: johdantoesimerkki ja määritelmä (Դեկտեմբեր 2021).