Berapa saya harus menggunakan 'let' vs 'const' di ES6?

Saya telah menulis banyak kode ES6 untuk io.js baru-baru ini. Tidak ada banyak kode di alam liar untuk dipelajari, jadi saya merasa seperti saya mendefinisikan konvensi saya sendiri ketika saya pergi.

Pertanyaan saya adalah tentang kapan harus menggunakan constvs let.

Saya telah menerapkan aturan ini: Jika memungkinkan, gunakan const. Hanya gunakan letjika Anda tahu nilainya perlu diubah. (Anda selalu dapat kembali dan mengubah constke letjika nanti ternyata Anda perlu mengubah nilainya.)

Alasan utama aturan ini adalah mudah untuk diterapkan secara konsisten. Tidak ada area abu-abu.

Masalahnya adalah, ketika saya menerapkan aturan ini, dalam praktiknya 95% dari deklarasi saya adalah const. Dan ini terlihat aneh bagiku. Saya hanya menggunakan letuntuk hal-hal seperti idalam satu forlingkaran, atau kadang-kadang untuk hal-hal seperti akumulasi total Fibonacci (yang tidak banyak muncul dalam kehidupan nyata). Saya terkejut dengan ini - ternyata 95% dari 'variabel' dalam kode ES5 saya saat ini adalah untuk nilai-nilai yang tidak bervariasi. Tetapi melihat constseluruh kode saya terasa salah.

Jadi pertanyaan saya adalah: apakah boleh menggunakan constsebanyak ini? Haruskah saya benar-benar melakukan hal-hal seperti const foo = function () {...};?

Atau haruskah saya memesan constuntuk situasi-situasi di mana Anda membuat kode literal di bagian atas modul - seperti yang Anda lakukan dengan huruf besar, seperti const MARGIN_WIDTH = 410;?

Balasan saya di sini tidak spesifik javascript.

Sebagai aturan praktis dalam bahasa apa pun yang memungkinkan saya melakukannya dengan cara semi-mudah saya akan mengatakan selalu menggunakan const / final / readonly / apa pun namanya dalam bahasa Anda bila memungkinkan. Alasannya sederhana, jauh lebih mudah untuk alasan tentang kode ketika sudah jelas apa yang bisa berubah dan apa yang tidak bisa berubah. Dan selain itu, dalam banyak bahasa Anda bisa mendapatkan dukungan alat yang memberi tahu Anda bahwa Anda melakukan sesuatu yang salah ketika Anda secara tidak sengaja menetapkan ke variabel yang telah Anda nyatakan sebagai const.

Kembali dan mengubah const ke let adalah mati sederhana. Dan menjadi const secara default membuat Anda berpikir dua kali sebelum melakukannya. Dan dalam banyak hal ini adalah hal yang baik.

Berapa banyak bug yang Anda lihat yang melibatkan variabel berubah secara tak terduga? Saya banyak menebak. Saya tahu bahwa sebagian besar bug yang saya lihat melibatkan perubahan status yang tidak terduga. Anda tidak akan menghilangkan semua bug ini dengan bebas menggunakan const, tetapi Anda akan menyingkirkan banyak dari mereka!

Juga, banyak bahasa fungsional memiliki variabel tidak berubah di mana semua variabel adalah konst secara default. Lihatlah Erlang misalnya, atau F #. Pengodean tanpa penugasan bekerja dengan sempurna dalam bahasa-bahasa ini dan merupakan salah satu dari banyak alasan mengapa orang menyukai pemrograman fungsional. Ada banyak yang harus dipelajari dari bahasa-bahasa ini tentang mengelola negara agar menjadi programmer yang lebih baik.

Dan itu semua dimulai dengan menjadi sangat liberal dengan const! ;) Ini hanya dua karakter untuk ditulis dibandingkan dengan membiarkan, jadi lanjutkan dan constsemua hal!

Hati-hati, karena constkunci objek bisa berubah.

Dari sini: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

kunci objek tidak terlindungi

pertimbangkan contoh ini:

const colors = {red: "#f00"}; 
console.log(colors); // { "red": "#f00" }

colors.red = "#00f";
colors.green = "#0f0";
console.log(colors); // { "red": "#00f", "green": "#0f0" }

Hal yang sama untuk array:

const numbers = [1, 2, 3];
console.log(numbers); // [ 1, 2, 3 ]

numbers.push(4);
console.log(numbers); // [ 1, 2, 3, 4 ]

Saya belum memutuskan sepenuhnya sendiri, tapi saya mempertimbangkan constuntuk menggunakan untuk semua non-array / non-objek dan digunakan letuntuk objek / array.

Jangan khawatir tentang itu. constadalah tambahan yang luar biasa untuk JavaScript, dan saya akan merekomendasikan Anda menggunakannya semua tempat yang masuk akal. Itu membuat kode lebih kuat.

Ketika datang ke objek, constakan melindungi variabel Anda dari penugasan kembali, tetapi jika Anda membutuhkan objek abadi, Anda akan memerlukan Object.freezemetode, lihat di bawah.

const immutableOject = Object.freeze({immutableProperty: 'foo'});

consthanya akan melindungi dari penugasan kembali, dan freezemetode ini akan melindungi semua properti langsung. Jika Anda membutuhkan semua properti bersarang agar tidak berubah juga, maka Anda harus secara rekursif freeze.

Dalam ES6const saya bukan tentang post immutability , saya jelaskan apa constartinya persis menurut spec.

Berdasarkan fakta-fakta obyektif itu, inilah preferensi pribadi saya:

[...] masuk akal untuk menggunakan letdan constsebagai berikut dalam kode ES6 Anda:

• gunakan constsecara default
• hanya digunakan letjika rebinding (yaitu segala bentuk penugasan kembali) diperlukan
• ( vartidak boleh digunakan dalam ES6)

Meskipun subjektif, itu fakta bahwa ini paling dekat dengan maksud spec.

Orang-orang yang menggunakan letsecara default biasanya memperlakukan constvariabel sebagai konstanta (yang tidak harus, dengan desain!). Untuk masing-masing mereka sendiri, tetapi saya lebih suka menggunakan hal-hal untuk tujuan yang mereka maksudkan, dan bukan untuk beberapa makna yang dibuat-buat orang ditugaskan kepadanya berdasarkan kesalahpahaman.

Menggunakan consthanya untuk konstanta seperti menggunakan elemen HTML<aside> hanya untuk konten bilah samping.

Pendekatan pribadi saya, berpikir untuk membantu pembacaan dan pemahaman kode:

lethanya untuk variabel berumur pendek, didefinisikan pada satu baris dan tidak berubah setelahnya. Secara umum variabel-variabel yang ada hanya mengurangi jumlah pengetikan. Sebagai contoh:

for (let key in something) {
  /* we could use `something[key]` for this entire block,
     but it would be too much letters and not good for the
     fingers or the eyes, so we use a radically temporary variable
  */
  let value = something[key]
  ...
}

constuntuk semua nama yang diketahui konstan di seluruh modul. Tidak termasuk nilai konstan lokal. Dalam valuecontoh di atas, misalnya, konstan dalam cakupannya dan dapat dideklarasikan dengan const, tetapi karena ada banyak iterasi dan untuk masing-masing ada nilai dengan nama yang sama , "nilai", yang dapat menipu pembaca agar berpikir valueselalu sama. Modul dan fungsi adalah contoh terbaik dari constvariabel:

const PouchDB = require('pouchdb')
const instantiateDB = function () {}
const codes = {
  23: 'atc',
  43: 'qwx',
  77: 'oxi'
}

varuntuk segala sesuatu yang mungkin atau tidak variabel. Nama-nama yang dapat membingungkan orang-orang yang membaca kode, meskipun mereka konstan secara lokal, dan tidak cocok untuk let(yaitu, mereka tidak dilengkapi dalam deklarasi langsung sederhana) berlaku untuk dideklarasikan dengan var. Sebagai contoh:

var output = '\n'
lines.forEach(line => {
  output += '  '
  output += line.trim()
  output += '\n'
})
output += '\n---'

for (let parent in parents) {
  var definitions = {}
  definitions.name = getName(parent)
  definitions.config = {}
  definitions.parent = parent
}

Komentar lebih lanjut dan kemungkinan pembaruan di masa depan di sini .

JavaScript agak spesial karena variabel dapat berupa fungsi dan semacamnya, tetapi pertimbangkan dalam C #, Java atau bahasa gaya C serupa lainnya:

const public void DoSomething()

The constaneh, dan itu karena deklarasi metode dalam bahasa ini tidak bisa berubah, begitu mereka dikompilasi ke dalam sesuatu yang lain, yaitu apa yang mereka lakukan, tidak peduli apa (mengabaikan beberapa hacks mengerikan yang mungkin ada).

Mengapa JavaScript harus berbeda? Jadi itu tidak dikompilasi, tetapi itu tidak berarti kita harus membuang keamanan yang dapat diberikan oleh kompiler. Menggunakan constkata kunci memberi kita lebih banyak keamanan, yang tentunya akan mengarah pada aplikasi yang lebih kuat.