แแฆแแก แแแแฎแกแแ แแฎแแแ แ แแแแกแขแ แแชแแ
แแ แแฅแแแ แแฃแแแ แกแแ แแแแฉแ, แแก แแแกแขแ แกแแ แแแ แแแแแแแแแแ แแ แแแ แแแแฌแแ แแ. แฉแแแ แแ แแแ แแแขแแ แคแแแกแแก แแแแแแแแแ แแแ แแแ แ Yandex-แแก แแแแกแแแก แแคแแกแจแ แแ SRI-แแก แแฃแ แกแแแแแแแ แแแฃแแแแ แฌแแแ แฌแแแแจแ.
แแแกแแแแจแ แ แแแแกแขแ แแชแแแก แแแฎแกแแแกแแแ แแแแแแจแแ แแแแ, แแแฅแแแงแแแแ แฌแแแ แกแแแแแก แจแแกแแแแแ แแแแชแแแแแแก แแแแแแแก - แแฅ, แแแแกแแจแ.
แแฃ แแแแแงแฃแ แก แแแแแแแแ SRI แแแแแแแแแแแก แแกแขแแ แแแก, แฌแแแแแ แฌแแแแแ แแแแแฌแแแแแแ แแ แแแ แแแแกแขแแแแกแแแแก แกแแ แแแแจแแแแแแแแ แฃแแแ แก:
- แแแแแแแแแ. แงแแแแ แแแแแแแแแ แก แฃแแแ แจแแแซแแแก แแแแแแแแแแก แแแแแแแแ. แแกแ แแ แฎแแแแ, แ แแ แแงแแแก แซแแ แกแแ แแแ, แ แแแแแแช แแแแแ แแฃแแแแกแแแแก แแฌแงแแแก แแแแแแแก แแ แจแแ แแฎแแแแ แกแแ แแแขแแแก แฌแแ . แแแแขแแ, แแแแแแฃแแแ แแแกแฌแแแแแ แฃแแแ แแฉแแแแแก, แ แแแแ แแชแแก แแแ แแคแ.
- JavaScript. แแฃ แกแแฅแแ แแฎแแแแ แแแแแแแแแแ แจแแแแแคแแ แแแแแแแ, แแแจแแ แฉแแแ แแแแฅแแแแแแ แแ แ แแแขแแ แคแแแกแแก แแแแแแแแ แแแแก แกแแแแ, แแ แแแแ แแแแแแแแแแก แแแแแแแแ แแแแก แกแแแแ. แแแแแแแ แจแแฅแแแแแ แแแขแแ แคแแแกแ แฃแแแ แแฆแแ แซแแแแแก. แแแแขแแ, JS-แแกแแแแก แงแแแแแแแแก แแ แแก แแแแแแแแ, แแแแ แแ แแแแฏแแ แแก แแกแแแ แแ แแก แแแแชแแแ แแแแแ แแแแแแแกแแแแก - แฉแแแ แแกแแแ แซแแแแแ แแแแงแแแ แก.
- แแ แแแแแแแก แแแแแญแ แ แแแแแแแแแ แแก แแแแแ แงแแแแแแ แแแแจแแแแแแแแแ แฃแแแ แแ. แ แแช แจแแแฎแแแ แแแขแแ แคแแแกแแแแก แจแแฅแแแแก, แงแแแแแคแแ แ แซแแแแแ แกแฌแ แแคแแ แแชแแแแแ. แแก แฐแแแแก แแฃแแก แแแ แแแก: โแฃแแแ แแ แแแแ แ แแช แจแแแซแแแแ แกแฌแ แแคแแ, แ แแ แแแ แฉแ แแ แแกแ แแ แแแแแ แแแแแแแก, แฎแแแ แกแฎแแ แแแแแแแ แแแกแแกแแแแแแ แแ แฏแแ แฃแคแ แ แกแฌแ แแคแแ แฃแแแ แแ แแแแโ. แงแแแแแแฆแแฃแ แแ แแฎแแแแแแ แแฎแแ แขแแฅแแแแแแแแแก โ แฃแแแ แแแแแแแแแแกแฌแแแแ แแกแแแ แแ แจแแแแแซแแแก แแแแ แแแแแแ. แแแแขแแ, แแแกแแแ แแแแแแแแแจแ แจแแแแแแแแแ แขแแฅแแแแแแแแแแก แแแแแแ, แ แแแแแแกแแช แแแแฌแงแแแ แแแแแแแแแ แ แฉแแแฃแแแแ แแ แแ แแชแแแแก.
แแแแแแฃแแ แแแแแแแแแก แแแแแแแแกแแก แแแแแงแแแแแ แแ แ แแฎแแแแ แกแฌแแ แ แแ แแชแแแฃแ แแก, แแ แแแแ แแแแ แชแแแแแฃแแ แจแแชแแแแแแแก แจแแกแแฎแแ.
แแแแชแแแ 1: แแแ แขแคแแแแ
แแแ แแแ แแแแชแแแแแ แแฃแจแแแแแแแ Yandex.Collections-แแก แแแแแแแแ แ แแแแฅแกแแ แฉแแ แแแแแแแฉแ, แ แแแแแแแช แแชแแก แ แแแแ แแแแแแแแก แแแแแแแแแ แแ แแแกแแ แแแแแแแ, แแแขแแ แคแแแกแแก แแแแแแแแแ แแ แกแแ แแแ แกแแแกแแแแแแ.
แแแแแแแ แแแแ
แจแแฅแแแแแ แแแ แขแคแแแแก แแแแกแแแขแ: แแแแแฎแแ แแ แแฅแแแแก แจแแกแแฎแแ, แแฅแแแแก แกแแฅแแแแแแแแแ แแ แแฅแแแแก แแแแแแแแแแแ แกแแแแแกแแแ. แกแแแขแ แแแฅแกแแแแแฃแ แแ แฃแแแ แจแแแกแแแแแแแแแแก แจแแแแแแแแแแแฃแ แแแแแแแแแแก (แแแฃแแแแ แแแแแแแแแแแ:
1000px ,600px ,320px ,แกแแแชแแคแแแแชแแ ). แฉแแแ แแฎแแแแ แแแแแแแแแ แแแแแแขแแ แแกแแแก, แแแแขแแ แแแฎแแแ แแ แแแแแแงแแแแ JavaScript.แจแแแแฌแแแแแกแแก แแแแแแแแแแกแฌแแแแแ:
- แฉแแฆแ แแแแแแแก แแแแแแ, แคแแ แแก แกแแกแฌแแ แ, แจแ แแคแขแแก แกแขแแแ, แจแ แแคแขแแก แแแแ;
- แกแแแแแขแแแฃแ แ แแแแแแแแแ;
- แแแแแแแขแแแแก แกแฎแแแแแกแฎแแ แแแแแแแ แแแแแแแก แแ แกแแแแแ: แฆแแแแแแแแกแ แแ แแแฃแแแแแก แฉแแแแแแ แแฃแ แกแแ แแก แแขแแ แแแแกแแก, แแฅแขแแฃแ แ แจแแงแแแแแก แแแแแแแก แฎแแแแแกแแ แแ แ.แจ.;
- แฏแแแ แแแแแ แแ แแฃแแแ แแก แแแแกแแแแแแแ (แจแแแแฌแแแแฃแแแ แแแแฃแแแ แฃแแ แแ แแฃแแแ แแแแก แฃแแฎแแแก แแแ แกแแแแจแ).
แฃแแแ แแขแแกแแแ แแฅแแแแ:
- แแแแแแแแ แแแ CSS แแแแแฌแงแแแขแแแแแแแแก แแแแแงแแแแแ: flexbox, grid แแ แ.แจ.;
- แแแแแขแฃแ แ แแแแแแแแแ;
- แฌแแแแกแฌแแ แแ (แแ) แแแกแขแแ แแชแแกแแ แแแแก แแแแแงแแแแแ, แแฌแงแแแ, แแแแแคแแแแชแแ, แแแแแแแแแแ แแแแแก แแแขแแแแแแชแแ;
- HTML แคแแ แแแก แแแแแแแชแแ, แกแขแแแแแแแฃแแ แคแแแแแก แแขแแแ แแแแก แฆแแแแแ.
แแแแชแแแ แกแแแแแแ แแแชแฃแแแแแแแ, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแแแขแแแแ แแก, แ แแช แแ แแแฃแจแแแแแก. แแก แแแแแ แจแแแแชแแ แแแก แแฅแแแแก แฅแฃแแแก, แแแแ แแ แแแแแช แจแแซแแแแ แแฅแแแแ แชแแแแแก แแแแแแกแขแ แแ แแแแก. แ แแแแกแแช แแแแกแ แฃแแแแ, แแแแแแแแแแแแแแ แแ แ แแแฃแแ - แแฅแแแแก แแแ แขแคแแแแแจแ แแ แฌแงแแ แแก แแแแ GitHub-แแ.
แแแแแแแแแจแ แจแแแแแแแแแแแฃแแ แแแแแแแแแ แแงแ แแ แ แแฎแแแแ แแแแแแฃแ แ แแแฌแงแแแแแแแแแแก, แแแแแจแแขแแแแกแ แแ แแแกแแขแแแแก แแแ แแแแแแ, แแ แแแแ แ แแแแฃแ แ แกแแแชแแคแแแแชแแแแแ.
แแแ แแแแ แแแแแแแแแก แจแแแแฌแแแแแก แจแแแแแจแ แ แแช แจแแแซแแแแ แแแขแ แแแแแฅแขแฃแ แแแ แจแแแแขแแแแแแงแ, แแ แจแแแแฌแแแแแก แฃแแแ แแแ แแ แแขแแ แแฃแแ แแงแ.
แแ แแขแแ แแฃแแแแ
แจแแฅแแแแแแ แกแแแขแ. แแก แแจแแแ แแ แฉแแแก, แแแแ แแ แแแแแแ แแแ แแแญแแ แแแแแแแแ แแแแแขแแแ แ แแแแแแแแ แแแแแ - แแ แกแฃแ แแแ แแ แแแก แแแแแแแ, แแ แแแ แจแแซแแแก. แแแแแแแแแ แจแแแซแแแแ แฃแฎแแจแแ แแแแงแแก แแแฎ แแแแแแ แแแ แแแแ: แแแแแแ แ แแแ แแแ แแแแขแแ แแ, แแแแแ SRI-แก แแแแแแแแแแแก แกแแแ, แแแแแ แแแ แขแคแแแแแแ แแ แแแแแ แกแแแแแขแแฅแขแ แแแคแแ แแแชแแแ. แแแแ แแแแแแแแแ แจแแแซแแแแแแ แกแแฅแชแแแแแ แแ แฃแแ แแแแ div-แแแแก แแแแแงแแแแแแ, แแแแแแ แแ, แ แแ แแแฎแแแ แแแแแ แแงแ แฎแแแแแกแแฌแแแแแ.
แแแแแแแแแแก แแแแแแแแแแกแแแ แจแแกแแแแแแกแแแ. แแแแแแแแ แแ แจแแฅแแแ แชแแแแ แกแแแชแแคแแแแชแแ (แแแ แจแแ แแก แคแแ แแแ, แขแแแแแ แแคแแ, แฆแแแแแแแแก แแแแแแแ แแแแแแ แแ แ.แจ.) แแแแแแแแขแแแแกแแแแก แแแกแแแแแแแแแแแ. แแแแแจแ แแงแ แแแแแจแแแแ แแแ แแแแ แแแ แแแแก แญแ แแแแแกแ แแ แแแฎแแกแแแแแแแแแแ. แซแแแแแ แแแแงแแคแแแ แแแงแแแ แแแญแแแแ, แ แแแแแแแแช แแแแแแแแแกแฌแแแแก แแแแแแแแ แแก แงแแแแ แกแฃแ แแแแ: แแแแแแแแแ, แแแ แแแแ แแแ แแแ แแ แแแแแแแ แฃแแแ แงแแคแแแแงแ แฎแแแแก แกแแแแฆแแแแ.
แแแแแขแฃแ แ แแแแแแแแแ - แแก แแ แแก แแแจแแ, แ แแแแกแแช แแแขแแ แคแแแกแ แฃแแ แแแแ แแ แแ แแก แแแแแแแแแฃแแ แแกแ, แ แแ แกแแแ แ แแแแแฃแชแแแ แงแแแแแคแแ แ แแแฅแกแแแแแแ แแแฅแกแแแแแแ แแงแแก แแแแแแแแแแ. แจแฃแแแแแฃแ แแแแแแแ แแแแแแจแ แแแแแแแแแแช แแ แฃแแแ แแจแแแแ. แแแแก แแแแแแฌแงแแ แแแแขแแแแแ แแก แแแฅแกแแแแแฃแ แ แกแแแแแแก แจแแแฆแฃแแแ แแ แงแแแแแคแแ แ 1920 แแแฅแกแแแแ แแแแงแแแ, แแแแแ แแแแคแฃแญแ แคแแแ, แแแแ แแ แแแแแแแแแแจแ แแแแแแแแขแแแแ แแแ แแแ แแแแ แแแแก แแแแ แแ แแแแชแแแแก.
แกแแแแแขแแแฃแ แ แแแแแแแแแ. "แ แแแแแแฏแแ แฃแแฎแ แแก แแแ แแกแแคแแแแก" แ แแ แแแฃแแ แฃแแแ แแงแแก แจแแฅแแแแแ แ แแแแ แช , แฆแแแแแ - แ แแแแ แช . แกแแแแแแแแ แแ, แแแแแแแแขแแแแก แฃแแแขแแกแแแแ แจแแแกแ แฃแแ แแก แแแแฎแแแแแช. แงแแแแแ แแ แแฆแแแ แ แคแแ แฃแแ แกแแ SRI-แก แแแแแแแแแแจแ, แ แแช แแแก div แขแแแแแแก แแแแแงแแแแแแ แแฅแชแแแก, แแแแ แแ แแก แแ แช แแกแ แชแฃแแแ. แแงแ แแแแแแแแขแ, แ แแแแแแแช แฉแแแ แงแแแแ แแก แกแแแแแขแแแฃแ แ แขแแแ, แ แแแแแแช แแชแแแ - แกแแ แแงแ แกแแญแแ แ แแ แกแแ แแ แ. แแแแแแแแแ, แกแแแก แแแชแแแแ - แแ . แงแแแแแแแ แแแแก แจแแแแแ, แกแแแแแขแแแ - แแก แแ แแก แแฅแแแแ แแแแ แแแก แจแแแแแแแแแแแแกแ แแ แแแแแแฃแแ แแแแแแก แแแแแแก แแแแแแ (แฃแแ แแแแแกแแแแ แแแแฎแแ แฎแ แแก แแฅ), แแกแแแ แฌแแแแกแฌแแ แแ/แแ แแแกแขแแ แแชแแกแแ แแแแก แแแแแงแแแแแแก (แ แแแแแแแแแ แแแแฎแแ แฎแ แแฅ, แแฃแแชแ แแก แแกแแแ แแงแ แแฃแแฅแขแแแจแ - แงแแแแแแ แฎแจแแ แแ แแงแแแแแแแแ แแแแแแแก แแ แกแกแกแก) .
แกแแแฃแจแแ แกแแแแแแ แ. แแแแแแแแแจแ แแแแฌแแ แแ, แ แแ JS-แแก แแแแแงแแแแแ แจแแฃแซแแแแแแแ. แแฅ แแแแแกแชแแแแก แแ แแแแแแแแแก แแแแแญแ แแก แฃแแแ แ - แกแแแแแแ แแก แแแแแแแแแ แจแแแซแแแแแแ แแขแแแแแก แแแแแงแแแแแแ แแ . แงแแแแ แแแแแ แฎแแแแ แกแแแแฅแขแแ แแก แแแแแแ #แฆแแแแแ-N:แจแแแแฌแแแแฃแแ ~ .slider-inner .slider-slides. แ แแแแกแแช แฉแแแ แแแฌแแแแฃแแแแ แแ แ-แแ แ แจแแงแแแแแก แแแแแ, แแก แแแแแแแก แจแแแแฌแแแแฃแ แแแแแแแ แแแแแจแ. แฉแแแ แจแแแแแซแแแ แแแกแแ แแแแแแ แแแแ แแ แแแแแแฃแแแแแ แฉแแแแแแแก แกแแญแแ แ แแแ แแแแแ แแแแขแแแแแ แก แกแแแแแแแแ: transform: translate(-33%). แแฅแแแ แจแแแแซแแแแ แแแฎแแ แกแแแแแแ แแก แแแแฎแแ แชแแแแแแ
แฉแแแแกแแจแแแแ แกแแแแ. แแฅแแช แฉแแแแแแแ แแก แงแแแแแคแแ แ แแ แแกแแแแกแ แแแแแ แฉแแแ: .แแแแ แแแแแ-แแฃแแฅแขแแก แจแแงแแแแ:แจแแแแฌแแแแฃแแ ~ .แแแแ แแแแแ-แกแแฅแแแแแ__แจแแแแแแกแ. แแฅแแแ แจแแแแซแแแแ แแแฎแแ แแแแฎแแ แชแแแแแแ
:hover, :active แแ :focu* แแแแแแแ แแแแแแแก แฎแแแแแกแแฌแแแแแแแ. แซแแแแแ แแแแจแแแแแแแแแ แฌแแ แขแแแ. แแแกแแ แแงแ แแแแแแแแแแฃแแ แแแแคแแ แขแ แแแขแแ แคแแแกแแแ แฃแ แแแแ แแแแแกแแก. แแแแฎแแแ แแแแแแ แงแแแแแแแแก แฃแแแ แแแแฆแแก แแแแแฎแแแฃแ แแแ แแแก แฅแแแแแแแแแ. แแก แแฃแแฅแขแ แจแแแแฌแแแ แแแแฎแแแ แแแ แฃแ แแแแ แแฅแแแแแแแก แแแแแแแแแแแจแ. แแฃ แแแแแญแแ แ แฆแแแแแก โแแแแแ แแแโ แแ แแแแฃแแแฃแ แแ แแ แแคแแ แ แแแแฎแแแ แ (แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแแฎแแแแ แแแแแแแแแ), แแก แชแฃแแแ, แ แแแแแ แแแ แ แแกแแ แแ แแกแแ แแแแแฌแแแแฃแแแ. แจแแแแแแ, แแแ แแแแฎแแแแ แแแแแแแแแแแ แแ แแแฏแแ แแแแแ แแแแแแ. แแ แฃแแแ แแแแแแแแฌแงแแแก, แ แแ แแแแแแฃแ แแแฌแงแแแแแแแแแก แแ แแฅแแ แแแฃแกแ, แ แแช แแแจแแแแก, แ แแ แแ แฃแแแ แแงแแก แแแฃแกแ. แแ แแแแแ แแ แแ แแฃแแฅแขแ, แ แแแแแแช แแ แจแแแฎแ แแแ, แแแแช แจแแแกแ แฃแแ แแฃแแฅแขแ แกแแแแแขแแแแก แจแแกแแฎแแ. แแฃ แแฅแแแแ แแแแขแ แแแ แแ แแ แแก แแแขแแ แแฅแขแแฃแแ แแแแแแแขแ, แแแจแแ แแแกแแ แแแแแกแแแแกแแก แแฃแ แกแแ แ แกแขแแแแแ แขแฃแแ แแแ แฉแแแ. แซแแแแแ แแแฃแฌแแกแ แแแแแแแ แฉแแแก, แแแจแแแแช แแ, แแฃ แแฅแแแ แแแฌแแ แแ แ แแแฅแชแแ hover-แแ. แแฃ แจแแแคแแกแแแ แแฃแ แกแแ แก: แแแฉแแแแแแแแ.
แแแแแแชแแแแ. แแแแจแแแแแแแแแแ, แ แแ แงแแแแ แ แแแฅแชแแ, แ แแแแแแช แฎแแแแ แแแแแแแขแแแแแ, แแแฃแแ แแงแแก. แชแฎแแแ แแแแจแ แแ แแคแแ แแ แแงแแกแแแ แ, แแแแขแแ แแแแแกแแแแแ แฐแแแแ แแ แแ แแฅแขแแฃแ แแ แกแแแแแ แแกแ แแงแ แแแแกแแแแแก, แ แแ แแแขแแ แคแแแกแ แฃแคแ แ แกแแกแแแแแแแ แงแแคแแแแงแ. แแแ แแแ, แแกแแแ, แแแแช แแแแแแชแแฃแ แ แกแแแแแแ แ แแ แกแแแแ, แแแแแแแ, แจแแกแแแแจแแแแแ.
แฃแแฎแแแกแ แขแแฅแแแแแแแแแแก แแแแแงแแแแแแ. แแแแ แแ แแแแแแงแแแ แคแแแฅแกแ, แแแแ แแ แแแ แแแแ แจแแแกแ แฃแแ แแแแแแแแ แแแแแก แแแแแงแแแแแแ. แฅแฃแแ แแแแแแแแแแแ, แแฃ แคแแแฅแกแ แกแฌแแ แแ แแฅแแ แแแแแงแแแแแฃแแ. แแฃ แกแแแแ แแแแแแแแแ แแแแจแแแ แกแฌแแ แแ แแ แแแฅแแแแแแแก แแแแ, แกแแแฌแฃแฎแแ แแ, แแฅแแแ แแ แแแแแฆแแแ แแแแแขแแแแแ แฅแฃแแแแ.
แคแแ แแแก แแแแแกแขแฃแ แแแ. แกแแญแแ แ แแงแ แแฎแแแแ แคแแ แแแก แแแแแแฃแ แจแแงแแแแแกแแแแก แกแแญแแ แ แแขแ แแแฃแขแแก แแแแแขแแแ. แฉแแแ แแแแแแแขแแ แฅแฃแแแแ แแแ, แแแแช แแแแแแกแขแฃแ แ แแแคแแกแขแแก แแแแ, แ แแแแ แช แแแคแแกแขแ.
แคแแแแแก แแขแแแ แแแแก แฆแแแแแแก แกแขแแแแแแชแแ. แฉแแแ แแแแแแแ, แ แแ แแแฎแแแแ แแกแแแ แแแแแแแแชแแ, แ แแแแ แแชแแ: แแ แแแ แฉแแแ แคแแแแ . แจแแแแแ แแแแแญแแ แแ แจแแงแแแแแก แแแแแแแ แแ แแขแแแแขแแก แกแขแแแ. แแ แกแแแแแก แแแแแ แแ แแ แแแแ แชแแแแแฃแแ แแแ - แแแแญแแแ แแแแ แจแแงแแแแแก แแแแแแแแ แแ แฆแแแแแแก แแแแแ แแแงแแแแแ. แแแแ แแ แงแแแแ แแ แแฃแแแ แ แแ แแซแแแแ แกแขแแแแก แกแแจแฃแแแแแแก , แแ แแกแแ แแแแแฌแงแแแขแแก แแ แจแแแซแแแแ แแฌแแแแก แกแ แฃแแแ แฏแแแ แแแแแ แแ แแฃแแแ แ. แแ แกแแแแแขแแแฃแ แแ แฃแคแ แ แกแฌแแ แแ แแขแแแแขแแก แแแแแแแแ.
แฏแแแ แแแแแ แแ แแฃแแแ แแก แแแแกแแแแแแแ. แฉแแแ แจแแแแแแฌแแแ, แ แแ แงแแแแแคแแ แ แแแ แแแ แแงแ แแแแแแแแ แแแ แแ แแฃแแแ แแแแก แแ แฃแแฎแแแก แแแ แกแแแจแ (IE-แก แแแ แแจแ - แแแแแฌแแแแแแก แแแฃแแแ แแแแ), แแกแแแ Safari-แจแ iPhone-แแแแ แแ Chrome-แจแ Android-แแแแ.
แแแ แแฅแแ, แฉแแแ แแแแแแแ แฅแฃแแแแก, แแฃ แแแแแ แแงแแแแแแ JS แแ Bootstrap: แแ แแแ แแแแแแแ แแแแแแ แชแฎแแแแ แแแแแ แแแแแแแแแก แแแแแแก. แฃแคแ แ แแแขแแช, Bootstrap-แแก แแฅแแแ แแแแแฌแแแแแแแ แแ แ แแฎแแแแ แแแแฆแแก แแแแฃแกแ, แแ แแแแ แแแแแ แแแก แแ แแแแแ แฅแฃแแ แกแแแแแขแแแแกแ แแ แแแแฎแแ แชแแแแแแฃแแ แแแแแแแขแแแแกแแแแก.
แแแ, แแแแช แกแแแฃแแแ แกแแแขแก แกแแแแ แแแขแแ แแแขแจแ แฃแแแกแแแแซแแ, แแ แแแแฆแแก แ แแแแ แแแแกแแแฃแแ แแแฃแแ แฃแแแ แแขแแกแแแ - แแแแ แแ แแแแแแฎแแแแแแแแ แซแแแแแ แแแแแแแ แแแ แแงแแแแ, แ แแแแกแแช แแแ แแ แแแฃแฌแแแ แกแแชแแแแแแก แฉแแแแขแแแ แแแ แแ แแแแแแแแ แแแแ แแแจแแแแ แแแแแแฃแขแแ แแ. แแกแ แ แแ, แแก แแงแ แแแ แแแก แแแฃแกแ.
แแแ แแแแ แแแแแแแแ แซแแแแแ แกแแกแแ แแแแแ แแงแ แแแ แแแ แ แแแจแ แแแกแฌแแแแแกแแแแก. แแแ, แแแแช แฉแแแ แแ แแแแแฆแแ, แแฎแแ แแฅแแ แแแแแแแแแฃแแ แ แแแแฃแแ - แจแแแแซแแแแ แแแแงแแ แแแฃแ แแแ แงแแแแ แแแกแฃแฎแก แแ แแแแแแแแกแแ แแแ แแฅแแแแก gh-แแแแ แแแแแ.
แแแแชแแแ 2: แกแแขแ แแแกแแแ แขแ แแแ แจแ แฃแขแ
แแแแแแแแแก แแแขแแ แแ แกแแซแแแแ แแแขแแ แคแแแกแแแแก แฏแแฃแคแแก แฎแแแแซแฆแแแแแแ แแแแแก แแแแแแ.
แแแแแแแ แแแแ
แแแ แกแแแแแแฃแ แ แ แฃแแ แแแฅแแก? แแแ แแฉแแแแแแก แแแแแแฃแแ แแแ แกแแแแแแแก แกแแฎแแแก, แแกแแแ แแแแซแแแก แแแกแแแ แกแฎแแ แแแ แกแแแแแแแแแแแ แกแแแแแแแก แฌแแแแแจแ. แแแแแฎแแ แชแแแแแ แแแแฎแกแแแก แคแฃแแฅแชแแ, แ แแแแแแช แฃแแแ แแแแฆแแก แกแแแ แแ แแฃแแแแขแ: แแแแแฅแขแ, แ แแแแแจแแช แแแกแแฆแแแแแ แแ แแก แแแ แกแแแแแแแแแก แกแแฎแแแแแ, แฎแแแ แแแแจแแแแแแแแแ แแ แแก แแแแซแแแ แแแ แกแแแแแแแแแแแ (แชแแแแฎแ แแแ แแแซแ แแแแ แกแแแ แชแแจแ), แแกแแแ แกแแฎแแแแแ. แแแแแแแก แกแแฌแงแแกแ แแ แแแกแแกแ แฃแแ แฌแแ แขแแแแแ - แแแฌแงแแแ แแ แแแกแ แฃแแแแ, แจแแกแแแแแแกแแ. แคแฃแแฅแชแแแ แฃแแแ แแแแแ แฃแแแก แฃแแแแแแกแ แแแแซแแแ แกแแฌแงแแกแ แแแ แกแแแแแแแแแ แคแแแแจแแก แแแ แกแแแแแแแแแ แแ แแแกแแกแแแแแ แแแ.
แคแฃแแฅแชแแแก แฎแแแแแฌแแ แ:
const solution = function(graph, start, finish) { // ะะฐัะต ัะตัะตะฝะธะต }
แจแแงแแแแแก แแแแแชแแแแแแก แแแแแแแแ:
const graph = { start: { A: 50, B: 20 }, A: { C: 40, D: 20 }, B: { A: 90, D: 90 }, C: { D: 160, finish: 50 }, D: { finish: 20 }, finish: {} }; const start = 'start'; const finish = 'finish';
แแแแแกแแแแแก แแแแแแแแ:
{ distance: 90, path: ['start', 'A', 'D', 'finish'] }
แจแแแแจแแแ: แฎแกแแแ แแก แฉแแแฉแฎแ แแ แแก src/ แกแแฅแแฆแแแแแจแ, แฉแแแแ แแแแแกแแแแแ solution.js-แจแ.
แแแแ แ แแแแแแแแแก แแแแแแแฌแแแแ แงแแแแแแ แแแขแแแแขแแแแ แแแฃแแ แแ แแแแแฅแขแฃแ แ แแงแ. แแแญแแแแก แฃแแแขแแกแแแแ แแแแแแชแแ, แ แแ แแฃแชแแแแแแแ แแงแ แแแแกแขแ แแก แแแแแ แแแแแก แแแแฎแแ แชแแแแแแ. แแกแแแ, แแแแช แแแแแแก แแแกแ แแฆแฌแแ แ แแ แแแแแ แแแก แแแแแ แแแแ JS-แจแ, แแแ แแแ แแแแแแแแก. แแฃแแชแ แแแแแแแแแก แจแแแแฌแแแแแกแแก แแ แแแแแ แ แจแแชแแแแแ แแแแ แแแจแ แแแก แฌแแแแฌแงแแแ. แแแขแแ แแแขแจแ แแแแแซแแแ แแแแแก แคแ แแแแแแขแแแ แแ แแแแแแแ แกแขแแขแแ, แกแแแแแแแช แแแแแฌแแแแแแแ แแแแแแแแ แแก แแแแแ แแแแ. แกแแกแแชแแแแ, แ แแ แแแแ แแ แแแแแแแแ แ แแแแ แกแขแแขแแแแแ แแแขแแ แแก แแแแแแขแแ แแแแแ แแ แแแ. แแกแแแแ แแแแฃแจแแแ แแแแ แแแแแแ แจแแคแแกแแแ แแแแฆแ. แฉแแแ แแ แแแ แซแแแแแ แ แแแแ แฌแงแแ แแก แแแแแงแแแแแแก, แแแแ แแ แแแแแแ, แแแแแแแแแ แฉแแฃแฆแ แแแแแแก แแแแก, แ แแกแแช แฌแแ แก.
แแ แแขแแ แแฃแแแแ
แซแแ แแแแแ แฅแฃแแแแ แแแแแแญแ แขแแกแขแแแก. แแแแฏแแ แชแฎแแแ แแงแ, แ แแ แแแญแแแ แแ แแฃแแแแแแแ แกแแชแแแจแ, แกแแฅแแฆแแแแแแแแก แแแแแ แฅแแแแแก แแ แขแแกแขแแแ แฉแแแแ แแแแแแ แแฎแแแแ แแแแขแแ, แ แแ แแกแแแ แแแ แแแแแแแก แกแแญแแ แ แคแแแแแแก. แฌแแแก แฉแแแ แจแแแแชแแแแ แแแแแฎแแแ แแ แแกแแ แแแญแแแก แแ แงแแแแแคแแ แ แแแแแก แแแแแแแ แแแแแแ แฃแแแ. แแแแ แแ แแแแแแแ แฌแแแก แแแแแแแแ แกแแแแแแฃแ แกแ แกแแกแขแแแแแ แแแแแกแแแแก แแ แแก แแฆแแ แแแแแแขแแแแก.
แแกแแแ แแงแ โแแแแแแแแฃแ แโ, แฎแแแแ แแ แแขแแ แแฃแแแแ. แแแแแแแแแ, แแ แแ แแแแแก แกแขแแแแก แแ แกแแแแแ. แแ แแแแก แแแฃแแแแแแ แฅแฃแแแแ แแแขแแ แแแแแก แแแชแแแแ แฉแแแแ แแแแแก แแแแแงแแแแแแกแแแแก แแ แแแ แแฅแแ. แกแฎแแ แกแแฅแแแ, แแฃ แแฅแแแ แจแแชแแแแ แแ แ แแ แญแงแแแแแก แแ แแแแ แแ แญแงแแแแแแ, แแฅแแแแแแแก แชแแแแแแ แฌแแกแแก แแแฎแแแแแ แแ แแแแแแ แแซแแแแ แจแแแแฎแแแแแ.
แชแแแแ แแงแ แแแแแแแแกแฌแแแแแฃแแ แฎแกแแแ แแก แกแแชแฎแแแ แแ แฌแแแแแฎแแ. แแกแแคแแแแก แงแแแแ แแแแคแแ แแแชแแแแ แแแแแแแ, แ แแ แแ แแแ แแแแกแขแแก แกแแแฃแจแแแก 80% แกแฎแแ แแแแแแแแแแแก แแแแแก แฌแแแแแฎแแแจแแ. แกแแแแแก แแแกแฌแแแแแแแแช แแ แแแแแแ แแแแแฅแกแแก แแแแแฎแแแแแก - แแแแ แแฃแ แแขแแ แแแแกแแแ แแ แแ แแแแแแแแกแแแ. แแกแ แ แแ, แแ แแ แแขแแ แแฃแแก แแแแจแแแแแแแแแ แฌแแแ แฐแฅแแแแ. แแงแ แแแแฃแจแแแ แแแ, แ แแแแแแจแแช แแ แแงแ แแ แ แกแแแแแแแแ แแแขแ แชแแแแแ - แแแฎแแแ, แแ แแแแแแแแ แแก. แแแแแฌแแแแแ แแแแแแขแแ แแแ แซแแแแแ แแแแแแฎแแแแแแแแ แแงแ - แแแ แแ แแ แจแแแแฎแแแแแแแกแ, แ แแแแแแแช แกแขแแแ แฉแแแแแก แแแแแแขแแ แแแแก แแแแแขแฃแ แ แแงแ.
แแแแ แแ แแขแแ แแฃแแ แแ แแก แแแขแแขแแกแขแแแแก แแ แกแแแแแ. แแฎแแแแ แ แแแแแแแแ แแแแแแแแแ แแแแแแขแ แแกแแแ, แแแแ แแ แงแแแแแกแแแแก แแก แแแฎแแ แฃแแแ แแแแแ แ แแแฃแกแ แแแ แแแ แแแจแ.
แกแฌแแ แ แแแแแฌแงแแแขแแแแแ:
const solution = function(graph, START, FINISH) {
// ะัั ะฝะต ะฑะตัะฟะปะฐัะฝะพ ะฒ ััะพะผ ะผะธัะต
const costs = Object.assign({[FINISH]: Infinity}, graph[START]);
// ะะตัะฒะฐั ะฒะพะปะฝะฐ ัะพะดะธัะตะปััะบะธั
ะฝะพะด
const parents = { [FINISH]: null };
Object.keys(graph[START]).reduce((acc, child) => (acc[child] = START) && acc, parents)
const visited = [];
let node;
// ะัะตะผ ยซะดะตััะฒะพะณะพยป ัะพะดะธัะตะปั, ะพัะผะตัะฐะตะผ ะฟัะพะนะดะตะฝะฝัะต
do {
node = lowestCostNode(costs, visited);
let children = graph[node];
for (let n in children) {
let newCost = costs[node] + children[n];
// ะัั ะฝะต ะพัะตะฝะตะฝะฐ ะธะปะธ ะฝะฐััะปัั ะฑะพะปะตะต ะดะตััะฒัะน ะฟะตัะตั
ะพะด
if (!costs[n] || costs[n] > newCost) {
costs[n] = newCost;
parents[n] = node;
}
}
visited.push(node);
} while (node)
return {
distance: costs[FINISH],
path: optimalPath(parents)
};
// ะะพะทะฒัะฐั ะฝะฐะทะฐะด ะฟะพ ัะฐะผัะผ ยซะดะตััะฒัะผยป ัะพะดะธัะตะปัะผ
function optimalPath(parents) {
let optimalPath = [FINISH];
let parent = parents[FINISH];
while (parent && parent !== START) {
optimalPath.push(parent);
parent = parents[parent];
}
optimalPath.push(START);
return optimalPath.reverse();
}
// ะะธะฝะธะผะฐะปัะฝะฐั ััะพะธะผะพััั ะธะท ัะตะบััะตะน ะฝะพะดั ััะตะดะธ ะฝะตะฟัะพัะผะพััะตะฝะฝัั
function lowestCostNode(costs, visited) {
return Object.keys(costs).reduce((lowest, node) => {
if (lowest === null || costs[node] < costs[lowest]) {
if (!visited.includes(node)) {
lowest = node;
}
}
return lowest;
}, null);
};
};
แแแแชแแแ 3: แฆแแแแกแซแแแแแแแก แแแแแแแแ แ
แแแ แแแแแแแแแก แแแขแแ แคแแแกแแก แแแแแแแแแ แแแแ แกแแ แแแ แแแแแแแแแ แแ แแแแฅแกแแแแ แ แแแแแ แแแแแแแ.
แแแแแแแ แแแแ
แแแฌแแ แแ แแแแ แแแแแแแแ แ แแฅแแแแ แแแแ แแแแก แกแแฉแแแแแแแแ. แแฅแแแ แจแแแแซแแแแ แแแแฆแแ แแแแแกแแแแ แ แแ แแคแแแ, แ แแแแแแช แแแแฌแแแ. แแแแแแแแแ, แคแ แแแขแแแแแก แแแแคแแ แแแชแแแแแก แแแแ แแแ 2019 แฌแแแก.
แแแแแแแแ แ แฃแแแ แแแแแแงแฃแ แแแแแแก แกแแแก. แแแแแแแแก แกแฎแแ แแแแฎแแแแแแ แแ แแ แกแแแแแก. แแแฎแแแแ แจแแกแแซแแแแแแ แแแแแแแแก แจแแฎแกแแแแแแแแก แแแงแแแแแ 3, 7 แแ 14 แแฆแแ แแแ แ. แแแขแแ แแแขแแแแ แแแ แแแแ แฉแแแแขแแแ แแแแก แจแแแแแ, แแแแแแแแ แ แฃแแแ แแแแฎแกแแแก แแ แแคแแแแ แคแฃแแฅแชแแแแแ แแแก.
แกแแกแแ แแแแแ แ แแกแฃแ แกแแแ
Frontend แแแแคแแ แแแชแแแก แแแแ แแแ:
confs.tech/javascript?topics=javascript%2Bcss%2Bux แแแแกแแฎแฃแ แ แแฃแจแแแ:
developer.mozilla.org/ru/docs/Web/API/Service_Worker_API/Using_Service_Workers
developers.google.com/web/fundamentals/primers/service-workers แจแแขแงแแแแแแแแแแก API:
developer.mozilla.org/ru/docs/Web/API/Notifications_API
แแแกแแแ แแแแแแแแ แงแแแแแแ แกแแแแขแแ แแกแ แแงแ แจแแกแแแแฌแแแแแแ, แ แแแแแ แแแแ แ แจแแกแแซแแ แแแแแกแแแแแ แแงแ, แแแแแแฃแแก แแแแแกแ. แฉแแแ แแแแแแแแแฌแแแ, แ แแแแ แฃแแแแแแแแแ แแแแแแแแขแ แฃแชแแแ แขแแฅแแแแแแแแแก - แแชแแก แแฃ แแ แ แแแแแแ, แแแแฌแแแแก แแฃ แแ แ แแแแแก แแแแแฌแงแแแขแแแแแแแก.
แแ แแขแแ แแฃแแแแ
แแแแแชแแแ แแแแแแแแ แ. แแแแฎ, แฏแแ แแแแแ แกแญแแ แแแแแแ แแแแแแแแ. แแงแแแแ แแกแแแแแแช, แแแแช แแแ แแแแก แซแแแแแ แกแแขแงแแแกแแขแงแแแ แแฆแแฅแแแแแแแ แแ CSS แแแแแก แแ แช แแ แแ แฎแแแ แแ แฉแแกแแแก. แซแแแแแ แแแแแแแแแแแ แแ แแแแแแงแฃแ แแแแแ, แแแแ แแ แแฃ แงแแแแแคแแ แ แแฃแจแแแแแ, แฅแฃแแแแ แแ แแแแแแก.
แแแแแแแแแแก แกแแแก แแแฆแแแ แฌแงแแ แแแแ. แแก แแ แแ แแก แแแแแแแแแแก แแแแชแแแ, แแแแขแแ แแแกแจแ แจแแแแแแแ แแแแแแแแแแก แกแแ แแ แแงแ แแแแแแแแ. แงแแแแแแแแก แจแแแแซแแแแ แแแแฃแฅแแแ แแแแคแแ แแแชแแ, แแแแแแฎแแแ แแก แแ แแแแแแขแแ แแฎแแแ. แแแแขแแ แกแแญแแ แ แแงแ แแแ แแแแ แแแแแชแแแแแแก แแแฆแแแ แแ แแแฆแแแฃแแ JSON-แแก แกแแคแฃแซแแแแแ แแแแแแแแแแก แแแคแแ แแแแ. แแแแจแแแแแแแแแ แแงแ แแแแแชแแแแแแก แแแฆแแแ แแแแแกแแแแ แ แแแแ (Fetch แแแแแแแก แแแแแงแแแแแแ แแ XMLHttpRequest-แแก แแแแแงแแแแแแ). แแฃ แแแแแแแแแ แแแแแแขแ แแแแแคแแแ Fetch-แแกแแแแก แแ แแแแแจแแ แแแกแ แแ แฉแแแแแ readme-แจแ, แแก แฉแแแแแแแแแแ แแแฃแกแแ.
แกแแ แแแกแแก แแแแแแจแ แแแแแก แ แแแแกแขแ แแชแแ แจแแชแแแแแแแก แแแ แแจแ แแ แแแฃแจแแแแ แแคแแแแแจแ แแแ แแแแ แฉแแแแขแแแ แแแแก แจแแแแแ.
แจแแฎแกแแแแแแก แแแงแแแแแแก แจแแกแแซแแแแแแแแแกแ, แ แแ แแก แ แแแแฃแ แแ แแฃแจแแแแก 3, 7, 14 แแฆแแก แจแแแแแ. แกแแญแแ แ แแงแ แจแแขแงแแแแแแแแแแก API-แก แแแแแแ,
แแแกแแขแแแแ แฎแแขแแก แแแแแแแกแแแแก แจแแกแแซแแแแแแแ (PWA). แฉแแแ แจแแแแแแฌแแแ แคแแแแแก แแ แกแแแแแ
Codestyle แแ แแ แแแฅแขแแก แกแขแ แฃแฅแขแฃแ แ. แ แแแแ แช แแแแ แ แแแแชแแแแจแ, แฉแแแ แจแแแฎแแแแ แแ แแ แแแแแก แกแขแแแก (แแฃแแแแช แแก แแ แแแแฎแแแแแแก แฉแแแแกแแก). แแแแแแ แแ แแแญแ แฎแ แแฎแแแแแ แแแขแ แ - แแก แจแแกแแแแจแแแแแ.
แแแแกแแแแก แจแแชแแแแแแ. แแฃ แแแแกแแแจแ แแงแ แแแแแแแขแแ แ, แ แแ แ แแฆแแช แแ แแกแฌแแ แ แแงแ แแ แแแแแฌแแแแ แแแแก แงแฃแ แแแฆแแแ แแ แแแแฅแชแแ, แแแจแแ แฉแแแ แแแแแแแ แฅแฃแแแแก.
แจแแแแแแแ
แ แ แแ แแก แกแแกแแชแแแ แแแแแฌแแแแแ แแแแแฌแงแแแขแแแแแแแจแ:
- แแ แแ แแแแฎแแแ แ แจแแแชแแแแ แจแแแแแ แขแแฅแกแขแก: โแแ แแแ แแแแก แแแแแแแ แ แแแแแฎแแแ แ React แแแแแแแชแแแก แจแแแแแแแจแ. แแแแแแแแ แแแก แแแแฎแแแแแ แ แแแแ แแ แ แแขแแ แแ แแแแฎแ แ. แซแแแแแ แแแแแฌแแแ, แแกแฃแ แก แแแขแ แแแชแแแ แแแก แจแแกแแฎแแ. โ แแ แแแแแแแชแแแก แแแแแ แแฃแแแ แแแแ แแขแแกแขแแแแแ, แแแแ แแ แกแแแฌแฃแฎแแ แแ, แแแแแแแแขแแก แแแแแแแ แ แแแแแ แแ แแแแแแฎแแแ แ แแแแแชแฎแแแแก แแแแฅแแแแแแแจแ.
- แแ แแแ แแแแแแแแขแแ แแแฃแแแแแแ แแแฃแแ GitHub-แก, แกแแแแช RAR แแ แฅแแแ แแงแ แแแแแแแกแแแฃแแ - แแแแแ แแแแแแขแแ แแก แแแแแแแแ แ แแฃแแแ. ๐
- แกแฎแแ แแแแแแแแขแแ, solution.js แคแแแแแก แแแ แแแ แกแขแ แแฅแแแแ แแแแแแขแแ แจแ, แแฃแแฌแ แคแแแแ แแฆแแแ แ, แ แแ แแแ แแแแแแแแ แ แแแแแ แแแแ.
แฉแแแ แแแแแฆแแ แแแแแชแฎแแแ 76 แแแแแแแแขแแกแแแ แแ แจแแแแ แฉแแแ 23 แแแแแแแแ. แแแแแแแแแแแแแแก แแแแฎแแแ แแแ แแ แ แแฎแแแแ แแแแกแแแแแ, แแ แแแแ แแแกแแแแแแแ, แแแขแแ แแฃแ แแแแแ แแ แแแแแ แกแขแแแแแแแแช แแ. แแแแแแ แแแ แแแญแแ แแฆแแแแแแแแ แแ แแคแแกแแแ แแแแแแแชแ: แแ แแ แกแแกแแแแ แแแ แแฅแกแแแ แขแแ, แแแแ แ แแ แกแแแแแแชแแแ แกแขแฃแแแแขแ.
แจแแแแแ แแงแ แแแแแแแแแแแก แจแแกแ แฃแแแแแกแแก แฌแแ แแแขแแแแก แแแฉแแแแแแแแแแก แกแแแแขแแ แแกแ แแแแแฌแแแแแ. แแแแแฌแแแแแแแ แแแ แแแแ แแแแแแแแ แจแแแกแ แฃแแแก แกแแจแฃแแแแ 60%-แแ, แแแแ แแก 50%-แแ, แฎแแแ แแแกแแแ แงแแแแแแ แ แแฃแแ แแฆแแแฉแแแ แแ แกแแจแฃแแแแ 40%-แแ แจแแแกแ แฃแแแก.
แแ แแ แจแแฎแแแแแ, แแแแชแแแแแ แแแแแแงแฃแ แแแ แ แแฃแแ แแ แจแ แแแแขแแแแแ. แแแแแแ แแ แแ แแก แแก, แ แแ แฉแแแ แแแแแแ แ แแช แจแแแซแแแแ แแแขแ แแแแแแแแขแแก แแแแแแแแแ. แกแฌแแแแแก แแ แแก แกแขแฃแแแแขแแแก แ แแแแฃแ แ แแแแชแแแแแแก แฌแแแแจแ แแแแแแ - แฉแแขแแก แแแแแแแแ, Yandex.Music แแแแจแแแแแกแแแแก แแ Yandex.Weather แแแแแแแ แแแแแแแแแแฃแแ แแแแแแแแแแแกแแแแก. แแแแกแแแแแก แกแแญแแ แแ แกแแฌแงแแกแ แแแแ.
แแแฎแกแแแก, แแ แ แฌแแแก แฌแแ แแแแฎแ แฉแแแ SRI-แแก แจแแกแแกแแแแแ แแแแแแแแ แแ แแคแแฅแ แแแแ, แ แแ แแแก แแแ แแกแแแแก แแแแแแแแ แแแแ. แแ แแแแแแขแจแ แแแแแแ แแ แแแฏแแ, แงแฃแ แแแฆแแแแ แฌแแแแแแฎแ แแแ แแแแแ แแ แแแแฌแงแ แแแแก แแแแแแแแ. แแแแแแแก, แ แแ แแแ แแแแแ แจแแแชแแแก แฎแกแแแ แแก แแแแฅแแแก 80%-แก. แแแแแแแแแ, แแแกแแแ แแแแแแแแแก (แงแแแแแแ แ แแฃแแ) แแแ แแแแแจแ แแแแแแแขแแ แกแแ แแแกแแก แแฃแจแแแแแแก แแแฃแแแแ แแ แจแแขแงแแแแแแแแแแก API MDN-แแ. แแแกแฌแแแแแแแแ, แ แแแแแแแช แกแฌแแแแแแแแแ แแแฃแแแแแก แจแแแแแ แกแก, แฃแแ แแแแแแแ แแแแกแ แฃแแแก แแแ.
แซแแแแแ แแแแแ, แ แแ แแก แกแขแแขแแ แฌแแแแแแฎแแ แแแแแแแแขแแแแ, แ แแแแแแแช แแแแแแแแ แกแแแแแแแแแ SRI-แจแ แจแแกแแแแก, แ แแแแแแแแช แแแ แจแแซแแแก แแแแกแแแก แกแแแแแจแ แจแแกแแแ, แแ แ แแแแแแแช แแฌแงแแแแ แ แแแแ แกแฎแแ แกแแขแแกแขแ แแแแแแแแแก แจแแกแ แฃแแแแแก. แ แแแแ แช แฎแแแแแ, แแแแก แแแแแแแแ แกแแแกแแแแ แจแแกแแซแแแแแแแ. แแฅแแแ แฃแแ แแแแ แฃแแแ แแฏแแ แแแแ แกแแแฃแแแ แ แแแแแก แแ แแแฃแกแแแแแ แงแแแแ แ แฉแแแแก แแแขแแ แแแแกแแแ.
แฌแงแแ แ: www.habr.com