JavaScript'teki artış (“++”) ve azaltma (“-”) operatörlerinden neden kaçınmalısınız?

Jslint aracı için ipuçlarından biri:

++ ve -
++ (artış) ve - (azalma) operatörlerinin aşırı hileyi teşvik ederek kötü koda katkıda bulunduğu bilinmektedir. Virüslere ve diğer güvenlik tehditlerine olanak tanıyan hatalı mimariden sonra ikinci sıradalar. Bu operatörlerin kullanımını yasaklayan bir artı seçenek vardır.

PHP yapıları gibi $foo[$bar++]kolayca off-by-one hataları ile sonuçlanabilir biliyorum , ama bir while( a < 10 ) do { /* foo */ a++; }veya daha döngü kontrol etmek için daha iyi bir yol anlayamadık for (var i=0; i<10; i++) { /* foo */ }.

Jslint onları " ++" ve " --" sözdiziminden yoksun ya da farklı şekilde ele aldığı için benzer diller olduğundan mi yoksa eksik olabileceğim " ++" ve " --" 'den kaçınmanın başka mantıkları mı var?

Benim görüşüm her zaman olduğu gibi ++ ve - tek başına tek bir satırda kullanmaktır:

i++;
array[i] = foo;

onun yerine

array[++i] = foo;

Bunun dışındaki herhangi bir şey bazı programcılar için kafa karıştırıcı olabilir ve bence buna değmez. Çünkü döngüler bir istisnadır, çünkü artım operatörünün kullanımı deyimseldir ve bu nedenle daima açıktır.

Açıkçası bu tavsiyeyle kafam karıştı. Bir parçam, javascript kodlayıcıları ile deneyim eksikliği (algılanan veya gerçek) ile ilgisi olup olmadığını merak ediyor.

Birisi nasıl sadece bazı örnek kod "hack" nasıl + ve - ile masum bir hata yapabilir görebilirsiniz, ama deneyimli bir profesyonel neden onları önlemek olacağını görmüyorum.

C'de bir şey yapmanın bir tarihi vardır:

while (*a++ = *b++);

bir dizeyi kopyalamak için belki de bahsettiği aşırı hileliğin kaynağı budur.

Ve her zaman ne olduğu sorusu vardır

++i = i++;

veya

i = i++ + ++i;

aslında. Bazı dillerde tanımlanmıştır ve diğerlerinde ne olacağının garantisi yoktur.

Bu örnekler bir yana, artmak için kullanılan bir for döngüsünden daha deyimsel bir şey olduğunu sanmıyorum ++. Bazı durumlarda, bir foreach döngüsüyle veya farklı bir durumu kontrol eden bir while döngüsüyle kurtulabilirsiniz. Ancak, arttırma kullanmaktan kaçınmak için kodunuzu bükmek saçma.

JavaScript İyi Parçalar'ı okursanız, Crockford'un bir for döngüsünde i ++ yerine ikisinin i + = 1 (i = i + 1 değil) olduğunu görürsünüz . Bu oldukça temiz ve okunabilir ve "zor" bir şeye dönüşme olasılığı daha düşük.

Crockford AUTOINCREMENT izin vermeme ve bir autodecrement yapılan seçeneği jslint içinde. Tavsiyeye uyup uymayacağınızı siz seçersiniz.

Kendi kişisel kuralım, otomatik azaltma veya otomatik azaltma ile birlikte hiçbir şey yapmamaktır.

Ben C deneyim yıllardan ben basit kullanımı devam ederseniz ben arabellek taşması (veya sınırları dışında dizi dizini) alamadım öğrendim. Ama ben aynı ifadede başka şeyler yapmak "aşırı zor" uygulama içine düşersem arabellek taşması olduğunu keşfettim.

Yani, kendi kurallar için, bir for döngüsünde artış olarak i ++ kullanımı gayet iyi.

Bir döngüde zararsızdır, ancak bir atama ifadesinde beklenmedik sonuçlara yol açabilir:

var x = 5;
var y = x++; // y is now 5 and x is 6
var z = ++x; // z is now 7 and x is 7

Değişken ve operatör arasındaki boşluk da beklenmedik sonuçlara yol açabilir:

a = b = c = 1; a ++ ; b -- ; c; console.log('a:', a, 'b:', b, 'c:', c)

Bir kapanışta, beklenmedik sonuçlar da bir sorun olabilir:

var foobar = function(i){var count = count || i; return function(){return count++;}}

baz = foobar(1);
baz(); //1
baz(); //2


var alphabeta = function(i){var count = count || i; return function(){return ++count;}}

omega = alphabeta(1);
omega(); //2
omega(); //3

Ve yeni satırdan sonra otomatik noktalı virgül eklemeyi tetikler:

var foo = 1, bar = 2, baz = 3, alpha = 4, beta = 5, delta = alpha
++beta; //delta is 4, alpha is 4, beta is 6

preincrement / postincrement karışıklığı, teşhis edilmesi son derece zor olan tek tek hatalar üretebilir. Neyse ki, onlar da gereksizdir. Bir değişkene 1 eklemenin daha iyi yolları vardır.

Referanslar

• JSLint Yardımı: Artış ve Azaltma İşleçleri

Aşağıdaki kodu düşünün

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[i++] = i++;
    a[i++] = i++;
    a[i++] = i++;

i ++ iki kez değerlendirildiğinden çıktı (vs2005 hata ayıklayıcısından)

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

Şimdi aşağıdaki kodu göz önünde bulundurun:

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = ++i;
    a[++i] = ++i;
    a[++i] = ++i;

Çıktının aynı olduğuna dikkat edin. Şimdi ++ i ve i ++ 'ın aynı olduğunu düşünebilirsiniz. Onlar değil

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

Son olarak bu kodu düşünün

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = i++;
    a[++i] = i++;
    a[++i] = i++;

Çıktı şimdi:

    [0] 0   int
    [1] 1   int
    [2] 0   int
    [3] 3   int
    [4] 0   int
    [5] 5   int

Yani aynı değiller, her ikisi de karıştırmak o kadar sezgisel davranışla sonuçlanmaz. Döngüler için ++ ile tamam olduğunu düşünüyorum, ancak aynı satırda veya aynı talimatta birden fazla ++ sembolü olduğunda dikkat edin

Artış ve eksiltme operatörlerinin "öncesi" ve "sonrası" doğası, bunlara aşina olmayanlar için kafa karıştırıcı olabilir; bu onların zor olabilmelerinin bir yoludur.

Benim görüşüme göre, "Açık, her zaman örtük olmaktan iyidir." Çünkü bir noktada, bu artış ifadesiyle kafanız karışabilir y+ = x++ + ++y. İyi bir programcı kodunu her zaman daha okunaklı yapar.

++ veya - 'dan kaçınmanın en önemli mantığı, operatörlerin değerleri döndürmesi ve aynı zamanda yan etkilere neden olması, kod hakkında akıl yürütmeyi zorlaştırmasıdır.

Verimlilik için şunu tercih ederim:

• ++ i kullanmayan dönüş değeri (hiçbir geçici)
• i ++ kullanılarak dönüş değeri (bir boru hattı durak)

Bay Crockford hayranıyım, ama bu durumda katılmıyorum. ++iayrıştırılacak metinden% 25 daha az i+=1 ve tartışmasız daha nettir.

Douglas Crockford'un bu konudaki videosunu izledim ve arttırma ve eksiltme kullanmamaya ilişkin açıklaması

1. Geçmişte diğer dillerde dizilerin sınırlarını kırmak ve tüm kötülük ve davranış biçimlerine neden olmak için kullanılmıştır.
2. Daha kafa karıştırıcı ve deneyimsiz JS geliştiricileri tam olarak ne yaptığını bilmiyorlar.

Öncelikle JavaScript'teki diziler dinamik olarak boyutlandırılmıştır ve bu yüzden yanlışsam beni affet, bir dizinin sınırlarını kırmak ve JavaScript'te bu yöntem kullanılarak erişilmemesi gereken verilere erişmek mümkün değildir.

İkincisi, karmaşık olan şeylerden kaçınmalıyız, elbette sorun bu tesise sahip olmamız değil, sorun şu ki, JavaScript yaptıklarını iddia eden ancak bu operatörlerin nasıl çalıştığını bilmeyen geliştiriciler var mı? Yeterince basit. değeri ++, bana geçerli değeri ver ve ifade bir tane ekledikten sonra, ++ değeri, bana vermeden önce değeri artır.

Bir ++ + ++ b gibi ifadeler, yukarıdakileri hatırlarsanız kolayca çalışabilirsiniz.

var a = 1, b = 1, c;
c = a ++ + ++ b;
// c = 1 + 2 = 3; 
// a = 2 (equals two after the expression is finished);
// b = 2;

Sanırım sadece kodu kimin okuması gerektiğini hatırlamanız gerekiyor, eğer JS'yi dışarıda bilen bir ekibiniz varsa endişelenmenize gerek yok. Değilse, yorum yapın, farklı yazın, vb. Yapmanız gerekeni yapın. Artış ve azalmanın doğası gereği kötü olduğunu veya hata yaratan veya güvenlik açığı oluşturduğunu düşünmüyorum, belki de kitlenize bağlı olarak daha az okunabilir.

Btw, sanırım Douglas Crockford zaten bir efsane, ama bence hak etmeyen bir operatör üzerinde çok korkuttu.

Yine de yanlış olduğu kanıtlanmış olarak yaşıyorum ...

Başka bir örnek, artmış değerin basit geri dönüşüyle ​​diğerlerinden daha basit:

function testIncrement1(x) {
    return x++;
}

function testIncrement2(x) {
    return ++x;
}

function testIncrement3(x) {
    return x += 1;
}

console.log(testIncrement1(0)); // 0
console.log(testIncrement2(0)); // 1
console.log(testIncrement3(0)); // 1

Gördüğünüz gibi, bu operatörün sonucu etkilemesini istiyorsanız, dönüş ifadesinde hiçbir artım / azalma kullanılmamalıdır. Ancak getiri, artış / azalma sonrası operatörlerini "yakalamaz":

function closureIncrementTest() {
    var x = 0;

    function postIncrementX() {
        return x++;
    }

    var y = postIncrementX();

    console.log(x); // 1
}

Programcıların kullandıkları dilde yetkin olmaları gerektiğini düşünüyorum; açıkça kullanın; ve iyi kullanın. Ben yok yapay kullandıkları dili sakat gerektiğini düşünüyorum. Deneyimden konuşuyorum. Bir zamanlar ELSE kullanmadıkları bir Cobol mağazasının hemen yanında çalıştım, çünkü 'çok karmaşıktı'. Reductio ad absurdam.

Varolan cevapların bazılarında belirtildiği gibi (rahatsız edici bir şekilde yorum yapamıyorum), sorun x ++ ++ x'in farklı değerlere (artıştan önce vs sonra) değer vermesi, ki bu açık değil ve çok kafa karıştırıcı olabilir - Eğer bu değer kullanılır. cdmckay, arttırma operatörünün kullanılmasına izin vermeyi oldukça akıllıca önerir, ancak yalnızca döndürülen değerin, örneğin kendi satırında kullanılmayacağı bir şekilde. Ben de bir for döngüsü içinde standart kullanımı (ancak yalnızca dönüş değeri kullanılmayan üçüncü deyim) içerir. Başka bir örnek düşünemiyorum. Kendimi "yanmış" olduktan sonra, aynı kılavuzu diğer diller için de tavsiye ederim.

Bu aşırı katılığın birçok JS programcısının deneyimsiz olmasından kaynaklandığı iddiasına katılmıyorum. Bu, "aşırı zekice" programcıların tipik yazı tipidir ve daha geleneksel dillerde ve bu dillerde arka planı olan JS geliştiricileri ile çok daha yaygın olduğuna eminim.

Tecrübelerime göre, ++ i veya i ++, operatörün nasıl çalıştığını ilk öğrenmenin dışında hiçbir zaman karışıklığa neden olmamıştır. Operatörleri kullanabileceğiniz dillerde öğretilen herhangi bir lise veya kolej kursu tarafından verilen döngüler ve döngüler için en temel olanı esastır. Şahsen ben ayrı bir satırda bir ++ olmak ile bir şey daha iyi bakmak ve okumak için aşağıdaki gibi bir şey yapıyor bulmak.

while ( a < 10 ){
    array[a++] = val
}

Sonunda bir stil tercihi ve daha fazla bir şey değil, daha önemli olan, kodunuzda bunu yaptığınızda tutarlı kalmanız, böylece aynı kod üzerinde çalışan diğerlerinin takip edebilmesi ve aynı işlevselliği farklı şekillerde işlemek zorunda kalmamasıdır. .

Ayrıca, Crockford, okumak için --i veya i'den daha zor bulduğum i- = 1 kullanıyor gibi görünüyor.

İki sentim, iki durumda kaçınılması gerektiğidir:

1) Birçok satırda kullanılan bir değişkeniniz varsa ve bunu kullanan ilk deyimde (veya ortada en son, hatta daha da kötüsü) artırıp / azalttığınızda:

// It's Java, but applies to Js too
vi = list.get ( ++i );
vi1 = list.get ( i + 1 )
out.println ( "Processing values: " + vi + ", " + vi1 )
if ( i < list.size () - 1 ) ...

Bunun gibi örneklerde, değişkenin otomatik olarak artırıldığını / azaltıldığını veya hatta ilk ifadenin kaldırıldığını kolayca özleyebilirsiniz. Başka bir deyişle, yalnızca çok kısa bloklarda veya değişkenin blokta birkaç yakın ifadede göründüğü yerlerde kullanın.

2) Birden fazla ++ ve - aynı ifadede yaklaşık aynı değişken olması durumunda. Böyle durumlarda ne olduğunu hatırlamak çok zor:

result = ( ++x - --x ) * x++;

Sınavlar ve profesyonel testler yukarıdaki gibi örnekler soruyor ve gerçekten bunlardan biri hakkında belge ararken bu soruyu tökezledim, ancak gerçek hayatta tek bir kod satırı hakkında çok fazla düşünmek zorunda kalmamalıyım.

Fortran C benzeri bir dil midir? Ne ++ ne de - vardır. İşte size bir döngü yazma nasıl :

     integer i, n, sum

      sum = 0
      do 10 i = 1, n
         sum = sum + i
         write(*,*) 'i =', i
         write(*,*) 'sum =', sum
  10  continue

İndeks elemanı i , döngü boyunca her seferinde dil kuralları tarafından arttırılır. 1'den başka bir şeyle artırmak istiyorsanız, örneğin iki geriye doğru sayın, sözdizimi ...

      integer i

      do 20 i = 10, 1, -2
         write(*,*) 'i =', i
  20  continue

Python C benzeri mi? Bir dizini artırma gereksinimini atlamak için aralık ve liste kavrayışlarını ve diğer sözdizimlerini kullanır :

print range(10,1,-2) # prints [10,8.6.4.2]
[x*x for x in range(1,10)] # returns [1,4,9,16 ... ]

Dolayısıyla, tam olarak iki alternatifin bu ilk keşfine dayanarak, dil tasarımcıları ++ ve - kullanım durumlarını tahmin ederek ve alternatif bir sözdizimi sağlayarak önleyebilirler.

Fortran ve Python, ++ ve - içeren yordamsal dillerden önemli ölçüde daha az hata mıknatısı mıdır? Kanıtım yok.

Fortran ve Python'un C benzeri olduğunu iddia ediyorum çünkü% 90 doğrulukla akıcı olmayan biriyle tanışmamıştım, gizlenmemiş Fortran veya Python'un niyetini doğru tahmin ediyorlar.