JavaScript değişkenleri döngü içinde mi yoksa dışında mı bildiriyor?

AS3'te performans artışı için döngülerin dışındaki tüm değişkenleri başlatmanız gerektiğine inanıyorum. JavaScript ile de durum böyle mi? Hangisi daha iyi / daha hızlı / en iyi uygulama?

var value = 0;

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

veya

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

JavaScript veya ActionScript'te anlam veya performans açısından kesinlikle hiçbir fark yoktur .

varayrıştırıcı için bir direktiftir ve çalışma zamanında yürütülen bir komut değildir . Belirli bir tanımlayıcı varbir işlev gövdesinde (*) bir veya daha fazla herhangi bir yerde bildirilmişse , bu tanımlayıcının bloktaki tüm kullanımı yerel değişkene atıfta bulunacaktır. Döngünün içinde, döngünün dışında veya her ikisinin birden valuebildirildiği fark etmez var.

Sonuç olarak en okunaklı bulduğunuz şeyi yazmalısınız. Crockford ile tüm değişkenleri bir işlevin üstüne koymanın her zaman en iyi şey olduğunu kabul etmiyorum. Bir değişkenin bir kod bölümünde geçici olarak kullanıldığı durumda var, bu bölümde bildirmek daha iyidir , bu nedenle bölüm tek başına kalır ve kopyalanabilir. Aksi takdirde, birkaç kod satırını yeniden ilişkilendirme sırasında ilişkili olanı ayrı olarak seçip taşımadan yeni bir işleve kopyalayıp yapıştırın varve kendinize yanlışlıkla bir global var.

Özellikle:

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

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

Crockford ikinciyi varkaldırmanızı (ya da her ikisini de kaldırmanızı varve var i;yukarıdaki işlemleri yapmanızı ) tavsiye eder ve jslint bunun için size sızlanır. Ancak IMO var, işlevin üstünde ekstra, kolayca unutulan bir kod parçasına sahip olmak yerine, her iki s'yi de tutmak, ilgili tüm kodu bir arada tutmak daha sürdürülebilir .

Şahsen ben var, aynı fonksiyonun başka bir bölümünde aynı değişken adının başka bir ayrı kullanımı olsun veya olmasın, bağımsız bir kod bölümünde bir değişkenin ilk ataması olarak beyan etme eğilimindeyim . Benim için hiç beyan etmek varistenmeyen bir JS siğilidir (değişkenlerin yerel olarak varsayılana sahip olması daha iyi olurdu); JavaScript'te de [eski bir düzeltme] ANSI C'nin sınırlamalarını çoğaltmak benim görevim olarak görmüyorum.

(*: iç içe fonksiyon gövdeleri dışında)

Teoride, dilin blok kapsamı değil, sadece işlev kapsamı olduğu için JavaScript'te herhangi bir fark yaratmamalıdır.

Performans argümanından emin değilim, ancak Douglas Crockford hala varifadelerin işlev gövdesindeki ilk ifadeler olmasını önermektedir . JavaScript Programlama Dili için Kod Kurallarından Alıntı :

JavaScript'in blok kapsamı yoktur, bu nedenle bloklardaki değişkenleri tanımlamak, diğer C ailesi dillerinde deneyimli programcıları karıştırabilir. Fonksiyonun üstündeki tüm değişkenleri tanımlayın.

Aşağıdaki örnekte gördüğünüz gibi bir anlamı olduğunu düşünüyorum. Fonksiyonun üstündeki değişkenleri bildirmek, okuyucuları değişkenin döngü bloğu i kapsamında tutulduğunu düşünmeyle karıştırmamalıdır for:

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

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

ECMA-/JavascriptDil hoistsbir fonksiyonun üstüne yerde ilan edilir herhangi değişkeni. Bu dil olmasıdır mu var function scopeve yok değil var block scopediğer birçok dilde C benzeri gibi.
Bu olarak da bilinir lexical scope.

Gibi bir şey beyan ederseniz

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

Bu şunlara ulaşır hoisted:

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

Bu yüzden performansta herhangi bir fark yaratmaz (Ama burada tamamen yanılıyorsam beni düzeltin).
A daha iyi argüman değil bir fonksiyonun üstünde başka bir yerde daha değişken bildirerek olduğunu okunabilirliği . Bir değişkenin bir değişken içinde bildirilmesi for-loop, bu değişkenin yalnızca döngü gövdesi içinde erişilebileceği yanlış varsayımına yol açabilir, ki bu tamamen yanlıştır . Infact, bu değişkenin geçerli kapsamın herhangi bir yerine erişebilirsiniz.

Gelecek yıl, tüm tarayıcılar kodu önceden derleyen JS motorlarına sahip olacak, böylece performans farkı (aynı kod bloğunu tekrar tekrar ayrıştırma ve atamayı yürütme) ihmal edilebilir hale gelecektir.

Ayrıca, gerekmedikçe asla performans için optimize etmeyin. Değişkenleri ilk kez ihtiyacınız olan yere yakın tutmak kodunuzu temiz tutar. Olumsuz tarafta, blok kapsamı olan dillere alışkın olan insanlar karışık olabilir.

Şimdi sahip olduğumuz letve constES2015'teki bir başka husus, değişkenleri özellikle döngü bloğuna dahil edebilmenizdir. Dolayısıyla, döngü dışında aynı değişkene ihtiyacınız yoksa (veya her yineleme önceki yinelemede bu değişken için yapılan bir işleme bağlı değilse), muhtemelen bunu yapmanız tercih edilir:

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

Chrome'da yeni bir test yaptım. Tarayıcınızda kemanı deneyin ve sonuçları görün

  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());

Sonuç, son testin ~ 8 saniye sürmesi ve önceki 2'nin sadece ~ 2 saniye olmasıdır. Çok tekrarlanabilir ve sipariş ne olursa olsun.

Yani, bu bana, her zaman döngü dışındaki değişkenleri beyan etmesi gerektiğini kanıtlıyor. Meraklı durum i, for () ifadesinde bildirdiğim ilk dava . Bu, indeksi önceden bildirdiğim 2. test kadar hızlı görünüyor.

JavaScript altta C veya C ++ ile yazılmış bir dildir, hangisinin olduğundan emin değilim. Amaçlarından biri de dahili hafızayı kullanma lavourunu kurtarmaktır. C veya C ++ 'da bile, bir döngü içinde değişkenler bildirildiğinde çok fazla kaynak tüketip tüketmeyeceği konusunda endişelenmenize gerek yoktur. JavaScript için neden endişelenmelisiniz?

Bu, neyi başarmaya çalıştığınıza bağlıdır ... valuedöngü bloğunun içinde sadece geçici bir değişken olduğunu varsayalım, o zaman ikinci formu kullanmak çok daha açıktır. Aynı zamanda daha mantıklı ve ayrıntılı.

Döngü içinde veya dışında değişkenler bildirirseniz fark etmez. Test edilecek örnek kod aşağıdadır.

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()

Benim durumumda gösterilen sonuçlar

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

Teşekkür ederim - MyFavs.in

Buradaki soru temelde bir döngü içinde bir değişken bildirmektir. Bunu yaparsanız ne olacağını düşünün:

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

Bunun doğru olduğunu düşünüyor musun? Hayır ... çünkü bir değişkeni defalarca bildirmek istemiyorsunuz. Döngü içindeki bir değişkeni bildirdiğinizde, döngü çalıştığında kaç kez bildirilmiyor? Açıkçası 'katı kullanın' modundayken sizi tokatlayacaktır. İnsanlar orijinal soruyu düşünmeden Crockford'la aynı fikirde değiller.

Bu yüzden değişkenleri en üste beyan etmek her zaman iyidir - 1. Okunabilirlik için 2. İyi alışkanlıklar kazanmak.

Bir Linux işletim sisteminde Chrome, Firefox ve jsperf üzerinde test yaptıktan sonra performansla ilgili olarak, bir döngüdeki değişkenlerin bildirimi ile döngü dışı arasında bir performans farkı var gibi görünüyor. Küçük bir farktır, ancak bu aynı zamanda yineleme miktarı ve değişken bildirimlerin miktarı ile de birleştirilir.

Bu nedenle en iyi performans için değişkenlerin döngü dışında bildirilmesini öneririm. Ya da daha iyisi, değişkenlerinizi sıra ile bildiriniz. Örneğe bakın.

// 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' ve 'av' değişkeninin for döngüsü bildirim satırında nasıl olduğuna dikkat edin. Bu satır içi bildirim bana sürekli olarak daha iyi performans sağladı. Döngü dışındaki değişkenlerin beyanı üzerinde bile. Yine performans farkı gerçekten küçük.

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