ⴰⴷⵍⵉⵙ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏ JavaScript ⴰⵙⵉⵏⴽⵔⵓⵏ

ⵎⴰ ⵢⴻⵍⵍⴰ ⵜⴻⴱⴷⵉⴹ ⴽⴰⵏ ⵙ ⵓⵙⵏⵉⵍⴻⵙ, ⵍⵍⴰⵏⵜ ⵜⵣⴻⵎⵎⴰⵔ, ⵜⴻⵜⵜⵅⴻⵎⵎⵉⵎⴻⴹ ⵖⴻⴼ ⵡⴰⵀⵉⵍⴻⵏ ⴰⵎ ⵢⵉⵡⴻⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵏⴹⴰⵡⵜ ⵢⴻⵜⵜⵡⴰⵙⴱⴻⴷⴷⴻⵏ, ⴰⵏⴷⴰ ⵢⴰⵍ ⴰⴼⴻⵔⴷⵉⵙ ⵉⵅⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵡⵙⴰ ⵙ ⵜⵉⵎⵎⴰⴷⵉⵙ ⵢⴻⵔⵏⴰ ⵢⴻⵜⵜⵄⴻⴷⴷⴰⵢⴷ ⴰⴳⵎⵓⴹⵉⵙ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⵣⵎⴻⵔ ⵓⴼⴻⵔⴷⵉⵙ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ ⴰⴷ ⵢⴻⴷⴷⵓ ⴷ ⵡⴰⵢⴻⵏⵏⵏⵉⴹⴻⵏ, ⵢⴻⵔⵏⴰ ⵉ ⵍⵎⴻⵏⴷ ⵏ ⴰⵎⵓⵔ ⴰⵎⴻⵇⵔⴰⵏ ⵜⴻⵙⵄⵉⴹ ⵍⵃⴻⵇⵇ, ⴰⵎⵓⵔ ⴰⵎⴻⵇⵔⴰⵏ ⵙⴻⴳ ⵡⴰⵀⵉⵍⴻⵏ ⵜⵜⴽⴻⵎⵎⵉⵍⴻⵏ ⵙ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ, ⴰⵎⵣⵓⵏⴰ ⵢⴻⵜⵜⴰⴵⴵⴰⴰⵖ ⴰⴷ ⵏⴻⴱⵏⵓ ⴰⵀⵉⵍⴻⵏ ⵉⵙⴻⵀⵍⴻⵏ ⵉ ⵜⵉⵔⴰ ⴷ ⵓⵃⴰⵔⴻⴱ. ⵍⵍⴰⵏ ⵡⵓⴳⵓⵔⴻⵏ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⵉⴳⴻⵔⵔⵣⴻⵏ ⴷ ⴰⵛⵓ ⴽⴰⵏ ⴰⵏⴷⴰ ⵓⵔ ⵉⵅⴻⴷⴷⴻⵎ ⴰⵔⴰ ⵓⵎⴹⴰⵏⴰ ⵏ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ, ⵏⴻⵖ ⵓⵔ ⵢⴻⵜⵜⵉⵍⵉ ⴰⵔⴰ ⴷ ⴰⵢⴻⵏ ⵢⴻⵍⵀⴰⵏ. ⴰⵎ ⵓⵎⴻⴷⵢⴰ, ⴻⴼⴽⴷ ⴰⵙⴻⵏⴼⴰⵔ ⵏ ⵜⵖⵓⵔⵉ ⵏ ⵢⴻⴷⵍⵉⵙⴻⵏ. ⴰⵙⴻⵏⴼⴰⵔⴰ ⵢⴻⵙⵄⴰ ⴽⵔⴰ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ ⴰⵎ ⵜⵓⴼⴼⵖⴰ ⵏ ⵡⴰⴽⴽ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵡⴰⵡⴰⵍ, ⴰⵃⴻⵣⵣⴻⴱ ⴳⴰⵔ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ, ⴷ ⵡⴰⵢⴻⵏ ⵏⵏⵉⴹⴻⵏ ⴰⵎ ⵡⴰ. ⵜⵓⵔⴰ ⵅⴻⵎⵎⴻⵎⴷ ⴰⵙⴻⵇⴷⴰⵛⵏⵏⵉ ⵢⴻⵇⵇⴰⵔⴷ ⵜⵓⵔⴰ ⴰⴷⵍⵉⵙ ⵖⴻⵣⵣⵉⴼⴻⵏ ⵢⴻⵔⵏⴰ ⵢⴻⵇⵙⴻⴷ ⴰⴷ ⵉⵏⴰⴷⵉ ⵖⴻⴼ ⵡⴰⴽⴽ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵡⴰⵡⴰⵍ ⵓⵛⵔⵉⴽ ⴰⵎ “The”. ⴰⵙⴻⵏⴼⴰⵔ ⴰⴷ ⵢⴻⵟⵟⴻⴼ ⵙ ⵍⵇⴰⵏⵓⵏ ⵙⵏⴰⵜ ⵏ ⵜⴻⵙⴷⵉⴷⵉⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴰⴼ ⵢⴻⵔⵏⴰ ⴰⴷ ⴷⵢⴻⵙⵎⴻⴽⵜⵉ ⴰⴽⴽ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵡⴰⵡⴰⵍⵏⵏⵉ. ⴷⴻⴳ ⵡⴰⵀⵉⵍ ⵏ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ, ⴰⵙⴻⵇⴷⴰⵛ ⵓⵔ ⵢⴻⵣⵎⵉⵔ ⴰⵔⴰ ⴰⴷ ⵢⴻⵜⵜⴻⵎⵛⴰⴱⵉ ⵖⴻⵔ ⵓⵙⴻⵇⴷⴻⵛ (ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⴰⵙⴻⴱⵜⴻⵔ ⵏⴻⵖ ⴰⴷ ⴷⵢⴻⵙⵎⴻⴽⵜⵉ ⴰⴹⵔⵉⵙ) ⴰⵍⴰⵎⵎⴰ ⵜⴻⴹⵔⴰ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ. ⴰⵙⵉⵔⴻⵎ, ⵜⵣⴻⵎⵔⴻⴹ ⴰⴷ ⵜⵡⴰⵍⵉⴹ ⴱⴻⵍⵍⵉ ⴰⵢⴰ ⵎⴰⵞⵞⵉ ⴷ ⵜⴰⵣⵎⴻⵔⵜ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⵉⴳⴻⵔⵔⵣⴻⵏ!

ⴰⴹⵔⵉⵙⴰ ⵢⴻⵙⵙⴽⴰⵏⴰⵢⴷ ⴰⴹⵔⵉⵙ ⵏ ⵓⵅⴻⴷⴷⵉⵎ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵓⵎⴻⵖⵔⵉ ⵏ ⵢⴻⴷⵍⵉⵙⴻⵏ. ⵎⴰ ⵢⴻⵍⵍⴰ ⴰⵙⴻⵇⴷⴰⵛ ⵢⴻⴱⴷⴰⴷ ⵜⴰⵎⵀⴻⵍⵜ ⵏ ⵜⵖⵓⵔⵉ ⵖⴻⵣⵣⵉⴼⴻⵏ (ⴷⴻⴳ ⵜⴰⵍⵓⴼⵜⴰ ⴰⵏⴰⴷⵉ ⵖⴻⴼ ⵡⴰⴽⴽ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ “ⵜⵀⴻ” ⴷⴻⴳ ⵓⴷⵍⵉⵙ ⴰⵎⴻⵇⵔⴰⵏ), ⴰⵙⴻⵏⴼⴰⵔ “ⵢⴻⵜⵜⴼⴻⴳⴳⵉⴹ” ⵉ ⵡⴰⴽⴽ ⵜⴰⵖⵣⵉ ⵏ ⵜⴻⵎⵀⴻⵍⵜⵏⵏⵉ. ⴷⴻⴳ ⵜⴻⴳⵏⵉⵜⴰ, ⴰⵙⴻⵇⴷⴰⵛ ⴰⴷ ⵢⴻⵇⵇⵉⵎ ⵢⴻⵜⵜⴹⴻⴳⴳⵉⵄ ⵖⴻⴼ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵓⵙⵎⴻⵍ ⴰⵢ ⴷⵉⵜⴻⴷⴷⵓⵏ ⵡⴰⵔ ⵎⴰ ⵢⴻⵍⵍⴰⴷ ⴽⵔⴰ ⵏ ⵓⴳⵎⵓⴹ ⴰⵍⴰⵎⵎⴰ ⵜⴼⵓⴽ ⵜⴻⵎⵀⴻⵍⵜ ⵏ ⵓⵏⴰⴷⵉ ⵢⴻⵔⵏⴰ ⴰⴽⴽ ⵜⴻⵎⵀⴻⵍⵜ ⴰⴷ ⴷⵜⵉⵍⵉ ⴷⴻⴳ ⵢⵉⵡⴻⵜ ⵏ ⵜⵉⴽⴽⴻⵍⵜ ⴰⵔⴰ ⴷⵢⴻⴼⴽⴻⵏ ⵉ ⵓⵙⴻⵇⴷⴰⵛ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴰⵃⵓⵍⴼⵓ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⴰⵢ ⴷⵢⴻⵇⵇⵉⵎⴻⵏ ⴷⴻⴼⴼⵉⵔ.

ⴰⵀⴰⵜ ⵜⵡⴰⵍⴰⴹ ⴱⴻⵍⵍⵉ ⴰⵎⴻⴷⵢⴰⴰⴳⵉ ⵓⵔ ⵢⴻⵜⵜⴻⵎⵛⴰⴱⵉ ⴰⵔⴰ ⵙ ⵜⵉⴷⴻⵜ ⵖⴻⵔ ⵓⵎⴹⴰⵏ ⵏ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⴷⵏⴻⵙⵙⴻⴽⵛⴻⵎ ⵢⴰⴽⴰⵏ. ⴰⵢⴰ ⵉⵎⵉ ⵜⵉⵎⵀⴰⵍ ⴷⴰⴳⵉ ⵜⵜⵡⴰⵃⴻⵔⵣⴻⵏⵜ ⴳⴰⵔⴰⵙⴻⵏⵜ. ⴰⵎⵙⴻⵇⴷⴰⵛ ⵓⵔ ⵢⴻⵙⵙⴻⴼⴽ ⴰⵔⴰ ⴰⴷ ⵢⵉⵙⵙⵉⵏ ⵖⴻⴼ ⵓⵎⴹⴰⵏ ⵏ ⵜⵎⵓⵖⵍⵉⵡⵉⵏ ⵏ “ⵜⵀⴻ” ⴰⴽⴽⴻⵏ ⴰⴷ ⵉⵄⴻⴷⴷⵉ ⵖⴻⵔ ⵜⴼⴻⵍⵡⵉⵜ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ, ⵉⵀⵉ ⴰⴹⵔⵉⵙ ⵏ ⵓⵙⵙⴻⴹⵔⵓ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵓⵔ ⵢⴻⵍⵍⵉ ⴰⵔⴰ ⴷ ⴰⵢⴻⵏ ⵢⴻⵙⵄⴰⵏ ⴰⵣⴰⵍ ⵙ ⵜⵉⴷⴻⵜ. ⵓⵔ ⵢⴻⵙⵙⴻⴼⴽ ⴰⵔⴰ ⴰⴷ ⵏⵕⴰⴵⵓ ⵜⴰⴳⴳⴰⵔⴰ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ ⵓⵇⴱⴻⵍ ⴰⴷ ⵏⵔⵓⵃ ⵖⴻⵔ ⵜⴼⴻⵍⵡⵉⵜ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ. ⴰⵙⵏⴻⵔⵏⵉ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵓⵙⵡⵉⵔ ⵏ ⵓⵙⵙⴻⴹⵔⵓ ⵉⵄⴻⴷⴷⴰⵏ ⵢⴻⵜⵜⵡⴰⴱⵏⴰ ⵖⴻⴼ ⵍⵇⴰⵏⵓⵏⴰ : ⵏⴻⵣⵎⴻⵔ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⵜⴰⵎⵀⴻⵍⵜ ⵏ ⵓⵏⴰⴷⵉ ⵖⴻⵣⵣⵉⴼⴻⵏ ⴷⴻⴳ ⵜⴼⴻⵍⵡⵉⵜ, ⴰⴷ ⵏⴽⴻⵎⵎⴻⵍ ⵙ ⴽⵔⴰ ⵏ ⵜⴻⵎⵀⴻⵍⵜ ⴰⵔⴰ ⴷⵉⴽⴻⵛⵎⴻⵏ, ⵢⴻⵔⵏⴰ ⵎⵉ ⴰⵔⴰ ⵜⴼⴰⴽ ⵜⴻⵎⵀⴻⵍⵜ ⵖⴻⵣⵣⵉⴼⴻⵏ, ⵏⴻⵣⵎⴻⵔ ⴽⴰⵏ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵍⵉⵍ ⴰⵙⴻⵇⴷⴰⵛ. ⴰⵙⵓⴷⴷⴻⵎ ⵏ ⵓⵙⴻⴹⵔⵓ ⵢⴻⵜⵜⵓⵖⴰⵍ ⴷ ⵡⵉⵏ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ:

ⵙ ⵓⵙⵡⵉⵔⴰ ⵏ ⵓⵙⵙⴻⴹⵔⵓ, ⵜⴻⵙⵏⴻⵔⵏⴰ ⵙ ⵡⴰⵟⴰⵙ ⵜⵎⵓⵙⵙⵏⵉ ⵏ ⵓⵙⴻⵇⴷⴻⵛ. ⵜⵓⵔⴰ ⴰⵙⴻⵇⴷⴰⵛ ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵢⴻⴱⴷⵓ ⵜⴰⵎⵀⴻⵍⵜ ⵏ ⵜⵖⵓⵔⵉ ⵖⴻⵣⵣⵉⴼⴻⵏ, ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⴰⴷ ⵢⴻⵙⵙⴻⵇⴷⴻⵛ ⴰⵙⴻⵏⴼⴰⵔ ⵙ ⵜⵖⴰⵡⵍⴰ, ⵢⴻⵔⵏⴰ ⴰⴷ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⵔⴷⴻⵛ ⵎⵉ ⴰⵔⴰ ⵜⴼⴰⴽ ⵜⴻⵎⵀⴻⵍⵜ. ⴷ ⴰⵢⴰ ⴰⵢ ⴷ ⵍⵍⵙⴰⵙ ⵏ ⵓⵙⴻⵍⴽⴻⵎ asynchrone.

Javascript, ⴳⴰⵔ ⵜⵓⵜⵍⴰⵢⵉⵏ ⵏⵏⵉⴹⴻⵏ, ⵢⴻⵜⵜⵄⴰⵡⴰⵏ ⴰⵖⴰⵏⵉⴱⴰ ⵏ ⵓⵙⴻⵍⴽⵉⵎ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⴼⴰⵔ ⵙ ⵓⵙⵏⴻⴼⵍⵉ ⵏ APInsen ⵙ ⵡⴰⵟⴰⵙ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⴰⵡⴻⴹ ⵇⵔⵉⴱ ⵢⴰⵍ ⵜⵉⴽⵍⵉ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⴼⴰⵔ ⵉ ⵜⵣⴻⵎⵔⴻⴹ ⴰⴷ ⵜⵜⵉⴷⵜⵅⴻⵎⵎⴻⴹ. ⴷⴻⴳ ⵜⴰⴳⴳⴰⵔⴰ ⵏ ⵡⴰⵙⵙ, Javascript ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵜⵖⴰⵡⵍⴰ ⴷ ⵜⵓⵜⵍⴰⵢⵜ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⵇⴻⴷ. ⵎⴰ ⵏⴻⴱⴷⴻⵔⴷ ⴰⵎⴻⴷⵢⴰ ⵉⵄⴻⴷⴷⴰⵏ, ⵍⵇⴰⵏⵓⵏ asynchrone ⵢⴻⵍⵍⴰ ⴷⴻⴳ ⵍⵍⵙⴰⵙ ⵏ ⵡⴰⴽⴽ ⵉⵙⴻⵏⴼⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵙⴻⵇⴷⴰⵛ, ⵢⴻⵔⵏⴰ Javascript ⵢⴻⵜⵜⵡⴰⴱⵏⴰ ⵙ ⵓⵎⴰⵜⴰ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⵜⵜⵡⴰⵙⴻⵇⴷⴻⵛ ⴷⴻⴳ ⵓⵙⵎⴻⵍ ⴰⵏⴷⴰ ⴰⵎⵓⵔ ⴰⵎⴻⵇⵔⴰⵏ ⵙⴻⴳ ⵡⴰⵀⵉⵍⴻⵏ ⵜⵜⵎⴻⵙⵍⴰⵢⴻⵏ ⵖⴻⴼ ⵜⴳⴻⵔⵎⴰⵏⵜ ⴷⴻⴳ ⵜⵉⴳⴰⵡⵉⵏ ⵏ ⵓⵙⴻⵇⴷⴰⵛ.

ⴰⵢⴰⴳⵉ ⴰⴷ ⴰⴽⴷ-ⵢⴻⴼⴽ ⴰⴹⵔⵉⵙ ⴰⴳⴻⵊⴷⴰⵏ ⵖⴻⴼ Javascript Asynchrone:

ⵜⵉⵖⵔⵉⵡⵉⵏ

ⴷⴻⴳ ⵡⴰⵀⵉⵍ ⵏ ⵜⵎⴻⵥⵔⵉ, ⵙ ⵓⵎⴰⵜⴰ ⴰⴷ ⵜⴰⴼⴻⴹ ⴰⵟⴰⵙ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ. ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⵜⴰⵖⵓⵍⵜ, ⴰⴷ ⴰⵙⵏⴻⵙⵙⴰⵡⴻⵍ ⵙ ⵜⵎⴻⵥⵔⵉ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ. ⴰⴽⴰⵔⴰⵎ ⵏ ⵜⵎⴻⵥⵍⴰ ⴰⴷ ⵢⴻⴳ ⵢⴻⵔⵏⴰ ⴰⴷ ⴷⵢⴻⵔⵔ ⴰⴳⵎⵓⴹ, ⵓⵍⴰⵛ ⴽⵔⴰ ⵏ ⵜⵖⴰⵡⵙⴰ ⵓⵔ ⵏⴻⵍⵍⵉ ⴰⵔⴰ ⴷ ⵍⵇⴰⵏⵓⵏ. ⴰⵀⵉⵍ asynchrone ⵢⴻⵜⵜⴱⴻⴷⴷⵉⵍ ⵛⵡⵉⵟ ⵍⵇⴰⵏⵓⵏⴰ. ⵎⴰ ⵏⵓⵖⴰⵍ ⵖⴻⵔ ⵓⵎⴻⴷⵢⴰ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵓⵎⴻⵖⵔⵉ ⵏ ⵢⴻⴷⵍⵉⵙⴻⵏ, ⵓⵔ ⵏⴻⵣⵎⵉⵔ ⴰⵔⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵙⵡⵉⵔ ⵉ ⵓⵙⴻⴹⵔⵓ ⵏ ⵜⵎⴻⵏⴹⴰⵡⵜ ⵏ ⵜⴻⵎⵀⴻⵍⵜ ⵏ ⵓⵏⴰⴷⵉ ⵉⵎⵉ ⵜⴰⵎⵀⴻⵍⵜⴰ ⵜⴻⵟⵟⴻⴼ ⴰⴽⵓⴷ ⵓⵔ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵔⴰ. ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵙⵡⵉⵔ ⴰⴷ ⴷⵜⵓⵖⴰⵍ ⴷⴻⴳ ⵍⵍⵙⴰⵙ ⵓⵇⴱⴻⵍ ⴰⴷ ⴷⵜⵉⵍⵉ ⵜⴻⵎⵀⴻⵍⵜ, ⵢⴻⵔⵏⴰ ⵎⴰⵞⵞⵉ ⴷ ⵜⵉⴽⵍⵉⴰ ⵉ ⵏⴻⵜⵜⵕⴰⴵⵓ. ⵜⵉⴼⵔⴰⵜ ⴷ ⴰⵙⴻⴱⵜⴻⵔ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏⵏⵉⴹⴻⵏ ⴰⵔⴰ ⵢⴻⵜⵜⵡⴰⵅⴻⴷⵎⴻⵏ ⵎⵉ ⴰⵔⴰ ⴷⵜⵉⵍⵉ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ. ⴰⵢⴰ ⵢⴻⵜⵜⵎⵓⵇⵓⵍ ⵜⴰⵍⵓⴼⵜⵏⵏⴻⵖ ⵏ ⵓⵙⴻⵇⴷⴻⵛ ⵉⵎⵉ ⴰⵀⵉⵍⵏⵏⴻⵖ ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⴰⴱⵔⵉⴷⵉⵙ ⵙ ⵜⵖⴰⵔⴰ ⵢⴻⵔⵏⴰ ⵎⵉ ⴰⵔⴰ ⵜⴼⴰⴽ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ, ⴰⴷ ⵜⴻⵅⴷⴻⵎ ⵜⵎⴻⵥⵍⴰ ⵢⴻⵜⵜⵡⴰⵙⴱⴻⴷⴷⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⴻⵙⵙⵉⵡⴻⴹ ⵉ ⵓⵙⴻⵇⴷⴰⵛ ⵉⴳⵎⴰⴹ ⵏ ⵓⵏⴰⴷⵉ. ⵜⴰⵖⵓⵍⵜⴰ ⴷ ⴰⵢⴻⵏ ⵓⵎⵉ ⵏⴻⵇⵇⴰⵔ ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵙⵉⵡⴻⵍ:

// Search occurrences function
function searchOccurrences(word, callback) {
  try {
    // search operation logic, result is in result variable
    //....
    callback(null, word, result);
  } catch (err) {
    callback(err);
  }
}

// Search occurrences callback function
function handleSearchOccurrencesResult(err, word, result) {
  if (err) {
    console.log(`Search operation for ${word} ended with an error`);
  } else console.log(`Search results for ${word}: ${result}`);
  return;
}

searchOccurrences("the", handleSearchOccurrencesResult);

ⵜⴰⵣⵡⴰⵔⴰ, ⴰⴷ ⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⵜⴰⵖⵓⵍⵜ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ, searchOccurrences. ⵢⴻⵜⵜⴰⵡⵉⴷ ⴰⵡⴰⵍ ⴰⵔⴰ ⴷⵏⴰⴷⵉ ⴷ ⵢⵉⵡⴻⵏ ⵏ ⵓⴼⴻⵔⴷⵉⵙ ⵡⵉⵙ ⵙⵉⵏ “ⵛⴰⵍⵍⴱⴰⵛⴽ” ⴰⵔⴰ ⵢⵉⵍⵉⵏ ⴷ ⵜⴰⵖⵓⵍⵜ ⴰⵔⴰ ⴷⵢⴻⴹⵔⵓⵏ ⵎⵉ ⴰⵔⴰ ⵜⴼⴰⴽ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ. ⵜⴰⵖⵓⵍⵜ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ ⵜⴻⵍⵍⴰⴷ ⵙ ⵍⴻⴱⵖⵉ ⴷ ⵜⵉⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⵍⵎⴻⵄⵏⴰ, ⵢⴻⵙⵙⴻⴼⴽ ⴽⴰⵏ ⴰⴷ ⵏⴻⴱⴷⴻⵔ ⵙⵉⵏ ⵏ ⵢⵉⴳⴻⵎⵎⴰⴹⵉⵙ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⴷⵉⵍⵉⵏ : ⵜⴰⵍⵓⴼⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⴷ ⵜⵉⵏ ⴰⵢⴷⴻⴳ ⴽⵓⵍⵍⴻⵛ ⵢⴻⴷⴷⴰ ⵙ ⵔⵔⴱⴻⵃ ⵢⴻⵔⵏⴰ ⵏⴻⵙⵄⴰ ⴰⴳⵎⵓⴹ ⵏ ⵓⵏⴰⴷⵉ ⴷⴻⴳ ⵓⵎⴳⵉⵔⴻⴷ ⵏ ⵓⴳⵎⵓⴹ. ⴷⴻⴳ ⵜⴰⵍⵓⴼⵜⴰ, ⵢⴻⵙⵙⴻⴼⴽ ⴽⴰⵏ ⴰⴷ ⴷⵏⴻⵙⵙⵉⵡⴻⵍ ⵉ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵙⴽⴰⵙⵉ ⵙ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏⴰ : ⴰⴼⴻⵔⴷⵉⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵏⵓⵍⵍ ⴰⵏⴰⵎⴻⴽⵉⵙ ⵓⵍⴰⵛ ⵜⵓⵛⵛⴹⴰ ⵉ ⴷⵢⴻⴹⵔⴰⵏ, ⴰⴼⴻⵔⴷⵉⵙ ⵡⵉⵙ ⵙⵉⵏ ⴷ ⴰⵡⴰⵍ ⵉ ⴷⵢⴻⵜⵜⵡⴰⴼⴻⵔⵏⴻⵏ, ⴷ ⴰⴼⴻⵔⴷⵉⵙ ⵡⵉⵙ ⴽⵔⴰⴹ ⴰⵀⴰⵜ ⴷ ⴰⵢⴻⵏ ⵢⴻⵙⵄⴰⵏ ⴰⵣⴰⵍ ⴰⴽⴽ ⴳⴰⵔ ⴽⵔⴰⴹⵏⵏⵉ ., ⴷ ⴰⴳⴻⵔⵔⵓⵊ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ.

ⵜⴰⵍⵓⴼⵜ ⵜⵉⵙ ⵙⵏⴰⵜ ⴷ ⵜⵉⵏ ⵉⴷⴻⴳ ⵜⴻⴹⵔⴰ ⵜⵓⵛⵛⴹⴰ, ⴰⵢⴰ ⴷⴰⵖⴻⵏ ⴷ ⵜⴰⵍⵓⴼⵜ ⵉⴷⴻⴳ ⴰⵔⴰ ⴷⵢⵉⵍⵉ ⵓⵅⴻⴷⴷⵉⵎ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ ⵢⴻⵔⵏⴰ ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⴷⵏⴻⵙⵙⵉⵡⴻⵍ ⵉ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵙⵎⴻⴽⵜⵉ. ⵏⴻⵙⵙⴻⵇⴷⴰⵛ ⴰⵃⵔⵉⵛ ⵏ ⵜⵔⵢ ⴰⵏⴷ ⵛⴰⵜⵛⵀ ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⵃⴻⴱⴱⴻⵙ ⵢⴰⵍ ⵜⵓⵛⵛⴹⴰ ⵢⴻⵔⵏⴰ ⵏⴻⵙⵙⴰⵡⴻⵍ ⴽⴰⵏ ⵉ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵙⵉⵡⴻⵍ ⵙ ⵜⵖⴰⵡⵙⴰ ⵏ ⵜⵓⵛⵛⴹⴰ ⵙⴻⴳ ⵓⵃⵔⵉⵛ ⵏ ⵛⴰⵜⵛⵀ.

ⵏⴻⵙⴱⴻⴷⴷⴷ ⵙⵢⵉⵏ ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵙⵎⴻⴽⵜⵉ, handleSearchOccurrences, ⵏⴻⵃⵔⴻⵣ ⵍⵇⴰⵏⵓⵏⵉⵙ ⵙ ⵜⵖⴰⵡⵍⴰ. ⴷ ⵜⴰⵎⵙⴰⵍⵜ ⴽⴰⵏ ⵏ ⵓⵙⵙⵉⴳⴳⴻⵣ ⵏ ⵢⵉⵣⴻⵏ ⵖⴻⵔ ⵜⵎⴻⵥⴷⵉⵜ. ⵏⴻⵜⵜⵡⴰⵍⵉ ⴷⵉ ⵜⴰⵣⵡⴰⵔⴰ ⴰⴼⴻⵔⴷⵉⵙ “ⴻⵔⵔ” ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⵥⴻⵔ ⵎⴰ ⵢⴻⵍⵍⴰ ⴽⵔⴰ ⵏ ⵜⵓⵛⵛⴹⴰ ⵜⴻⴹⵔⴰⴷ ⴷⴻⴳ ⵜⵎⴻⵥⵍⴰ ⵜⴰⵖⴻⵍⵏⴰⵡⵜ. ⴷⴻⴳ ⵜⴻⴳⵏⵉⵜⵏⵏⵉ, ⴰⴷ ⵏⴻⴵⴵ ⴽⴰⵏ ⴰⵙⴻⵇⴷⴰⵛ ⴰⴷ ⵢⵉⵙⵙⵉⵏ ⴱⴻⵍⵍⵉ ⵜⴰⵎⵀⴻⵍⵜ ⵏ ⵓⵏⴰⴷⵉ ⵜⴻⴽⴼⴰ ⵙ ⵜⵓⵛⵛⴹⴰ. ⵎⴰ ⵢⴻⵍⵍⴰ ⵓⵔ ⴷⵜⵜⵡⴰⴱⴻⴷⵔⴻⵏⵜ ⴰⵔⴰ ⵜⵓⵛⵛⴹⵉⵡⵉⵏ, ⴰⴷ ⴷⵏⴻⵙⵙⵓⴼⴼⴻⵖ ⵉⵣⴻⵏ ⵙ ⵓⴳⵎⵓⴹ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ.

ⴷⴻⴳ ⵜⴰⴳⴳⴰⵔⴰ, ⴰⴷ ⴷⵏⴻⵙⵙⴰⵡⴻⵍ ⵉ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉOccurrences ⵙ ⵡⴰⵡⴰⵍ “ⵜⵀⴻ”. ⵜⴰⵖⵓⵍⵜ ⴰⴷ ⵜⴻⴷⴷⵓ ⵜⵓⵔⴰ ⵙ ⵍⵇⴰⵏⵓⵏ ⵡⴰⵔ ⵎⴰ ⵜⴻⵃⴱⴻⵙ ⴰⵀⵉⵍ ⴰⴳⴻⵊⴷⴰⵏ ⵢⴻⵔⵏⴰ ⵎⵉ ⴰⵔⴰ ⴷⵢⴻⴼⴼⴻⵖ ⵓⵏⴰⴷⵉ, ⴰⴷ ⴷⵢⵉⵍⵉ ⵓⵄⵉⵡⴻⴷ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵔⵏⴰ ⴰⴷ ⴷⵏⴰⵡⵉ ⵉⵣⴻⵏ ⵏ ⵓⴳⵎⵓⴹ ⴰⵎⴰ ⵙ ⵓⴳⵎⵓⴹ ⵏ ⵓⵏⴰⴷⵉ ⵏⴻⵖ ⵉⵣⴻⵏ ⵏ ⵜⵓⵛⵛⴹⴰ.

ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⴷⵏⴻⵙⵎⴻⴽⵜⵉ ⴷⴰⴳⵉ ⴱⴻⵍⵍⵉ ⵏⴻⵙⵄⴰ ⴽⴰⵏ ⴰⴱⵔⵉⴷ ⵖⴻⵔ ⵓⵎⴳⵉⵔⴻⴷ ⵏ ⵓⴳⵎⵓⴹ ⴷⴰⵅⴻⵍ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵜⵉⵎⴻⵇⵔⴰⵏⵉⵏ ⴷ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵓⵙⵎⴻⵍ. ⵎⴰ ⵏⴻⵄⵔⴻⴹ ⴽⵔⴰ ⴰⵎ ⵡⴰ:

let result;
function searchOccurrences(word, callback) {
  try {
    // search operation logic, result is in searchResult variable
    //....
    result = searchResult;
    callback(null, word, result);
  } catch (err) {
    callback(err);
  }
}
searchOccurrences("the", handleSearchOccurrencesResult);
console.log(result);

ⴰⴳⵎⵓⴹ ⵏ ⵜⵖⵓⵔⵉ ⴰⴷ ⵢⵉⵍⵉ ⵓⵔ ⵢⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵔⴰ ⴰⵛⴽⵓ ⴰⵀⵉⵍⴻⵏ ⵓⵔ ⵜⵜⵕⴰⵊⵓⵏ ⴰⵔⴰ ⴰⴷ ⵜⵉⴷⵜⴻⵅⴷⴻⵎ ⵜⵎⴻⵥⵍⴰ searchOccurrences. ⵢⴻⵜⵜⴽⴻⵎⵎⵉⵍ ⵖⴻⵔ ⵜⴻⵙⵍⴻⴹⵜ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ ⵢⴻⵍⵍⴰⵏ ⴷ ⴰⵙⴻⴼⵔⵓ ⵏ ⵜⵖⵓⵔⵉ ⵓⵇⴱⴻⵍ ⴰⴷ ⵢⴻⵜⵜⵓⵏⴻⴼⴽ ⵓⵎⴳⵉⵔⴻⴷ ⵏ ⵓⴳⵎⵓⴹ ⴷⴰⵅⴻⵍ ⵏ ⵜⵎⴻⵥⵍⴰ ⵜⴰⵖⴻⵍⵏⴰⵡⵜ. ⵙ ⵡⴰⵢⴰ, ⴰⴷ ⴷⵏⴻⵙⵙⴻⵣⵔⴻⴳ ⴰⵎⴳⵉⵔⴻⴷ ⵏ ⵓⴳⵎⵓⴹ ⵓⵔ ⵢⴻⵜⵜⵡⴰⴼⴻⵔⵏⴻⵏ ⴰⵔⴰ.

ⵉⵀⵉ ⵙ ⵍⵙⴰⵙ ⵏ ⵍⵇⴰⵏⵓⵏⴰ, ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵏⴻⵃⵔⴻⵣ ⴰⴽⴽ ⴰⴽⴰⵔⴰⵎ ⵉ ⵢⴻⵙⵇⴻⴷⵛⴻⵏ ⴰⴱⴻⴷⴷⴻⵍ ⵏ ⵓⴳⵎⵓⴹ ⴷⴰⵅⴻⵍ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵙⵎⴻⵍ. ⴰⵀⴰⵜ ⴰⵢⴰ ⵓⵔ ⵢⴻⵜⵜⴱⴰⵏ ⴰⵔⴰ ⴷ ⵓⴳⵓⵔ ⵜⵓⵔⴰ ⵎⴰⵛⴰ ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵢⴻⵏⵏⴻⵔⵏⵉ ⵙ ⵜⵖⴰⵡⵍⴰ ⵖⴻⵔ ⵡⵓⴳⵓⵔ ⵏ ⵜⵉⴷⴻⵜ. ⵅⴰⵢⴻⵍⴷ ⵜⴰⵍⵓⴼⵜ ⴰⵏⴷⴰ ⵏⴻⵙⵄⴰ ⵜⴰⵙⴻⵏⵙⴻⵍⴽⵉⵎⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⵇⴻⵙ ⵉ ⵢⴻⵙⵙⴻⴼⴽⴻⵏ ⴰⴷ ⴷⴷⵓⵏⵜ ⵙ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ, Deg ⵍⵇⴰⵏⵓⵏ ⵏ ⵓⵙⵉⵡⴻⵍ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⴰⴷ ⵜⴻⵙⵇⴻⴷⵛⴻⴹ ⴽⵔⴰ ⴰⵎ ⵡⴰ:

functionA(function (err, resA) {
  ///......
  functionB(resA, function (err, resB) {
    ///......
    functionC(resB, function (err, resC) {
      ///......
      functionD(resC, function (err, resD) {
        ///......
      });
    });
  });
});

ⵃⵔⴻⵣ ⴷⴻⴳ ⵡⴰⵍⵍⴰⵖⵉⴽ ⴱⴻⵍⵍⵉ ⵢⴰⵍ ⴰⵙⵉⵡⴻⵍ ⵢⴻⵙⵄⴰ ⴰⴼⴻⵔⴷⵉⵙ ⵏ ⵜⵓⵛⵛⴹⴰ ⵢⴻⵔⵏⴰ ⵢⴰⵍ ⵜⵓⵛⵛⴹⴰ ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵜⴻⵜⵜⵡⴰⵃⵔⴻⵣ ⵙ ⵜⵖⴰⵡⵍⴰ. ⴰⵢⴰ ⵢⴻⵜⵜⴳⴻⵏ ⴰⴽⴰⵔⴰⵎ ⵢⴻⵍⵍⴰⵏ ⵢⴰⴽⴰⵏ ⴷ ⴰⵖⴻⵣⴼⴰⵏ ⵏⵏⵉⴳⴰ ⴷ ⴰⵖⴻⵣⴼⴰⵏ ⵓⴳⴰⵔ ⵢⴻⵔⵏⴰ ⴷ ⴰⵢⴻⵏ ⵉⵡⴻⵄⵔⴻⵏ ⴰⴷ ⵢⴻⵜⵜⵡⴰⵃⵔⴻⵣ. ⴰⵙⵉⵔⴻⵎ, Promises ⵍⵍⴰⵏ ⴷⴰⴳⵉ ⴰⴽⴽⴻⵏ ⴰⴷ ⴼⵔⵓⵏ ⵓⴳⵓⵔ ⵏ ⵍⴵⴻⵏⵏⴻⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⴰⴷ ⴷⵏⴻⴱⴷⴻⵔ ⴰⵢⴰ ⵙⴷⴰⵜⵏⴻⵖ.

ⵉⵄⵓⵀⵓⴷ

ⵍⵡⴻⵄⴷⴰⵜ ⵜⵜⵡⴰⴱⵏⴰⵏⵜ ⵖⴻⴼ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵔⵏⴰ ⵅⴻⴷⴷⵎⴻⵏⵜ ⵙ ⵜⵖⴰⵡⵙⴰ ⴰⵎ ⵜⴰ. ⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⴷⴻⴳ ⵓⴽⴰⵜⴰⵔ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ES6 ⴰⴽⴽⴻⵏ ⴰⴷ ⴼⵔⵓⵏ ⴽⵔⴰ ⵏ ⵜⴻⵎⵙⴰⵍ ⵉⴱⴰⵏⴻⵏ ⵙ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⴰⵎ ⵍⴵⴻⵏⵏⴻⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ. ⵉⵄⴻⵡⵡⵉⵇⴻⵏ ⵜⵜⴰⴽⴻⵏⴷ ⵜⵉⵣⴻⵎⵎⴰⵔⵏⵙⴻⵏ ⵙ ⵜⵉⵎⵎⴰⴷⵏⵙⴻⵏ ⵉ ⵢⴻⵜⵜⴽⴻⵎⵎⵉⵍⴻⵏ ⵙ ⵜⴽⴻⵎⵎⴻⵍⵜ ⵙ ⵔⵔⴱⴻⵃ (ⵜⵉⴼⵔⴰⵜ), ⴷ ⵎⵉ ⴰⵔⴰ ⴷⴹⵔⵓⵏⵜ ⵜⵓⵛⵛⴹⵉⵡⵉⵏ (ⵜⵓⴳⵉ). ⴰⵢⴻⵏ ⵉⴷⵉⵜⴻⴷⴷⵓⵏ ⵢⴻⵙⵙⴽⴰⵏⴰⵢⴷ ⴰⵎⴻⴷⵢⴰ ⵏ searchOccurrences ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵙ ⵍⴻⵄⵇⵓⴷⴰⵜ:

// Search occurrences function
function searchOccurrences(word) {
  return new Promise((resolve, reject) => {
    try {
      // search operation logic, result is in result variable
      //....
      resolve(word, result);
    } catch (err) {
      reject(err);
    }
  });
}

searchOccurrences("the")
  .then((word, result) => {
    console.log(`Search results for ${word}: ${result}`);
  })
  .catch((err) => {
    console.log(`Search operation ended with an error`);
  });

ⴰⴷ ⵏⵡⴰⵍⵉ ⵉⴱⴻⴷⴷⴰⵍⴻⵏ ⵉ ⴷⵏⴻⵙⵙⴻⵅⴷⴻⵎ:

ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵏⴰⴷⵉOccurrences ⵜⴻⵜⵜⴰⴵⴵⴰⴷ ⵍⵎⴻⵄⵇⵓⵍ. ⴷⴰⵅⴻⵍ ⵏ ⵍⵡⴻⵄⴷ, ⵏⴻⵟⵟⴻⴼ ⵢⵉⵡⴻⵏ ⵏ ⵍⵇⴰⵏⵓⵏ : ⵏⴻⵙⵄⴰ ⵙⵏⴰⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵉⴼⵔⴰⵜ ⴷ ⵜⵓⴳⵉ ⵉ ⴷⵢⴻⵎⵎⴰⵍⴻⵏ ⵜⵉⵖⵔⵉⵡⵉⵏⵏⵏⴻⵖ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵡⴰⵍⴰ ⴰⴷ ⵏⴻⵙⵄⵓ ⵢⵉⵡⴻⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵉ ⵢⴻⵜⵜⵃⴰⴷⴰⵔ ⴰⵎⴰ ⴷ ⴰⵅⴻⴷⴷⵉⵎ ⵉⴳⴻⵔⵔⵣⴻⵏ ⴰⵎⴰ ⴷ ⴰⵅⴻⴷⴷⵉⵎ ⵙ ⵜⵓⵛⵛⴹⵉⵡⵉⵏ. ⵉⵄⴻⵡⵡⵉⵇⴻⵏ ⴱⴹⴰⵏ ⵙⵉⵏ ⵏ ⵢⵉⴳⴻⵎⵎⴰⴹ ⵢⴻⵔⵏⴰ ⵜⵜⴰⴽⴻⵏⴷ ⵜⴰⵙⴻⵏⵙⴻⵍⴽⵉⵎⵜ ⵣⴻⴷⴷⵉⴳⴻⵏ ⵎⵉ ⴰⵔⴰ ⴷⵙⵙⵉⵡⵍⴻⵏ ⵉ ⵜⵎⴻⵥⵍⴰ ⵜⴰⵖⴻⵍⵏⴰⵡⵜ. ⵜⴰⵖⵓⵍⵜ ⵏ ⵜⵉⴼⵔⴰⵜ “ⵜⴻⵇⵇⴻⵏ” ⵖⴻⵔ ⵜⴰⵖⵓⵍⵜ ⵜⴰⵖⴻⵍⵏⴰⵡⵜ ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵜⵎⴻⵥⴷⵉⵜ “ⵙⵢⵉⵏ”. ⴷⴰⴳⵉ ⴰⴷ ⴷⵏⴻⴱⴷⴻⵔ ⴽⴰⵏ ⵙⵉⵏ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵜⵉⴼⵔⴰⵜ ⵢⴻⵔⵏⴰ ⴰⴷ ⴷⵏⴻⵙⵙⵓⴼⴼⴻⵖ ⴰⴳⵎⵓⴹ ⵏ ⵓⵏⴰⴷⵉ. ⵜⴰⵖⴰⵡⵙⴰ ⴰⵎ ⵜⴰ ⵜⴻⵜⵜⴽⴻⵎⵎⵉⵍ ⴷⴻⴳ ⵜⵎⴻⵥⵍⴰ ⵏ ⵜⵓⴳⵉ, ⵜⴻⵣⵎⴻⵔ ⴰⴷ ⵜⴻⵜⵜⵡⴰⵃⴱⴻⵙ ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵜⵎⴻⵥⵍⴰ “ⵛⴰⵜⵛⵀ”. ⵙ ⵓⵙⵉⵔⴻⵎ, ⵜⵣⴻⵎⵔⴻⵎ ⴰⴷ ⵜⵇⴰⴷⵔⴻⵎ ⵍⴼⴰⵢⴷⴰⵜ ⴰⵢ ⴷⵜⵜⴰⴽⴻⵏ ⵢⵉⵄⴻⵡⵡⵉⵇⴻⵏ ⴷⴻⴳ ⵡⴰⵢⴻⵏ ⵢⴻⵔⵣⴰⵏ ⵜⴰⵖⵓⵔⵉ ⵏ ⵓⴹⵔⵉⵙ ⴷ ⵜⴻⵣⴷⴻⴳ. ⵎⴰ ⵎⴰⵣⴰⵍⵉⴽ ⵜⴻⵜⵜⵎⴻⵙⵍⴰⵢⴻⴹ ⴼⴻⵍⵍⴰⵙ, ⵥⴻⵔ ⴰⵎⴻⴽ ⴰⵔⴰ ⵏⴻⴼⵔⵓ ⵓⴳⵓⵔ ⵏ ⵍⴵⴻⵏⵏⴻⵜ ⵏ ⵓⵙⵉⵡⴻⵍ ⵙ ⵓⵙⴷⵓⴽⴽⴻⵍ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⵇⴻⵙ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⵉⴷⵙⴱⴻⴷⴷⴻⵏⵜ ⵢⵉⵡⴻⵜ ⴷⴻⴼⴼⵉⵔ ⵜⴰⵢⴻⴹ:

searchOccurrences("the")
  .then(searchOccurrences("asynchronous"))
  .then(searchOccurrences("javascript"))
  .then(searchOccurrences("guide"))
  .catch((err) => {
    console.log(`Search operation ended with an error`);
  });

Async/Rǧu

ⴰⵙⵢⵏⵛ/Await ⴷ ⵔⵏⴰⵏⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵉ ⵜⵎⴻⵥⴷⵉⵜⵏⵏⴻⵖ ⵏ ⵡⴰⵍⵍⴰⵍⴻⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⵇⴻⴷ ⴷⴻⴳ Javascript. ⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵙ ES8, ⵜⵜⴰⴽⴻⵏⴷ ⵢⵉⵡⴻⵏ ⵏ ⵓⵙⵡⵉⵔ ⴰⵎⴰⵢⵏⵓⵜ ⵏ ⵜⵎⵓⵖⵍⵉ ⵙⴷⴰⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⴼⴰⵔ ⵙ “ⵓⵕⴰⴵⵓ” ⴽⴰⵏ ⵏ ⵓⵙⵙⴻⴹⵔⵓ ⵏ ⵜⵎⴻⵥⵍⴰ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵏⴼⴰⵔ. ⴰⵣⴰⵍ ⵏ ⵡⴰⵀⵉⵍ ⵢⴻⵜⵜⵃⴻⴱⴱⵉⵙ ⴷⴻⴳ ⵜⴻⵙⵍⴻⴹⵜⵏⵏⵉ ⴰⵍⴰⵎⵎⴰ ⴷ ⴰⵙⵎⵉ ⴰⵔⴰ ⴷⵢⵓⵖⴰⵍ ⵢⵉⵡⴻⵏ ⵏ ⵓⴳⵎⵓⴹ ⵙⴻⴳ ⵜⵎⴻⵥⵍⴰ asynchrone ⵙⵢⵉⵏ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵡⴰⵀⵉⵍ ⵙ ⵜⴻⵙⵍⴻⴹⵜ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ. ⵎⴰ ⵢⴻⵍⵍⴰ ⵜⴻⵜⵜⵅⴻⵎⵎⵉⵎⴻⴹ ⵖⴻⴼ ⵓⵙⵡⵉⵔ ⵏ ⵓⵅⴻⴷⴷⵉⵎ ⵏ ⵙⵉⵏⴽⵔⵓⵏ ⵜⵃⴻⵇⵇⴻⴹ. ⵏⵓⵙⴰⴷ ⵙ ⵜⵛⵉⵔⴹⴰⵔⵜ ⵜⴽⴻⵎⵎⴻⵍ! ⴰⵙⵢⵏⵛ/ⴰⵡⴰⵉⵜ ⵢⴻⵜⵜⵄⴻⵔⵔⵉⴹ ⴰⴷ ⴷⵢⴰⵡⵉ ⴰⵙⴻⴼⵙⴻⵙ ⵏ ⵓⵙⴻⵍⴽⵉⵎ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵙ ⵓⵎⴰⴹⴰⵍ ⴰⵙⵉⵏⴽⵔⵓⵏ. ⵜⵜⵅⵉⵍⴽ ⵃⵔⴻⵣ ⴷⴻⴳ ⵡⴰⵍⵍⴰⵖⵉⴽ ⴱⴻⵍⵍⵉ ⴰⵢⴰ ⵢⴻⵜⵜⵡⴰⵃⵙⴰⴱ ⴽⴰⵏ ⴷⴻⴳ ⵓⵙⵙⴻⴹⵔⵓ ⴷ ⵍⵇⴰⵏⵓⵏ ⵏ ⵡⴰⵀⵉⵍ. ⴽⵓⵍⵛⵉ ⵢⴻⵇⵇⵉⵎ ⴰⴽⴽⴻⵏ ⵢⴻⵍⵍⴰ ⴷⴷⴰⵡ ⵏ ⵜⵎⴻⵥⴷⵉⵜ, Async/ⴰⵡⴰⵉⵜ ⵎⴰⵣⴰⵍ ⵙⵙⴻⵇⴷⴰⵛⴻⵏ ⵍⴻⵡⵚⴰⵢⴰⵜ ⵢⴻⵔⵏⴰ ⵜⵉⵖⵔⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⴷ ⵜⵉⵖⴰⵡⵙⵉⵡⵉⵏⵏⵙⴻⵏ ⵏ ⵍⴻⴱⵏⵉ.

ⴰⴷ ⵏⵡⴰⵍⵉ ⴰⵎⴻⴷⵢⴰⵏⵏⴻⵖ ⴰⴷ ⵜⵏⴻⵙⵙⴻⴹⵔⵓ ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ Async/ⴰⵡⴰⵉⵜ:

async function searchOccurrences(word) {
  try {
    // search operation logic, result is in result variable
    //....
    return result;
  } catch (err) {
    console.log(`Search operation for ${word} ended with an error`);
  }
}

const word = "the";

const result = await searchOccurrences(word, handleSearchOccurrencesResult);

console.log(`Search results for ${word}: ${result}`);

ⴰⴽⴰⵔⴰⵎⵏⵏⴻⵖ ⵓⵔ ⵉⴱⴻⴷⴷⴻⵍ ⴰⵔⴰ ⴰⵟⴰⵙ, ⴰⵢⴻⵏ ⵢⴻⵙⵄⴰⵏ ⴰⵣⴰⵍ ⴰⴷ ⵜⵉⴷⵏⴻⴱⴷⴻⵔ ⴷⴰⴳⵉ ⴷ ⴰⵡⴰⵍ ⵏ ⵜⵎⴻⵥⴷⵉⵜ “ⴰⵙⵢⵏⵛ” ⵓⵇⴱⴻⵍ ⴰⵙⴻⵏⵇⴻⴷ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ searchOccurrences. ⴰⵢⴰ ⵢⴻⵙⵙⴽⴰⵏⴰⵢⴷ ⴱⴻⵍⵍⵉ ⵜⴰⵖⵓⵍⵜⵏⵏⵉ ⴷ ⵜⴰⵙⴻⴽⴽⵉⵔⵜ. ⴷⴰⵖⴻⵏ, ⵥⴻⵔ ⴰⵡⴰⵍ ⵏ ⵜⵎⴻⵥⴷⵉⵜ “ⴰⵡⴰⵉⵜ” ⵎⵉ ⴰⵔⴰ ⵜⴻⵙⵙⵉⵡⴹⴻⴹ ⵉ ⵜⵎⴻⵥⵍⴰ ⵏ searchOccurrences. ⴰⵢⴰ ⴰⴷ ⵢⴻⵙⵙⵉⵡⴻⴹ ⴰⵀⵉⵍ ⴰⴷ ⵉⵔⴰⴵⵓ ⴰⵙⴻⴹⵔⵓ ⵏ ⵜⵎⴻⵥⵍⴰ ⴰⵍⴰⵎⵎⴰ ⴷ ⴰⵙⵎⵉ ⴰⵔⴰ ⴷⵢⵓⵖⴰⵍ ⵓⴳⵎⵓⴹ ⵓⵇⴱⴻⵍ ⴰⴷ ⵢⴻⵣⵎⴻⵔ ⵡⴰⵀⵉⵍ ⴰⴷ ⵉⵄⴻⴷⴷⵉ ⵖⴻⵔ ⵓⴳⵎⵓⴹ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ, ⵙ ⵡⴰⵡⴰⵍⵏⵏⵉⴹⴻⵏ, ⴰⴱⴻⴷⴷⴻⵍ ⵏ ⵓⴳⵎⵓⴹ ⴰⴷ ⵢⴻⵟⵟⴻⴼ ⴷⵉⵎⴰ ⴰⵣⴰⵍ ⵢⴻⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ searchOccurrences ⵎⴰⵞⵞⵉ ⴷ ⵍⵡⴻⵄⴷ ⵏ . ⵜⴰⵖⵓⵍⵜ, ⴷⴻⴳ ⵓⵏⴰⵎⴻⴽⵏⵏⵉ, Async/Await ⵓⵔ ⵢⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵃⵔⵉⵛ ⵏ ⵜⵖⴻⵍⵍⵉⵙⵜ ⴰⵎ Promises. ⵎⵉ ⴰⵔⴰ ⵜⴼⴰⴽ ⵜⵎⴻⵥⵍⴰ, ⴰⴷ ⵏⵔⵓⵃ ⵖⴻⵔ ⵜⵎⴻⵏⴹⴰⵡⵜ ⵏ ⵜⵖⵓⵔⵉ ⵢⴻⵔⵏⴰ ⵜⵉⴽⴽⴻⵍⵜⴰ ⴰⴳⵎⵓⴹ ⵢⴻⵙⵄⴰ ⵙ ⵜⵉⴷⴻⵜ ⴰⴳⵎⵓⴹ ⵏ ⵜⵎⴻⵥⵍⴰ ⵏ ⵓⵏⴰⴷⵉ. ⴰⴽⴽⴻⵏ ⵉ ⴷⵏⴻⴱⴷⴻⵔ, ⴰⴽⴰⵔⴰⵎ ⴰⵎⴰⵢⵏⵓⵜ ⵢⴻⵙⵄⴰ ⵜⵉⴽⵍⵉ ⴰⵎⵣⵓⵏ ⴷ ⵙⵉⵏⴽⵔⵓⵏ.

ⵜⴰⵖⴰⵡⵙⴰ ⵏⵏⵉⴹⴻⵏ ⵜⴰⵎⴻⵛⵟⵓⵃⵜ ⴰⵔⴰ ⵏⴻⵃⵔⴻⵣ ⴷⴻⴳ ⵡⴰⵍⵍⴰⵖⵏⵏⴻⵖ ⴷ ⴰⴽⴽⴻⵏ ⵉⵎⵉ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⵜⵉⵖⴱⵓⵍⴰ ⵏ ⵓⵙⵎⴻⴽⵜⵉ, ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⵜⵓⵛⵛⴹⴰ ⵏ searchOccurrences ⴷⴰⵅⴻⵍ ⵏ ⵢⵉⵡⴻⵜ ⵏ ⵜⵖⴰⵡⵙⴰ ⵉⵎⵉ ⵓⵔ ⵏⴻⵣⵎⵉⵔ ⴰⵔⴰ ⴽⴰⵏ ⴰⴷ ⵏⴻⵙⵙⴻⵣⴳ ⵜⵓⵛⵛⴹⴰⵏⵏⵉ ⵖⴻⵔ ⵜⵖⴰⵡⵙⴰ ⵏ ⵓⵙⵎⴻⴽⵜⵉ ⵢⴻⵔⵏⴰ ⴰⴷ ⵜⵜⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⴷⵉⵏⵏⴰ. ⴷⴰⴳⵉ ⵏⴻⵙⵙⴻⵣⴳⴻⵔ ⴽⴰⵏ ⵉⵣⴻⵏ ⵏ ⵜⵓⵛⵛⴹⴰ ⴷⴻⴳ ⵜⴻⴳⵏⵉⵜ ⵏ ⵜⵓⵛⵛⴹⴰ ⵖⴻⴼ ⵍⵊⴰⵍ ⵏ ⵓⵎⴻⴷⵢⴰ.

ⴰⵙⴻⵎⵔⴻⵙ

ⴷⴻⴳ ⵓⵎⴰⴳⵔⴰⴷⴰ ⵏⴻⴷⴷⴰ ⵙ ⵜⵜⴰⵡⵉⵍⴰⵜ ⵢⴻⵎⴳⴰⵔⴰⴷⴻⵏ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵉ ⵓⵙⴻⴹⵔⵓ ⵏ ⵍⵇⴰⵏⵓⵏ asynchrone ⴷⴻⴳ Javascript. ⵏⴻⴱⴷⴰ ⵙ ⵓⵏⴰⴷⵉ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵙ ⵡⴰⵛⵓ ⴰⵔⴰ ⵏⴻⵃⵡⴰⴵ ⴰⴷ ⵏⴱⴻⴷⴷⴻⵍ ⵙⴻⴳ ⵓⵙⵡⵉⵔ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵖⴻⵔ ⵓⵙⵡⵉⵔ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵙⵏⵉⵍⴻⵙ. ⵏⴻⴷⴷⴰ ⵙⵢⵉⵏ ⵖⴻⵔ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⴰⵢ ⴷ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵉⴳⴻⵊⴷⴰⵏⴻⵏ ⵏ ⵍⴻⴱⵏⵉ ⵏ Javascript asynchrone. ⵜⵉⵙⵡⵉⵄⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵙⵙⴰⵡⴹⴻⵏⵜⴰⵖ ⵖⴻⵔ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵎⴳⴰⵔⴰⴷⴻⵏ ⵉ ⴷⵢⴻⵔⵏⴰⵏ ⴷⴻⴳ ⵢⵉⵙⴻⴳⴳⴰⵙⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⵖⴻⵍⵍⴻⵜ ⵜⵉⵙⵡⵉⵄⵉⵏⴰ, ⵍⴰⴷⵖⴰ ⵍⵡⴻⵄⴷⴰⵜ ⴷ Async/ⴰⵡⴰⵉⵜ. Logic asynchrone ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵢⴻⵜⵜⵡⴰⴼ ⴷⴻⴳ ⵢⴰⵍ ⴰⵎⴽⴰⵏ ⴷⴻⴳ ⵡⴻⴱ, ⴰⵎⴰ ⵜⴻⵙⵙⴰⵡⵍⴻⴹ ⵉ API ⵏ ⴱⴻⵔⵔⴰ, ⵜⴻⴱⴷⵉⴹ ⴰⵙⴻⵇⴷⴻⵛ ⵏ ⵜⴱⴰⴹⵏⵉⵜ, ⵜⵉⵔⴰ ⴷⴻⴳ ⵓⵏⴰⴳⵔⴰⵡ ⵏ ⵢⵉⴼⵓⵢⵍⴰ ⵉⴷⵉⴳⴰⵏⴻⵏ, ⵏⴻⵖ ⵓⵍⴰ ⴷ ⵜⵜⵔⴰⴵⵓⴹ ⴰⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵙⴻⵇⴷⴰⵛ ⴷⴻⴳ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵜⵓⴽⴽⵙⴰ. ⵙ ⵓⵙⵉⵔⴻⵎ, ⵜⵓⵔⴰ ⵜⵃⵓⵍⴼⴰⴹ ⵙ ⵍⵇⴻⵡⵡⴰ ⵓⴳⴰⵔ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⵇⴰⴱⴻⵍⴹ ⵜⵉⵎⵙⴰⵍⴰ ⵙ ⵜⵉⵔⴰ ⵏ Javascript Asynchronous ⵣⴻⴷⴷⵉⴳⴻⵏ ⵢⴻⵔⵏⴰ ⵢⴻⵜⵜⵡⴰⵃⵔⴻⵣ!

ⵎⴰ ⵜⵃⴻⵎⵎⵍⴻⴹ ⴰⵎⴰⴳⵔⴰⴷⴰ, ⵜⵜⵅⵉⵍⴽ ⵥⴻⵔ CLA Blog ⴰⵏⴷⴰ ⴰⵔⴰ ⴷⵏⴻⵎⵎⴻⵙⵍⴰⵢ ⵖⴻⴼ ⵢⵉⵙⴻⵏⵜⴰⵍ ⵢⴻⵎⴳⴰⵔⴰⴷⴻⵏ ⵖⴻⴼ ⵡⴰⵎⴻⴽ ⴰⵔⴰ ⵜⴽⴻⵛⵎⴻⴹ ⴷⴻⴳ teknoloji. ⴷⴰⵖⴻⵏ, ⵥⴻⵔ ⴰⵥⴻⴹⴹⴰⵏⵏⴻⵖ ⵏ youtube ⵉ ⵢⵉⵙⴰⵔⴰⴳⴻⵏⵏⵏⴻⵖ ⵉⵍⴻⵍⵍⵉⵢⴻⵏ ⵉⵄⴻⴷⴷⴰⵏ ⵢⴻⵔⵏⴰ ⴹⴻⴼⴼⴻⵔⴰⵖⴷ ⴷⴻⴳ ⵉⵥⴻⴹⵡⴰⵏ ⵉⵏⵎⴻⵜⵜⵉⵢⴻⵏ ⴰⴽⴽⴻⵏ ⵓⵔ ⵜⵜⴻⵜⵜⵓⴹ ⴰⵔⴰ ⴷⴻⴳ ⵡⵉⴷ ⴰⵔⴰ ⴷⵢⴰⵙⴻⵏ!