Döngüler tersine gerçekten daha mı hızlı?

Bunu birkaç kez duydum. Geriye doğru sayarken JavaScript döngüleri gerçekten daha mı hızlı? Öyleyse neden? Ters döngülerin daha hızlı olduğunu gösteren birkaç test paketi örneği gördüm, ancak nedenine ilişkin herhangi bir açıklama bulamıyorum!

Ben döngü artık bitmiş olup olmadığını görmek için kontrol her zaman bir özellik değerlendirmek zorunda değildir ve sadece son sayısal değere karşı denetler çünkü varsayıyorum.

yani

for (var i = count - 1; i >= 0; i--)
{
  // count is only evaluated once and then the comparison is always on 0.
}

Bundan i--daha hızlı değil i++. Aslında ikisi de eşit derecede hızlı.

Yükselen döngülerde zaman alan şey, her ibiri için dizinizin boyutunu değerlendirmektir . Bu döngüde:

for(var i = array.length; i--;)

.lengthBeyan ederken sadece bir kez değerlendirirsiniz i, oysa bu döngü için

for(var i = 1; i <= array.length; i++)

Eğer değerlendirmek .lengthsen artırmak her zaman ieğer kontrol ederken, i <= array.length.

Çoğu durumda bu tür bir optimizasyon hakkında bile endişelenmemelisiniz .

Bu adam , birçok tarayıcıda javascript'teki birçok döngüyü karşılaştırdı. Ayrıca bir test paketi vardır, böylece onları kendiniz çalıştırabilirsiniz.

Her durumda (benim okuma bir cevapsız sürece) en hızlı döngü oldu:

var i = arr.length; //or 10
while(i--)
{
  //...
}

Bu cevapla geniş bir resim vermeye çalışıyorum.

Parantez içindeki şu düşünceler oldu ben sadece son zamanlarda konuyu test ettik kadar inancımı:

[[ C / C ++ gibi düşük seviyeli diller açısından kod, bir değişken sıfır olduğunda (veya sıfır olmadığında) işlemcinin özel bir koşullu atlama komutuna sahip olması için derlenir. Ayrıca, bu kadar optimizasyonu önemsiyorsanız, bunun yerine gidebilirsiniz , çünkü tek bir işlemci komutu anlamına gelir .]]
++ii++++ii++j=i+1, i=j

Gerçekten hızlı döngüler onları açarak yapılabilir:

for(i=800000;i>0;--i)
    do_it(i);

Şundan çok daha yavaş olabilir

for(i=800000;i>0;i-=8)
{
    do_it(i); do_it(i-1); do_it(i-2); ... do_it(i-7);
}

ancak bunun nedenleri oldukça karmaşık olabilir (sadece bahsetmek gerekirse, oyunda işlemci komutu önişleme ve önbellek işleme sorunları vardır).

İstediğiniz gibi JavaScript gibi üst düzey diller açısından, kütüphanelere, döngü için yerleşik işlevlere güveniyorsanız işleri optimize edebilirsiniz. En iyi nasıl yapılacağına karar vermelerine izin verin.

Sonuç olarak, JavaScript'te,

array.forEach(function(i) {
    do_it(i);
});

Ayrıca hataya daha az eğilimlidir ve tarayıcıların kodunuzu optimize etme şansı vardır.

[HATIRLATMA: sadece tarayıcılar değil, aynı zamanda kolayca optimize edebileceğiniz bir alanınız var forEach, en yeni en iyi hileyi kullanması için işlevi (tarayıcıya bağlı olarak) yeniden tanımlamanız yeterli ! :) @AMK özel durumlarda array.popveya kullanmaya değer olduğunu söylüyor array.shift. Bunu yaparsanız, perdenin arkasına koyun. En fazla aşırıforEach döngü, döngü algoritmasını seçmek için seçenekler eklemektir .]

Ayrıca, düşük seviyeli diller için de en iyi uygulama, mümkünse karmaşık, ilmekli işlemler için bazı akıllı kütüphane işlevlerini kullanmaktır.

Bu kütüphaneler ayrıca (çok iş parçacıklı) şeyleri arkanıza da koyabilir ve ayrıca uzman programcılar onları güncel tutar.

Biraz daha fazla inceleme yaptım ve C / C ++ 'da, 5e9 = (50.000x100.000) operasyonlar için bile, testin @alestanis'in söylediği gibi bir sabite karşı yapılması durumunda yukarı ve aşağı gitme arasında bir fark olmadığı ortaya çıkıyor. (JsPerf sonuçları bazen tutarsızdır, ancak genel olarak aynı şeyi söylerler: büyük bir fark yaratamazsınız.)
Yani --ioldukça "lüks" bir şey olur. Sadece daha iyi bir programcı gibi görünmenizi sağlar. :)

Öte yandan, bu 5e9 durumda un-unrolling için, 10s gittiğimde 12 saniye 2.5 saniye ve 20s gittiğimde 2.1 saniye düştü. Optimizasyon yoktu ve optimizasyon işleri ölçülemez az zamana indirdi. :) (Kaldırma işlemi yukarıdaki şekilde veya kullanarak yapılabilir i++, ancak bu JavaScript'te bir şey getirmez.)

Sonuçta: tutmak i--/ i++ve ++i/ i++iş görüşmeleri, sopa ki farklar array.forEacholan veya diğer kompleks kütüphane fonksiyonları. ;)

i-- kadar hızlı i++

Aşağıdaki bu kod sizinki kadar hızlıdır, ancak fazladan bir değişken kullanır:

var up = Things.length;
for (var i = 0; i < up; i++) {
    Things[i]
};

Öneri, dizinin boyutunu her seferinde DEĞİL olarak değerlendirmektir. Büyük diziler için performans düşüşü görülebilir.

Konuyla ilgilendiğiniz için, JavaScript döngü karşılaştırması hakkında Greg Reimer'ın web günlüğü yayınına bir göz atın, JavaScript'te bir Döngü Kodlamanın En Hızlı Yolu Nedir? :

JavaScript'te döngüleri kodlamanın farklı yolları için bir döngü karşılaştırma testi paketi oluşturdum. Bunlardan birkaçı zaten var, ancak yerel diziler ve HTML koleksiyonları arasındaki farkı kabul eden herhangi bir şey bulamadım.

Ayrıca bir döngüde bir performans testi açarak da yapabilirsiniz https://blogs.oracle.com/greimer/resource/loop-test.html(JavaScript tarayıcıda örneğin NoScript tarafından engellendiyse çalışmaz ).

DÜZENLE:

Milan Adamovsky tarafından oluşturulan daha yeni bir kriter, burada farklı tarayıcılar için çalışma zamanında gerçekleştirilebilir .

Bir For Mac OS X Firefox 17.0 in Testini 10.6 Aşağıdaki döngü var:

var i, result = 0;
for (i = steps - 1; i; i--) {
  result += i;
}

en hızlı olduğu gibi:

var result = 0;
for (var i = steps - 1; i >= 0; i--) {
  result += i;
}

Bu --ya da değil ++, karşılaştırma işlemidir. İle --0 ile bir karşılaştırma kullanabilirsiniz, bununla birlikte ++uzunluğu ile karşılaştırmanız gerekir. İşlemcide, normalde sıfır ile karşılaştırmak mümkündür, ancak sonlu bir tamsayı ile karşılaştırmak bir çıkarma gerektirir.

a++ < length

aslında derlendi

a++
test (a-length)

Bu yüzden derlendiğinde işlemcide daha uzun sürer.

Kısa cevap

Normal kod için, özellikle JavaScript gibi üst düzey bir dilde , i++ve öğelerinde performans farkı yoktur i--.

Performans kriterleri fordöngüdeki kullanım ve karşılaştırma ifadesidir.

Bu , tüm üst düzey diller için geçerlidir ve çoğunlukla JavaScript kullanımından bağımsızdır. Açıklama, en alt satırda ortaya çıkan birleştirici kodudur.

Detaylı açıklama

Bir döngüde bir performans farkı oluşabilir. Arka plan, montajcı kodu düzeyinde , a'nıncompare with 0 ek bir kayıt gerektirmeyen tek bir deyim olduğunu görebilirsiniz .

Bu karşılaştırma, döngünün her geçişinde verilir ve ölçülebilir bir performans artışı ile sonuçlanabilir.

for(var i = array.length; i--; )

şöyle bir sahte kodla değerlendirilir :

 i=array.length
 :LOOP_START
 decrement i
 if [ i = 0 ] goto :LOOP_END
 ... BODY_CODE
 :LOOP_END

Not bu 0 değişmez ya da başka bir deyişle, sabit bir değerdir.

for(var i = 0 ; i < array.length; i++ )

böyle bir sahte kodla değerlendirilecektir (normal yorumlayıcı optimizasyonu varsayılmaktadır):

 end=array.length
 i=0
 :LOOP_START
 if [ i < end ] goto :LOOP_END
 increment i
 ... BODY_CODE
 :LOOP_END

Not o uç bir ihtiyacı olan bir değişkendir CPU kayıt. Bu yakarmak olabilir ek sicil takas kodunda ve bir ihtiyacı daha pahalı karşılaştırmak deyimi içinde ifdeyimi.

Sadece 5 sentim

Üst düzey bir dil için, sürdürülebilirliği kolaylaştıran okunabilirlik, küçük bir performans iyileştirmesi olarak daha önemlidir.

Normalde dizi başından sonuna kadar klasik yineleme daha iyidir.

Dizi sonundan başlayarak daha hızlı yineleme , olası istenmeyen ters sırayla sonuçlanır.

Komut dosyası yayınla

Bir yorumda sorulduğu gibi: Azaltma öncesi veya sonrası arasındaki fark --ive i--değerlendirmededir i.

En iyi açıklama denemek ;-) İşte bir Bash örneği.

 % i=10; echo "$((--i)) --> $i"
 9 --> 9
 % i=10; echo "$((i--)) --> $i"
 10 --> 9

Aynı öneriyi Sublime Text 2'de gördüm.

Daha önce söylendiği gibi, ana iyileştirme for döngüsünde her yinelemede dizinin uzunluğunu değerlendirmemektedir. Bu, iyi bilinen bir optimizasyon tekniğidir ve dizi HTML belgesinin bir parçası olduğunda JavaScript'te etkilidir ( fortüm liöğeler için bir yapıyor ).

Örneğin,

for (var i = 0; i < document.getElementsByTagName('li').length; i++)

daha yavaş

for (var i = 0, len = document.getElementsByTagName('li').length; i < len; i++)

Ben duruyorum yerden, sorunuzu şeklinde ana bir iyileşme (ekstra bir değişkeni bildirmek olmadığı gerçektir lenbizim örneğimizde)

Ama bana sorarsanız, bütün mesele i++vs i--optimizasyonu değil, her yinelemede dizinin uzunluğunu değerlendirmekle ilgili değildir ( jsperf'de bir kıyaslama testi görebilirsiniz ).

JavaScript'ten i--daha hızlı olduğunu söylemenin mantıklı olduğunu düşünmüyorum i++.

Her şeyden önce , tamamen JavaScript motoru uygulamasına bağlıdır.

İkincisi , en basit JIT'i kurması ve yerel talimatlara çevrilmesi şartıyla, i++vs i--, tamamen onu çalıştıran CPU'ya bağlı olacaktır. Yani, ARM'lerde (cep telefonları), azalma ve sıfıra kıyasla tek bir komutla yürütüldüğünden 0'a inmek daha hızlıdır.

Muhtemelen, birinin diğerinden daha fazla atık olduğunu düşündün çünkü önerilen yol

for(var i = array.length; i--; )

ancak önerilen yol, biri diğerinden daha hızlı olduğu için değil,

for(var i = 0; i < array.length; i++)

her yinelemede array.lengthdeğerlendirilmek zorundaydı (daha akıllı JavaScript motoru, döngünün dizinin uzunluğunu değiştirmeyeceğini tahmin edebilir). Basit bir ifade gibi görünse de, aslında JavaScript motoru tarafından başlık altında çağrılan bir işlevdir.

Diğer neden, i--"daha hızlı" olarak değerlendirilmesinin nedeninin nedeni, JavaScript motorunun döngüyü kontrol etmek için yalnızca bir dahili değişken ayırması gerektiğidir (değişken var i). Array.length veya başka bir değişkenle karşılaştırdıysanız, döngüyü kontrol etmek için birden fazla dahili değişken olması gerekiyordu ve dahili değişkenlerin sayısı bir JavaScript motorunun sınırlı varlığıdır. Bir döngüde ne kadar az değişken kullanılırsa JIT'in optimizasyon şansı o kadar artar. Bu yüzden i--daha hızlı düşünülebilir ...

Diğer cevapların hiçbiri sizin özel sorunuza cevap vermediği için (yarısından fazlası C örnekleri gösteriyor ve alt düzey dilleri tartışıyor, sorunuz JavaScript için) Kendi sorumluluğu yazmaya karar verdim.

İşte böyle:

Basit cevap: i-- genellikle daha hızlıdır, çünkü her çalıştığında 0 ile bir karşılaştırma yapmak zorunda değildir, çeşitli yöntemlerde test sonuçları aşağıdadır:

Test sonuçları: Bu jsPerf tarafından "kanıtlanmış" olduğu gibi arr.pop(), aslında açık arayla en hızlı döngü. Ama odaklanarak --i, i--, i++ve ++iözetlenmiştir sonuçlarında size soru sorulduğunda gibi burada (aşağıdaki kaynaklardan bakın, birden jsPerf en gelmektedir) jsPerf şunlardır:

--ive Chrome'da daha hızlı i--iken Firefox'ta aynıdır i--.

Chrome'da bir temel for döngüsü ( for (var i = 0; i < arr.length; i++)) Firefox'takinden daha hızlıdır i--ve --idaha yavaştır.

Chrome ve Firefox'ta önbelleğe alınan arr.lengthChrome, yaklaşık 170.000 ops / sn önde Chrome ile önemli ölçüde daha hızlıdır.

Önemli bir fark olmadan , çoğu tarayıcıdan ++idaha hızlıdır i++, AFAIK, hiçbir tarayıcıda asla tersi olmaz.

Kısa özet: arr.pop() açık arayla en hızlı döngüdür; özel olarak belirtilen döngüler için, i--en hızlı döngüdür.

Kaynaklar: http://jsperf.com/fastest-array-loops-in-javascript/15 , http://jsperf.com/ipp-vs-ppi-2

Umarım bu soruya cevap verir.

Dizinizin belleğe yerleştirilmesine ve bu diziye erişirken bellek sayfalarının isabet oranına bağlıdır.

Bazı durumlarda, isabet oranındaki artış nedeniyle dizi üyelerine sütun sırasına erişmek satır sırasından daha hızlıdır.

En son rahatsız ettiğim zaman 6502 derleme (8 bit, evet!) Yazarken oldu . Büyük kazanç, çoğu aritmetik işlemin (özellikle azalmalar) bir dizi bayrağı güncelledi, bunlardan biri Z'sıfıra ulaştı' göstergesi oldu.

Bu nedenle, döngünün sonunda sadece iki talimat yaptınız: DEC(azalma) ve JNZ(sıfır değilse atlama), karşılaştırmaya gerek yok!

JavaScript (ve tüm diller) sonunda CPU üzerinde çalıştırmak için opcode dönüştürülerek açıklanabilir. CPU'ların sıfıra karşı karşılaştırmak için her zaman tek bir talimatı vardır;

Bir yana, counther zaman >= 0olduğunu garanti edebilirseniz , basitleştirebilirsiniz:

for (var i = count; i--;)
{
  // whatever
}

Bu, --veya ++işaretine bağlı değildir , ancak döngüde uyguladığınız koşullara bağlıdır.

Örneğin: Değişkenin statik bir değeri varsa döngünüz, bir dizinin uzunluğu veya diğer koşullar gibi her seferinde döngü denetim koşullarından daha hızlıdır.

Ancak bu optimizasyon hakkında endişelenmeyin, çünkü bu sefer etkisi nanosaniye olarak ölçülür.

for(var i = array.length; i--; )çok daha hızlı değil. Değiştirmeye Ama array.lengthbirlikte super_puper_function(), olabilir önemli ölçüde (her tekrarında denir beri) daha hızlı. Aradaki fark bu.

2014 yılında değiştirecekseniz, optimizasyonu düşünmeniz gerekmez. "Arama ve Değiştirme" ile değiştirecekseniz, optimizasyonu düşünmenize gerek yoktur. Zamanınız yoksa, optimizasyon hakkında düşünmenize gerek yoktur. Ama şimdi bunu düşünmek için zamanın var.

PS: i--daha hızlı değil i++.

Kısaca kesmek için: Bunu JavaScript'te yapmanın kesinlikle bir farkı yoktur.

Her şeyden önce, kendiniz test edebilirsiniz:

• jsperf - JavaScript'te her türlü performans testi için mükemmel bir platformdur .

• http://jsperf.com/inc-vs-dec-2

Herhangi bir JavaScript kitaplığındaki herhangi bir komut dosyasını test etmek ve çalıştırmakla kalmaz, aynı zamanda önceden yazılmış komut dosyalarının tamamına ve farklı platformlarda farklı tarayıcılarda yürütme süresi arasındaki farkları görme yeteneğine de erişebilirsiniz.

Gördüğünüz kadarıyla, herhangi bir ortamdaki performans arasında bir fark yoktur.

Komut dosyanızın performansını artırmak istiyorsanız, yapmaya çalışabileceğiniz şeyler:

1. var a = array.length;Döngüdeki her seferinde değerini hesaplamamanız için bir ifade alın
2. Döngü kilidini açma http://en.wikipedia.org/wiki/Loop_unwinding

Ancak, elde edebileceğiniz iyileşmenin o kadar önemsiz olacağını anlamalısınız, çoğunlukla bunu önemsememeniz gerekir.

Kendi fikrim neden böyle bir yanlış anlama (Dec vs Inc) ortaya çıktı

Uzun zaman önce DSZ (Azaltma ve Atlama Sıfıra) gibi ortak bir makine talimatı vardı. Montaj dilinde programlanmış kişiler, bir kayıt kaydetmek için döngüler uygulamak için bu komutu kullandı. Şimdi bu eski gerçekler kullanılmıyor ve bu sözde gelişmeyi kullanarak herhangi bir dilde herhangi bir performans artışı elde edemeyeceğinizden eminim.

Sanırım bu tür bilginin zamanımızda yayılabilmesinin tek yolu, başkasının kişi kodunu okumanızdır. Böyle bir yapıyı görün ve neden uygulandığını sorun ve burada cevap: "sıfıra kıyasla performansı artırır". Meslektaşınla ilgili daha fazla bilgiden şaşkına döndün ve bunu daha akıllı olmak için kullanmayı düşündün :-)

Ben jsbench üzerinde bir karşılaştırma yaptım .

Alestani'nin işaret ettiği gibi, yükselen döngülerde zaman alan bir şey, her bir yineleme için dizinizin boyutunu değerlendirmektir. Bu döngüde:

for ( var i = 1; i <= array.length; i++ )

.lengthher artırdığınızda değerlendirirsiniz i. Bu birinde:

for ( var i = 1, l = array.length; i <= l; i++ )

.lengthbeyan ettiğinizde sadece bir kez değerlendirirsiniz i. Bu birinde:

for ( var i = array.length; i--; )

karşılaştırma örtüktür, azalmadan hemen önce gerçekleşir ive kod çok okunabilir. Ancak, müthiş bir fark yaratabilecek olan şey, döngü içine koyduğunuz şeydir.

İşlev çağrısı ile döngü (başka bir yerde tanımlanmıştır):

for (i = values.length; i-- ;) {
  add( values[i] );
}

Satır içi kod ile döngü:

var sum = 0;
for ( i = values.length; i-- ;) {
  sum += values[i];
}

Kodunuzu, bir işlevi çağırmak yerine, okunabilirlikten ödün vermeden satır içine alabiliyorsanız, daha hızlı bir büyüklük sırasına sahip olabilirsiniz!

Not : tarayıcı basit işlevleri satır içinde iyileştirirken , kodunuzun ne kadar karmaşık olduğuna bağlıdır. Optimize etmeden önce profil yapın, çünkü

1. Darboğaz başka bir yerde olabilir (ajax, reflow, ...)
2. Daha iyi bir algoritma seçebilirsiniz
3. Daha iyi bir veri yapısı seçebilirsiniz

Ama hatırla:

Kod, insanların okuması ve yalnızca makinelerin yürütmesi için yazılır.

Bunu şimdi yapma şekliniz daha hızlı değil (belirsiz bir döngü olmasının dışında, sanırım yapmak istediniz) i--.

Daha hızlı yapmak istiyorsanız:

for (i = 10; i--;) {
    //super fast loop
}

Tabii ki böyle küçük bir döngüde fark etmezsiniz. Daha hızlı olmasının nedeni, "doğru" olup olmadığını kontrol ederken i değerini azaltmanızdır (0'a ulaştığında "yanlış" olarak değerlendirilir)

Bazen kodumuzu yazma biçimimizde çok küçük değişiklikler yapmak, kodumuzun gerçekte ne kadar hızlı çalıştığında büyük bir fark yaratabilir. Küçük bir kod değişikliğinin yürütme sürelerinde büyük bir fark yaratabileceği bir alan, bir diziyi işleyen bir for döngüsüne sahip olduğumuz yerdir. Dizinin web sayfasındaki öğeler (radyo düğmeleri gibi) olduğu yerlerde, değişiklik en büyük etkiye sahiptir, ancak dizinin Javascript kodunun içinde olduğu yerlerde bile bu değişikliği uygulamaya değer.

Bunun gibi bir dizi lis işlemek için bir for döngüsü kodlamanın geleneksel yolu:

for (var i = 0; i < myArray.length; i++) {...

Buradaki sorun, myArray.length kullanarak dizinin uzunluğunun değerlendirilmesinin zaman alması ve döngüyü kodlama şeklimizin, bu değerlendirmenin döngü çevresinde her seferinde yapılması gerektiği anlamına gelir. Dizi 1000 öğe içeriyorsa, dizinin uzunluğu 1001 kez değerlendirilir. Radyo düğmelerine bakıyorduk ve myForm.myButtons.length'e sahip olsaydık, uzunluğun her döngüde değerlendirilmesinden önce belirtilen formdaki uygun düğme grubunun bulunması gerektiğinden değerlendirmek daha da uzun sürer.

Açıkçası, diziyi işlerken dizinin uzunluğunun değişmesini beklemiyoruz, böylece uzunluğun tüm bu yeniden hesaplamaları işlem süresine gereksiz yere ekleniyor. (Tabii ki döngü içinde dizi girişleri ekleyen veya silen kodunuz varsa, dizi boyutu yinelemeler arasında değişebilir ve bu nedenle test eden kodu değiştiremeyiz)

Boyutun sabit olduğu bir döngü için bunu düzeltmek için yapabileceğimiz, döngünün başlangıcında uzunluğu bir kez değerlendirmek ve bir değişkene kaydetmek. Daha sonra, döngüyü ne zaman sonlandıracağına karar vermek için değişkeni test edebiliriz. Bu, özellikle dizi yalnızca birkaç girişten fazlasını içerdiğinde veya web sayfasının bir parçası olduğunda, her seferinde dizi uzunluğunu değerlendirmekten çok daha hızlıdır.

Bunu yapmak için kod:

for (var i = 0, var j = myArray.length; i < j; i++) {...

Şimdi dizinin boyutunu yalnızca bir kez değerlendiriyoruz ve döngü sayacımızı döngü etrafında her seferinde bu değeri tutan değişkenle test ediyoruz. Bu ekstra değişkene dizinin boyutunu değerlendirmekten çok daha hızlı erişilebilir ve böylece kodumuz eskisinden çok daha hızlı çalışacaktır. Senaryomuzda sadece bir tane ekstra değişken var.

Genellikle, dizideki tüm girdiler işlendiği sürece diziyi hangi sırada işlediğimiz önemli değildir. Bu durumda, az önce eklediğimiz ekstra değişkeni ortadan kaldırarak ve diziyi ters sırada işleyerek kodumuzu biraz daha hızlı hale getirebiliriz.

Dizimizi mümkün olan en verimli şekilde işleyen son kod:

for (var i = myArray.length-1; i > -1; i--) {...

Bu kod hala dizinin boyutunu başlangıçta yalnızca bir kez değerlendirir, ancak döngü sayacını bir değişkenle karşılaştırmak yerine onu bir sabitle karşılaştırırız. Bir sabit, bir değişkene erişmek için daha da etkili olduğundan ve kodun üçüncü sürümümüzden daha az bir atama ifademiz olduğundan, şimdi ikinci sürümden biraz daha verimli ve birinciden çok daha verimli.

++vs.'nin --önemi yoktur, çünkü JavaScript yorumlanmış bir dildir, derlenmiş bir dil değildir. Her talimat birden fazla makine diline çevrilir ve kanlı ayrıntılarla ilgilenmemelisiniz.

Montaj talimatlarını verimli bir şekilde kullanmak için --(veya ++) kullanmayı konuşan kişiler yanlıştır. Bu komut tamsayı aritmetiği için geçerlidir ve JavaScript'te tamsayı yoktur, sadece sayılar vardır .

Okunabilir kod yazmalısınız.

Çoğu durumda, bunun aslında işlemcilerin sıfırı diğer karşılaştırmalardan daha hızlı karşılaştırabilmeleri ile ilgisi yoktur.

Bunun nedeni, sadece birkaç Javascript motorunun (JIT listesindeki motorlar ) aslında makine dil kodu oluşturmasıdır.

Çoğu Javascript motoru, daha sonra yorumladıkları kaynak kodunun dahili bir temsilini oluşturur (bunun nasıl bir şey olduğu hakkında bir fikir edinmek için , Firefox'un SpiderMonkey'inde bu sayfanın alt kısmına bakın ). Genellikle bir kod parçası hemen hemen aynı şeyi yapar ancak daha basit bir dahili temsile yol açarsa, daha hızlı çalışır.

Bir değişkenden bir değişken ekleme / çıkarma veya bir değişkeni bir şeyle karşılaştırma gibi basit görevlerle, yorumlayıcının bir dahili "talimattan" diğerine geçme yükünün oldukça yüksek olduğunu, bu nedenle daha az "talimatların" dahili olarak JS motoru tarafından kullanılırsa, o kadar iyidir.

Peki, JavaScript hakkında bilmiyorum, gerçekten sadece dizi yeniden değerlendirme meselesi olmalı ve belki ilişkilendirilebilir dizilerle ilgili bir şey olmalı (sadece azalırsanız, yeni girişlerin tahsis edilmesi muhtemel değildir - eğer dizi yoğun, yani birisi bunun için optimize edebilir).

Düşük seviyeli montajda, DJNZ (sıfır değilse azaltma ve atlama) adı verilen bir döngü talimatı vardır. Bu nedenle, eksiltme ve atlama tek bir komutta, bu da INC ve JL / JB'den daha hızlı bir şekilde daha hızlı hale geliyor (arttırma, eğer daha düşükse atlama / atlamadan daha düşükse). Ayrıca, sıfıra karşı karşılaştırmak başka bir sayıya göre karşılaştırmaktan daha kolaydır. Ancak tüm bunlar gerçekten marjinal ve aynı zamanda hedef mimariye de bağlı (örneğin akıllı telefonda Arm üzerinde fark yaratabilir).

Bu düşük seviyedeki farklılıkların yorumlanmış diller üzerinde çok büyük bir etkisi olmasını beklemezdim, yanıtlar arasında DJNZ'yi görmedim, bu yüzden ilginç bir düşünceyi paylaşacağımı düşündüm.

Bu kullanılan tek bir sonuç, indirildiği bir değer yoktur, çünkü (C ++) dibromtriakontan hızlı olduğu söylenebilir. i-- azaltılmış değeri i'ye geri saklamalı ve sonuç olarak orijinal değeri korumalıdır (j = i--;). Çoğu derleyicide bu, bir kayıt defteri değişkeni olarak saklanmak yerine başka bir değişkenin belleğe yazılmasına neden olabilecek biri yerine iki kayıt kullandı.

Bu günlerde hiçbir fark yaratmadığını söyleyenlere katılıyorum.

Çok basit bir deyişle

"i-- ve i ++. Aslında ikisi de aynı zamanı alıyor".

ancak bu durumda artımlı işlem yaptığınızda .. işlemci, değişken 1 olduğunda her zaman .length değerini değerlendirir ve azalma durumunda .. özellikle bu durumda, 0 elde edene kadar .length değerini yalnızca bir kez değerlendirir.

Birincisi, i++ve i--tam olarak JavaScript dahil olmak üzere herhangi bir programlama dili, aynı zaman alabilir.

Aşağıdaki kod çok farklı zaman alır.

Hızlı:

for (var i = 0, len = Things.length - 1; i <= len; i++) { Things[i] };

Yavaş:

for (var i = 0; i <= Things.length - 1; i++) { Things[i] };

Bu nedenle, aşağıdaki kod da farklı zaman alır.

Hızlı:

for (var i = Things.length - 1; i >= 0; i--) { Things[i] };

Yavaş:

for (var i = 0; i <= Things.length - 1; i++) { Things[i] };

PS Slow , derleyicinin optimizasyonu nedeniyle yalnızca birkaç dilde (JavaScript motorları) yavaştır. En iyi yol yerine '<' yerine '<=' (veya '=') ve '----' yerine 'i--' kullanmaktır .

İ-- veya i ++ tarafından çok fazla zaman harcanmaz. CPU mimarisinin derinliklerine giderseniz , işlem 2'nin tamamlayıcısını yapacağından ++daha hızlıdır , ancak donanımın içinde olur, böylece bu onu hızlı hale getirir ve bu işlemler arasında önemli bir fark yoktur . CPU'da en az tüketilen zaman. ----++--

Döngü böyle çalışır:

• Değişkeni başlangıçta bir kez başlatın.
• Döngünün ikinci işlenen içinde kısıtlamayı edin, <, >, <=, vb
• Sonra döngüyü uygulayın.
• Döngüyü artırın ve döngü tekrar bu işlemleri tekrar atın.

Yani,

for (var i = Things.length - 1; i >= 0; i--) {
    Things[i]
}; 

dizi uzunluğunu başlangıçta yalnızca bir kez hesaplar ve bu çok zaman değildir, ancak

for(var i = array.length; i--; ) 

her döngüdeki uzunluğu hesaplar, böylece çok zaman harcar.

Bu tür bir soruyu cevaplamanın en iyi yolu aslında denemektir. Bir milyon yineleme veya her neyse sayılan bir döngü oluşturun ve bunu her iki şekilde yapın. Her iki döngüyü de zamanlayın ve sonuçları karşılaştırın.

Yanıt muhtemelen kullandığınız tarayıcıya bağlı olacaktır. Bazılarının sonuçları diğerlerinden farklı olacaktır.

Bayıldım, bir sürü not var ama cevap yok: D

Sadece sıfıra karşı bir karşılaştırma koymak her zaman en hızlı karşılaştırmadır

Yani (a == 0), True döndürmede aslında (a == 5) daha hızlıdır

Küçük ve önemsizdir ve bir koleksiyondaki 100 milyon sıra ile ölçülebilir.

yani bir döngü yukarı nerede i <= array.length ve i artırma

aşağı döngüde nerede i> = 0 olduğunu söyleyebilir ve onun yerine i azalıyor olabilirsiniz.

Karşılaştırma daha hızlıdır. Döngünün 'yönü' değil.

BAŞKA BİR BAŞLIKTAN KAÇININIZA YARDIMCI OLUN!

Bu sayfadaki en popüler cevap Firefox 14 için çalışmıyor ve jsLinter'ı geçmiyor. "while" döngülerinin ödev değil, karşılaştırma operatörü olması gerekir. Krom, safari ve hatta ie üzerinde çalışır. Ancak firefox'ta ölüyor.

BU BOZUK!

var i = arr.length; //or 10
while(i--)
{
  //...
}

BU ÇALIŞACAK! (firefox üzerinde çalışır, jsLinter'i geçer)

var i = arr.length; //or 10
while(i>-1)
{
  //...
  i = i - 1;
}

Bu sadece bir tahmindir, ancak belki de işlemcinin bir şeyi başka bir değerle (i <Things.length) yerine 0 (i> = 0) ile karşılaştırması daha kolaydır.