Змінні JavaScript оголошують зовнішній або внутрішній цикл?

В AS3 я вважаю, що ви повинні ініціалізувати всі змінні зовнішні цикли для підвищення продуктивності. Це так і з JavaScript? Що краще / швидше / найкраща практика?

var value = 0;

for (var i = 0; i < 100; i++)
{
    value = somearray[i];
}

або

for (var i = 0 ; i < 100; i++)
{
    var value = somearray[i];
}

Немає різниці в значенні та продуктивності в JavaScript або ActionScript.

var- це директива для аналізатора, а не команда, що виконується під час виконання. Якщо певний ідентифікатор був оголошений varраз або більше в будь-якому місці функціонального тіла (*), то все використання цього ідентифікатора в блоці буде посилатися на локальну змінну. Не має значення, чи valueоголошено йогоvar всередині циклу, поза циклом, або обидва.

Отже, ви повинні написати те, що вам найбільше читається. Я не погоджуюсь з Крокфордом, що ставити всі вищі вершини функції - це завжди найкраще. У випадку, коли змінна використовується тимчасово в розділі коду, краще оголосити varв цьому розділі, тому розділ стоїть окремо і його можна скопіювати. В іншому випадку скопіюйте декілька рядків коду в нову функцію під час рефакторингу, не вибираючи окремо та переміщуючи пов’язане var, і ви отримали випадковий глобальний результат.

Зокрема:

for (var i; i<100; i++)
    do something;

for (var i; i<100; i++)
    do something else;

Крокфорд порекомендує вам видалити друге var(або видалити обидва vars і зробити var i;вище), і jslint буде збиватися з вас для цього. Але в IMO важче зберегти обидва vars, зберігаючи весь пов'язаний код разом, замість того, щоб мати додатковий, легко забутий біт коду у верхній частині функції.

Особисто я схильний заявляти як varперше призначення змінної у незалежному розділі коду, чи є інше окреме використання того ж імені змінної в якійсь іншій частині тієї ж функції. Для мене varвзагалі декларувати - це небажана бородавка JS (краще було б мати змінні за замовчуванням для локальних); Я не вважаю своїм обов'язком дублювати обмеження [старої редакції] ANSI C також у JavaScript.

(*: крім вкладених функціональних органів)

Теоретично це не повинно змінювати JavaScript, оскільки мова не має блочного кола, а лише область застосування.

Я не впевнений у аргументі продуктивності, але Дуглас Крокфорд все-таки рекомендує, щоб varвисловлювання були першими твердженнями в функціональному органі. Цитування з конвенцій коду для мови програмування JavaScript :

У JavaScript немає області блоку, тому визначення змінних у блоках може переплутати програмістів, які мають досвід роботи з іншими мовами сімейства C. Визначте всі змінні у верхній частині функції.

Я думаю, що у нього є пункт, як ви бачите в наступному прикладі. Оголошення змінних у верхній частині функції не повинно заплутати читачів у думці, що змінна i міститься в області forблоку циклу:

function myFunction() {
  var i;    // the scope of the variables is very clear

  for (i = 0; i < 10; i++) {
    // ...
  }
}

ECMA-/JavascriptМова hoistsбудь-якої змінної , яка оголошена в будь-якому місці у верхній частині функції. Це відбувається тому , що ця мова дійсно є function scopeі не НЕ мають , block scopeяк і багато інших C-подібних мов.
Це також відоме як lexical scope.

Якщо ви заявляєте щось подібне

var foo = function(){
    for(var i = 0; i < 10; i++){
    }
};

Це дістається hoistedдо:

var foo = function(){
    var i;
    for(i = 0; i < 10; i++){
    }
}

Тож це не має ніякої різниці у продуктивності (Але виправте мене, якщо я тут абсолютно помиляюся).
Набагато краще аргумент НЕ оголошувати змінну де - небудь ще , ніж у верхній частині функції читаність . Оголошення змінної всередині for-loopможе призвести до помилкового припущення, що доступ до цієї змінної можна отримати лише в тілі циклу, що абсолютно неправильно . Infact ви можете отримати доступ до цієї змінної в будь-якому місці в межах поточного діапазону.

У наступному році всі браузери матимуть двигуни JS, які попередньо компілюють код, тому різниця в продуктивності (яка виникає від розбору того ж блоку коду знову і знову плюс виконання завдання) повинна стати незначною.

Крім того, ніколи не оптимізуйте продуктивність, якщо вам цього не доведеться. Утримуючи змінні поблизу місця, де вони вам потрібні, перший раз зберігає ваш код чистим. З негативної сторони люди, які звикли до мов із областями блоку, можуть заплутатися.

Інше враження, що тепер у нас letі constв ES2015, полягає в тому, що тепер ви можете застосовувати змінні спеціально до блоку циклу. Тому, якщо вам не знадобиться однакова змінна поза циклом (або якщо кожна ітерація залежить від операції, виконаної з цією змінною в попередній ітерації), мабуть, бажано це зробити:

for (let i = 0; i < 100; i++) {
    let value = somearray[i];
    //do something with `value`
}

Я щойно робив простий тест у Chrome. Спробуйте загадку у вашому браузері і подивіться результати

  var count = 100000000;
    var a = 0;
    console.log(new Date());

    for (var i=0; i<count; i++) {
      a = a + 1
    }

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
      a = a + 1;
    }

    console.log(new Date());

    var j;
    for (j=0; j<count; j++) {
        var x;
        x = x + 1;
    }

    console.log(new Date());

Результатом є те, що останній тест займає ~ 8 секунд, а попередній - лише ~ 2 секунди. Дуже повторно та незалежно від порядку.

Отже, це доводить мені, що завжди слід оголошувати вари за межами циклу. Цікавий для мене випадок перший, де я заявляю iу заяві for (). Цей, здається, такий же швидкий, як і 2-й тест, де я попередньо оголосив індекс.

JavaScript - це мова, написана внизу на C або C ++, я не дуже впевнений, яка це мова. І однією з його цілей є збереження запасу внутрішньої пам'яті. Навіть у C або C ++ вам не доведеться турбуватися про те, чи буде вона споживати багато ресурсів, коли змінні оголошуються всередині циклу. Чому варто турбуватися про це в JavaScript?

Ну, це залежить від того, що ви намагаєтеся досягти ... якщо valueприпустимо, що це лише тимчасова змінна всередині блоку циклу, то використовувати другу форму набагато зрозуміліше. Це також більш логічно і багатослівно.

Це не має значення, якщо ви оголошуєте змінні всередині або зовні для циклу. Нижче наведено зразок коду для тестування.

function a() {
   console.log('Function a() starts');
   console.log(new Date());
    var j;
    for (j=0; j<100000000; j++) {
        var x;
        x = x + 1;
    }
    console.log(new Date());
    console.log('Function a() Ends');
}
a()
function b() {
console.log('Function B() starts');
   console.log(new Date());
    var a;
    var j;
    for (j=0; j<100000000; j++) {
      a = a + 1;
    }
    console.log(new Date());
    console.log('Function B() Ends');
}
b()

Результати показали в моєму випадку

Function a() starts
VM121:3 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:9 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:10 Function a() Ends
VM121:14 Function B() starts
VM121:15 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:21 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time)
VM121:22 Function B() Ends

Дякую - MyFavs.in

Питання в основному полягає в тому, щоб оголосити var всередині циклу. Подумайте, що станеться, якщо ви це зробите:

var a = 30;
var a = 50;
var a = 60;

Ви вважаєте, що це правильно? Ні ... тому що ви не хочете оголошувати змінну так багато разів. Коли ви оголошуєте змінну всередині циклу, чи не оголошується вона стільки разів, коли цикл працює? Очевидно, це ляпне вам, коли ви перебуваєте в режимі "суворого використання". Люди не погодилися з Крокфордом, не замислюючись над початковим питанням.

Тому завжди добре оголошувати змінні вгорі - 1. Для читабельності, 2. Створення хороших звичок.

Що стосується продуктивності після запуску тесту на Chrome, Firefox та jsperf в ОС Linux, то, схоже, є різниця в продуктивності між декларацією змінних у циклі та поза циклом. Це невелика різниця, але це також ускладнюється кількістю ітерацій та кількістю змінних оголошень.

Тому для кращої продуктивності я б запропонував оголосити змінні поза циклом. Або ще краще оголосити свої змінні в рядку. Див. Приклад.

// inline
for (var ai = 0, al = 100000000, av; ai < al; ai++) {
    av = av + 1;
}

// outside
var bv;
var bl = 100000000;
for (var bi = 0; bi < bl; bi++) {
    bv = bv + 1;
}

Зверніть увагу, як змінна 'al' і 'av' знаходяться в рядку декларування циклу. Ця вбудована декларація забезпечила мені стабільно кращі показники. Навіть над оголошенням змінних за межами циклу. Знову різниця у виконанні дійсно невелика.

https://jsperf.com/outside-inline-for-loop-ase/1