Merge pull request BonsaiDen#301 from it-na-move/master

translation into Belorussian

Author: timruffles

doc/by/array/constructor.md

@@ -0,0 +1,31 @@
+## Канструктар `Array`
+
+Праз тое, што канструктар `Array` неадназначна апрацоўвае свае параметры,
+крайне рэкамендуецца выкарыстоўваць літэрал - `[]` - для стварэння масіваў.
+
+    [1, 2, 3]; // Вынік: [1, 2, 3]
+    new Array(1, 2, 3); // Вынік: [1, 2, 3]
+
+    [3]; // Вынік: [3]
+    new Array(3); // Вынік: []
+    new Array('3') // Вынік: ['3']
+
+У выпадку, калі канструктару `Array` перадаецца толькі адзін параметр, і калі гэты
+аргумент тыпу `Number`, канструктар верне *разрэджаны* масіў, які мае уласціваць
+`length` са значэннем аргумента. Варта адзначыць, што такім чынам будзе зменена
+**толькі** значэнне ўласцівасці `length` масіва; індэксы масіва не будуць
+праініцыялізаваныя.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, індэкс не праініцыялізаваны
+
+Магчымасць загадзя вызначыць даўжыню масіва карысна толькі ў рэдкіх выпадках,
+напрыклад, паўтор радка без выкарыстання цыкла.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### У заключэнне
+
+Літэралы маюць перавагі над канструктарам Array. Яны карацейшыя, маюць больш чысты
+сінтаксіс і робяць код больш чытэльным.

doc/by/array/general.md

@@ -0,0 +1,56 @@
+## Ітэрацыі па масівам і ўласцівасці
+
+Хоць масівы ў JavaScript — аб'екты, няма добрых падставаў для таго, каб
+выкарыстоўваць [цыкл `for in`](#object.forinloop) для ітэрацыі па масівах.
+Фактычна, ёсць шэраг добрых падстаў **супраць** гэтага.
+
+> **Заўвага:** масівы JavaScript **не** *асацыятыўныя масівы*. JavaScript мае
+> [аб'екты](#object.general) для структуры ключ-значэнне. Але калі асацыятыўныя
+> масівы **захоўваюць** парадак, аб'екты — **не**.
+
+З той прычыны, што цыкл `for in` пералічвае ўсе ўласцівасці, якія ёсць у ланцужку прататыпаў,
+і таму, што адзіны спосаб выключыць гэтыя значэнні — [`hasOwnProperty`](#object.hasownproperty),
+ітэрацыя атрымліваецца ў **20 разоў** марудней за звычайны цыкл `for`.
+
+### Ітэрацыя
+
+Для таго, каб атрымаць найлепшую прадукцыйнасць у ітэрацыі па масіву, лепш
+выкарыстаць класічны цыкл `for`.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+У вышэйпрыведзеным прыкладзе ёсць яшчэ адзін прыём, з дапамогай якога можна кэшаваць
+памер масіва: `l = list.length`.
+
+Негледзячы на тое, што ўласцівасць `length` вызначана ў самім масіве, пошук
+гэтай уласцівасці накладвае выдаткі на пошук пры кожнай ітэрацыі цыкла. І хоць
+новыя рухавікі JavaScript **могуць** прымяніць аптымізацыю у гэтым выпадку, няма
+магчымасці дакладна ведаць, ці будзе код выкананы на гэтых новых рухавіках.
+
+Фактычна, адсутнасць кэшавання можа зрабіць выкананне цыкла **ў два разы больш
+марудным**, чым з кэшаваным 'length'.
+
+### Уласцівасць `length`
+
+Хоць *гэтэр* уласцівасці `length` проста вяртае колькасць элементаў, што
+знаходзяцца у масіве, *сэтэр* можа быць выкарыстаны для **абразання** масіва.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Прысвойванне ўласцівасці 'length' меншага значэння абразае масіў. Прысваенне большага
+значэнне створыць разрэджаны масіў.
+
+### У заключэнне
+
+Для лепшай прадукцыйнасці рэкамендуецца заўсёды выкарыстоўваць звычайны цыкл `for`,
+і кэшаваць уласціваць `length`. Выкарыстоўванне `for in` для ітэрацыі па масіву —
+прыкмета дрэнна напісанага коду, схільнага да памылак і дрэннай прадукцыйнасці.

doc/by/core/delete.md

@@ -0,0 +1,81 @@
+## Аператар `delete`
+
+У JavaScript *немагчыма* выдаліць глабальныя пераменныя, функцыі і некаторыя іншыя
+рэчы, што маюць атрыбут `DontDelete`.
+
+### Глабальны код і код функцый.
+
+Калі пераменная або функцыя аб'яўленыя ў глабальнай зоне бачнасці, або [зоне бачнасці
+функцыі](#function.scopes) то яна будзе ўласцівасцю або аб'екта актывацыі, або
+глабальнай зоны бачнасці. Такія ўласцівасці маюць набор атрыбутаў, адзін з іх —
+`DontDelete`. Пераменныя і функцыі, аб'яўленыя ў глабальнай зоне бачнасці і зоне
+бачнасці функцыі, заўсёды ствараюцца з уласцівасцю `DontDelete`, а таму не могуць
+быць выдаленыя.
+
+    // глабальная пераменная:
+    var a = 1; // мае ўласцівасць DontDelete
+    delete a; // false
+    a; // 1
+
+    // звычайная функцыя:
+    function f() {} // мае ўласціваць DontDelete
+    delete f; // false
+    typeof f; // "function"
+
+    // перапрызначэнне не дапамагае:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Яўна прызначаныя ўласцівасці
+
+Яўна прызначаныя ўласцівасці могуць быць лёгка выдаленыя.
+
+    // яўна прызначаныя ўласцівасці:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+У вышэйпрыведзеным прыкладзе, `obj.x` і `obj.y` могуць быць выдаленыя, бо не маюць
+атрыбута `DontDelete`. Таму і прыкад ніжэй працуе:
+
+    // Гэта працуе правільна, акрамя IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true — глабальная пераменная
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Гэта прыём, каб выдаліць `a`. [`this`](#function.this) спасылаецца на глабальны
+аб'ект, і мы яўна аб'яўляем пераменную `a` як яго ўласцівасць, што дазваляе нам
+выдаліць яе.
+
+IE (прынамсі 6-8) мае хібы, таму вышэйпрыведзены код там працаваць не будзе.
+
+### Аргументы функцый і ўбудаваныя ўласцівасці
+
+Звычайныя аргументы функцыі, [аб'ект `arguments`](#function.arguments), а таксама
+убудаваныя ўласцівасці таксама маюць атрыбут `DontDelete`.
+
+    // аргументы функцыі і ўласцівасці:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### У заключэнне
+
+Аператар `delete` часта паводзіць сябе нечакана, таму адзінае надзейнае выкарыстанне
+`delete` — выдаленне яўна прызначаных уласцівасцяў.

doc/by/core/eval.md

@@ -0,0 +1,47 @@
+## Чаму не варта выкарыстоўваць `eval`
+
+Функцыя `eval` выконвае радок JavaScript коду ў лакальнай зоне бачнасці.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+Тым не менш, `eval` выконваецца ў лакальнай прасторы імён толькі ў тым выпадку, калі
+яна была выклікана наўпрост *і* імя выкліканай функцыі — `eval`.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+Лепш пазбягаць выкарыстоўвання `eval`. 99,9% яе «выкарыстанняў» можа быць дасягнута
+**без** яе.
+
+### Схаваны `eval`
+
+Абедзве [функцыі тайм-аўты](#other.timeouts) `setTimeout` і `setInterval` могуць
+прымаць радок у якасці першага аргумента. Гэты радок будзе **заўсёды** выконвацца
+ў глабальнай прасторы імёнаў, бо `eval` не выклікаецца наўпрост у дадзеным выпадку.
+
+### Праблемы з бяспекаю
+
+Таксама `eval` мае праблемы з бяспекаю, бо ён выконвае **любы** перададзены код.
+Таму яе **ніколі** не варта выкарыстоўваць з радкамі, што паходзяць з ненадзейных
+крыніцаў.
+
+### Заключэнне
+
+Лепш ніколі не выкарыстоўваць `eval`. Любы код, што выкарыстоўвае яе, спрэчны ў
+плане якасці, карэктнасці, прадукцыйнасці і бяспекі. Калі для таго, каб нешта
+працавала, патрэбны `eval`, **не** трэба прымаць гэта рашэнне ў першую чаргу.
+*Лепшым рашэннем* будзе тое, што не будзе выкарыстоўваць `eval`.

doc/by/core/semicolon.md

@@ -0,0 +1,109 @@
+## Аўтаматычная ўстаўка кропкі з коскай
+
+Хаця JavaScript мае C-падобны сінтакс, ён **не** прымушае выкарыстоўваць кропку
+з коскай у кодзе, таму ёсць магчымасць прапускаць іх.
+
+Але JavaScript — не мова без кропак з коскай. Насамрэч яны патрэбны ёй, каб разумець
+зыходны код. Таму парсер JavaScript **аўтаматычна** ўстаўляе іх паўсюль, дзе
+сустракае памылку адсутнасці кропкі з коскай.
+
+    var foo = function() {
+    } // памылка разбора, парсер чакаў кропку з коскай
+    test()
+
+Адбываецца ўстаўка, парсер спрабуе зноў.
+
+    var foo = function() {
+    }; // памылкі няма, парсер працягвае
+    test()
+
+Аўтаматычная ўстаўка кропкі з коскай лічыцца адной з **найвялікшых** архітэктурных
+памылак у мове, бо *можа* змяніць паводзіны кода.
+
+### Як яно працуе
+
+Ніжэйпрыведзены код не мае кропак з коскай, таму парсер вырашае дзе іх уставіць.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Ніжэй — вынік гульні парсера ў адгадванне.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Не ўстаўлена, радкі былі аб'яднаныя
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- устаўлена
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- устаўлена
+
+            return; // <- устаўлена, разбіў аператар return на два блока
+            { // парсер лічыць гэты блок асобным
+                foo: function() {}
+            }; // <- устаўлена
+        }
+        window.test = test; // <- устаўлена
+
+    // Радкі зноў аб'ядналіся
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- устаўлена
+
+    })(window); //<- устаўлена
+
+> **Заўвага:** Парсер JavaScript не апрацоўвае "карэктна" аператар return, калі
+> пасля яго пачынаецца новы радок. Магчыма прычына і не ў аўтаматычнай устаўцы
+> кропак з коскай, але гэта, тым не менш, непажаданы эфект.
+
+Парсер кардынальна памяняў паводзіны кода. У пэўных выпадках ён прымае **памылковыя
+рашэнні**.
+
+### Вядучыя дужкі
+
+У выпадку вядучай дужкі парсер **не** уставіць кропку з коскай.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Гэты код ператворыцца ў радок.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+**Вельмі** верагодна, што `log` **не** вяртае функцыю; Таму вышэйпрыведзены
+код справакуе `TypeError` з заявай, што `undefined` не з'яўляецца функцыяй.
+
+### Заключэнне
+
+Крайне рэкамендуецца **ніколі** не прапускаць кропку з коскай. Таксама заўсёды
+рэкамендуецца ставіць дужкі на той жа лініі, што і адпаведныя канструкцыі, і ніколі
+не прапускаць іх у аднарадковых канструкцыях `if` / `else`. Гэтыя меры не толькі
+павысяць кансістэнтнасць кода, але таксама прадухіляць ад таго, што парсер
+JavaScript зменіць паводзіны кода.