Mengapa menghindari operator increment (“++”) dan decrement (“-”) di JavaScript?

Salah satu tips untuk alat jslint adalah:

++ dan -
The ++ (increment) dan - (decrement) operator telah dikenal berkontribusi pada kode buruk dengan mendorong trickiness yang berlebihan. Mereka adalah yang kedua setelah arsitektur yang salah dalam mengaktifkan virus dan ancaman keamanan lainnya. Ada opsi plusplus yang melarang penggunaan operator ini.

Saya tahu bahwa konstruksi PHP seperti $foo[$bar++]dapat dengan mudah dihasilkan dengan kesalahan satu per satu, tetapi saya tidak dapat menemukan cara yang lebih baik untuk mengontrol loop daripada a while( a < 10 ) do { /* foo */ a++; }atau for (var i=0; i<10; i++) { /* foo */ }.

Apakah jslint menyoroti mereka karena ada beberapa bahasa yang mirip yang tidak memiliki sintaksis " ++" dan " --" atau menanganinya secara berbeda, atau adakah alasan lain untuk menghindari " ++" dan " --" yang mungkin saya lewatkan?

Pandangan saya adalah untuk selalu menggunakan ++ dan - sendiri pada satu baris, seperti pada:

i++;
array[i] = foo;

dari pada

array[++i] = foo;

Apa pun di luar itu dapat membingungkan bagi beberapa programmer dan tidak sepadan dengan pandangan saya. Untuk loop adalah pengecualian, karena penggunaan operator increment bersifat idiomatis dan karenanya selalu jelas.

Terus terang saya bingung dengan saran itu. Sebagian dari saya bertanya-tanya apakah itu lebih berkaitan dengan kurangnya pengalaman (dirasakan atau aktual) dengan coders javascript.

Saya dapat melihat bagaimana seseorang hanya "meretas" beberapa kode sampel dapat membuat kesalahan yang salah dengan ++ dan -, tetapi saya tidak melihat mengapa seorang profesional yang berpengalaman akan menghindarinya.

Ada sejarah dalam C dalam melakukan hal-hal seperti:

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

untuk menyalin string, mungkin ini adalah sumber tipu daya berlebihan yang dia maksud.

Dan selalu ada pertanyaan tentang apa

++i = i++;

atau

i = i++ + ++i;

sebenarnya. Itu didefinisikan dalam beberapa bahasa, dan dalam bahasa lain tidak ada jaminan apa yang akan terjadi.

Selain contoh-contoh itu, saya tidak berpikir ada sesuatu yang lebih idiomatis daripada untuk loop yang digunakan ++untuk kenaikan. Dalam beberapa kasus Anda bisa lolos dengan loop foreach, atau loop sementara yang memeriksa kondisi yang berbeda. Tetapi memutarbalikkan kode Anda untuk mencoba dan menghindari penggunaan incrementing adalah konyol.

Jika Anda membaca JavaScript The Good Parts, Anda akan melihat bahwa pengganti Crockford untuk i ++ di dalam for loop adalah i + = 1 (bukan i = i + 1). Itu cukup bersih dan mudah dibaca, dan kecil kemungkinannya berubah menjadi sesuatu yang "rumit".

Crockford menjadikan penonaktifan autoincrement dan autodecrement sebagai opsi di jsLint. Anda memilih untuk mengikuti saran atau tidak.

Aturan pribadi saya adalah untuk tidak melakukan apa pun yang dikombinasikan dengan peningkatan otomatis atau penambahan otomatis.

Saya telah belajar dari pengalaman bertahun-tahun di C bahwa saya tidak mendapatkan buffer overruns (atau indeks array di luar batas) jika saya tetap menggunakannya sederhana. Tetapi saya telah menemukan bahwa saya mendapatkan buffer overruns jika saya jatuh dalam praktik "sangat rumit" melakukan hal-hal lain dalam pernyataan yang sama.

Jadi, untuk aturan saya sendiri, penggunaan i ++ sebagai kenaikan dalam for loop tidak masalah.

Dalam satu lingkaran itu tidak berbahaya, tetapi dalam pernyataan penugasan itu dapat menyebabkan hasil yang tidak terduga:

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

Spasi putih antara variabel dan operator dapat menyebabkan hasil yang tidak terduga juga:

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

Sebagai penutup, hasil yang tidak terduga juga bisa menjadi masalah:

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

Dan itu memicu penyisipan titik koma otomatis setelah baris baru:

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

kebingungan preincrement / postincrement dapat menghasilkan kesalahan satu per satu yang sangat sulit didiagnosis. Untungnya, mereka juga sama sekali tidak perlu. Ada cara yang lebih baik untuk menambahkan 1 ke variabel.

Referensi

• Bantuan JSLint: Operator Peningkatan dan Penurunan

Pertimbangkan kode berikut

    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++;

karena i ++ dievaluasi dua kali outputnya (dari vs2005 debugger)

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

Sekarang pertimbangkan kode berikut:

    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;

Perhatikan bahwa outputnya sama. Sekarang Anda mungkin berpikir bahwa ++ i dan i ++ adalah sama. Mereka tidak

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

Akhirnya pertimbangkan kode ini

    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++;

Outputnya sekarang:

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

Jadi mereka tidak sama, mencampur keduanya menghasilkan perilaku yang tidak begitu intuitif. Saya pikir untuk loop ok dengan ++, tapi hati-hati ketika Anda memiliki beberapa simbol ++ pada baris yang sama atau instruksi yang sama

Sifat operator "kenaikan" dan "kenaikan" yang cenderung cenderung membingungkan bagi mereka yang tidak terbiasa dengan mereka; itu salah satu cara di mana mereka bisa rumit.

Dalam pandangan saya, "Eksplisit selalu lebih baik daripada implisit." Karena pada titik tertentu, Anda mungkin bingung dengan pernyataan kenaikan ini y+ = x++ + ++y. Seorang programmer yang baik selalu membuat kodenya lebih mudah dibaca.

Alasan paling penting untuk menghindari ++ atau - adalah bahwa operator mengembalikan nilai dan menyebabkan efek samping pada saat yang sama, membuatnya lebih sulit untuk beralasan tentang kode.

Demi efisiensi, saya lebih suka:

• ++ i ketika tidak menggunakan nilai kembali (tidak sementara)
• i ++ saat menggunakan nilai kembali (tidak ada pipeline)

Saya penggemar Mr. Crockford, tetapi dalam hal ini saya harus tidak setuju. ++iadalah 25% lebih sedikit teks untuk diurai daripada i+=1 dan bisa dibilang lebih jelas.

Saya sudah menonton video Douglas Crockford tentang ini dan penjelasannya untuk tidak menggunakan kenaikan dan penurunan adalah itu

1. Ini telah digunakan di masa lalu dalam bahasa lain untuk mematahkan batasan array dan menyebabkan semua perilaku kejahatan dan
2. Itu lebih membingungkan dan tidak berpengalaman pengembang JS tidak tahu persis apa yang dilakukannya.

Array pertama dalam JavaScript berukuran secara dinamis dan karenanya, maafkan saya jika saya salah, tidak mungkin untuk melanggar batas array dan mengakses data yang tidak boleh diakses menggunakan metode ini dalam JavaScript.

Kedua, haruskah kita menghindari hal-hal yang rumit, yang pasti masalahnya bukan kita memiliki fasilitas ini tetapi masalahnya adalah ada pengembang di luar sana yang mengklaim melakukan JavaScript tetapi tidak tahu cara kerja operator ini ?? Cukup sederhana. nilai ++, beri saya nilai saat ini dan setelah ekspresi tambahkan satu untuk itu, nilai ++, tambahkan nilai sebelum memberi saya itu.

Ekspresi seperti +++ ++ b, mudah dikerjakan jika Anda hanya mengingat yang di atas.

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

Saya kira Anda baru saja ingat siapa yang harus membaca kode, jika Anda memiliki tim yang tahu JS dalam ke luar maka Anda tidak perlu khawatir. Jika tidak maka komentari, tulis berbeda, dll. Lakukan apa yang harus Anda lakukan. Saya tidak berpikir peningkatan dan penurunan pada dasarnya buruk atau menghasilkan bug, atau menciptakan kerentanan, mungkin hanya sedikit terbaca tergantung pada audiens Anda.

Ngomong-ngomong, kupikir Douglas Crockford adalah legenda, tapi kupikir dia menyebabkan banyak ketakutan pada operator yang tidak pantas mendapatkannya.

Saya hidup untuk terbukti salah ...

Contoh lain, lebih sederhana daripada yang lainnya dengan pengembalian sederhana dengan nilai tambah:

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

Seperti yang Anda lihat, tidak ada kenaikan / penurunan pasca harus digunakan pada pernyataan kembali, jika Anda ingin operator ini mempengaruhi hasilnya. Tetapi pengembalian tidak "menangkap" operator pasca kenaikan / penurunan:

function closureIncrementTest() {
    var x = 0;

    function postIncrementX() {
        return x++;
    }

    var y = postIncrementX();

    console.log(x); // 1
}

Saya pikir programmer harus kompeten dalam bahasa yang mereka gunakan; gunakan dengan jelas; dan gunakan dengan baik. Saya tidak berpikir mereka harus melumpuhkan bahasa yang mereka gunakan secara artifisial. Saya berbicara dari pengalaman. Saya pernah bekerja secara harfiah di sebelah toko Cobol di mana mereka tidak menggunakan ELSE 'karena terlalu rumit'. Reductio ad absurdam.

Seperti disebutkan dalam beberapa jawaban yang ada (yang mengganggu saya tidak dapat mengomentari), masalahnya adalah bahwa x ++ ++ x mengevaluasi nilai yang berbeda (sebelum vs setelah kenaikan), yang tidak jelas dan dapat sangat membingungkan - jika nilai itu digunakan. cdmckay menyarankan dengan bijak untuk memungkinkan penggunaan operator kenaikan, tetapi hanya dengan cara yang nilai yang dikembalikan tidak digunakan, misalnya pada barisnya sendiri. Saya juga akan menyertakan penggunaan standar dalam loop for (tetapi hanya dalam pernyataan ketiga, yang nilai kembaliannya tidak digunakan). Saya tidak bisa memikirkan contoh lain. Telah "dibakar" sendiri, saya akan merekomendasikan pedoman yang sama untuk bahasa lain juga.

Saya tidak setuju dengan klaim bahwa ini terlalu ketat karena banyak programmer JS yang tidak berpengalaman. Ini adalah jenis penulisan yang tepat khas dari programmer "terlalu pintar", dan saya yakin itu jauh lebih umum dalam bahasa yang lebih tradisional dan dengan pengembang JS yang memiliki latar belakang dalam bahasa tersebut.

Dalam pengalaman saya, ++ i atau i ++ tidak pernah menyebabkan kebingungan selain ketika pertama kali belajar tentang cara kerja operator. Sangat penting untuk loop paling dasar dan loop sementara yang diajarkan oleh kursus sekolah menengah atau perguruan tinggi yang diajarkan dalam bahasa di mana Anda dapat menggunakan operator. Saya pribadi menemukan melakukan sesuatu seperti apa di bawah ini untuk melihat dan membaca lebih baik daripada sesuatu dengan ++ berada di baris terpisah.

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

Pada akhirnya ini adalah preferensi gaya dan bukan apa-apa lagi, yang lebih penting adalah bahwa ketika Anda melakukan ini dalam kode Anda, Anda tetap konsisten sehingga orang lain yang bekerja pada kode yang sama dapat mengikuti dan tidak harus memproses fungsi yang sama dengan cara yang berbeda. .

Juga, Crockford tampaknya menggunakan i- = 1, yang menurut saya lebih sulit dibaca daripada --i atau i--

2 sen saya adalah bahwa mereka harus dihindari dalam dua kasus:

1) Ketika Anda memiliki variabel yang digunakan di banyak baris dan Anda menambah / menguranginya pada pernyataan pertama yang menggunakannya (atau terakhir, atau, lebih buruk lagi, di tengah):

// 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 ) ...

Dalam contoh-contoh seperti ini, Anda dapat dengan mudah kehilangan bahwa variabel bertambah / dikurangi secara otomatis atau bahkan menghapus pernyataan pertama. Dengan kata lain, gunakan hanya di blok yang sangat pendek atau di mana variabel muncul di blok hanya pada beberapa pernyataan dekat.

2) Dalam kasus multiple ++ dan - tentang variabel yang sama dalam pernyataan yang sama. Sangat sulit untuk mengingat apa yang terjadi dalam kasus-kasus seperti ini:

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

Ujian dan tes profesional bertanya tentang contoh-contoh seperti di atas dan memang saya telah menemukan pertanyaan ini sambil mencari dokumentasi tentang salah satunya, tetapi dalam kehidupan nyata orang tidak boleh dipaksa untuk berpikir banyak tentang satu baris kode.

Apakah Fortran bahasa seperti-C? Ini tidak memiliki ++ atau -. Inilah cara Anda menulis loop :

     integer i, n, sum

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

Elemen indeks i bertambah oleh aturan bahasa setiap kali melalui loop. Jika Anda ingin bertambah dengan sesuatu selain 1, hitung mundur dua misalnya, sintaksnya adalah ...

      integer i

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

Apakah seperti Python C? Ini menggunakan rentang dan daftar pemahaman dan sintaksis lain untuk memotong kebutuhan untuk meningkatkan indeks:

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

Jadi berdasarkan eksplorasi dasar dari dua alternatif ini, perancang bahasa dapat menghindari ++ dan - dengan mengantisipasi kasus penggunaan dan memberikan sintaksis alternatif.

Apakah Fortran dan Python memiliki magnet bug lebih sedikit daripada bahasa prosedural yang memiliki ++ dan -? Saya tidak punya bukti.

Saya mengklaim bahwa Fortran dan Python adalah seperti-C karena saya belum pernah bertemu seseorang yang fasih dalam C yang tidak bisa dengan akurasi 90% menebak dengan benar maksud dari Fortran atau Python yang tidak dikaburkan.