ES6'da 'let' vs 'const'ı ne kadar kullanmalıyım?

Son zamanlarda io.js için bir sürü ES6 kodu yazıyorum. Doğada öğrenilecek çok fazla kod yok, bu yüzden kendi sözleşmelerimi giderken tanımladığımı hissediyorum.

Benim sorum ne zaman constvs kullanılacağı ile ilgili let.

Bu kuralı uyguluyorum: Mümkünse, kullanın const. Sadece letdeğerinin değişmesi gerektiğini biliyorsanız kullanın . (Her zaman geri dönebilir ve a'yı bir a constile değiştirebilir ve letdaha sonra değerini değiştirmeniz gerekir.

Bu kuralın ana nedeni, tutarlı bir şekilde uygulanması kolaydır. Gri alan yok.

Mesele şu ki, bu kuralı uyguladığımda pratikte beyanlarımın% 95'i const. Bu bana çok garip geldi. Sadece kullanıyorum letgibi şeyler için ibir de for(gerçek hayatta çok gelip etmeyen) birikmiş Fibonacci toplamları gibi şeyler için zaman zaman döngü veya. Buna şaşırdım - ES5 kodumdaki "değişkenlerin"% 95'inin değişmeyen değerler için olduğu ortaya çıktı. Ama kodumun consther yerini görmek bir şekilde yanlış geliyor.

Öyleyse sorum şu: constbu kadarını kullanmak tamam mı? Gerçekten böyle şeyler yapmalı mıyım const foo = function () {...};?

Ya da constbir modülün tepesinde bir değişmezi kodladığınız durumlarda - örneğin büyük harflerle yaptığınız gibi - böyle const MARGIN_WIDTH = 410;mi?

Buradaki cevabım javascript'e özgü değil.

Bunu yarı kolay bir şekilde yapmamı sağlayan herhangi bir dilde bir kural olarak, her zaman mümkünse dilinizde ne denirse const / final / readonly / 'i kullanın. Sebep basittir, neyin değişebileceği ve neyin değişmeyeceği belli olmadığı zaman kodla ilgili sebepler çok daha kolaydır. Buna ek olarak, birçok dilde, yanlışlıkla const olarak ilan ettiğiniz bir değişkene atadığınızda, yanlış bir şey yaptığınızı söyleyen araç desteği alabilirsiniz.

Geri dönüp bir kursa izin vermek çok kolaydır. Ve varsayılan olarak const gitmeden önce iki kez düşünmenizi sağlar. Ve bu çoğu durumda iyi bir şeydir.

Beklenmedik şekilde değişen değişkenleri içeren kaç hata gördünüz? Çok fazla tahmin ediyorum. Gördüğüm hataların çoğunun beklenmeyen durum değişimlerini içerdiğini biliyorum. Tüm bu hataları liberal bir şekilde const kullanarak kurtulmayacaksın, ama birçoğundan kurtulacaksın!

Ayrıca, birçok işlevsel dil, tüm değişkenlerin varsayılan olarak const olduğu değişken değişkenlere sahiptir. Erlang'a bakınız, örneğin ya da F #. Atama olmadan kodlama bu dillerde mükemmel çalışır ve insanların işlevsel programlamayı sevmelerinin birçok nedeninden biridir. Daha iyi bir programcı olmak için bu dillerden devleti yönetme hakkında çok şey var.

Ve her şey const ile son derece liberal olmakla başlar! ;) Yazmak için iki karakter daha yazalım, o yüzden devam et ve consther şey!

Dikkat edin, çünkü constnesne tuşları değişkendir.

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

nesne anahtarları korunmuyor

bu örneği düşünün:

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

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

Diziler için aynı şey:

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

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

Tamamen kendime karar vermedim, ancak consttüm dizi / nesne olmayan nesneler letiçin kullanmayı ve nesneler / diziler için kullanmayı düşünüyorum .

Endişelenme. constJavaScript’e harika bir eklenti ve mantıklı olan her yerde kullanmanızı tavsiye ederim. Daha sağlam kod için yapar.

Nesneler söz konusu olduğunda constdeğişkeninizi yeniden atamadan koruyacaktır, ancak değişmez nesnelere ihtiyacınız varsa, Object.freezeyönteme ihtiyacınız olacaktır , aşağıya bakın.

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

constyalnızca yeniden atamadan koruyacak ve freezeyöntem tüm anında özellikleri koruyacaktır. Bütün iç içe geçmiş özelliklerin de değişmez olması gerekiyorsa, freezebunları tekrar tekrar yapmanız gerekir .

Benim içinde ES6 constdeğişmezlik ilgili değil yazı, ne açıklamak constspec göre tam demektir.

Bu nesnel gerçeklere dayanarak, benim kişisel tercihim:

[…] ES6 kodunuzda kullanımı letve constaşağıdakileri mantıklı kılar :

• kullanmak constvarsayılan olarak
• yalnızca letyeniden bağlama (yani herhangi bir yeniden atama şekli) gerektiğinde kullanın
• ( varES6'da kullanılmamalıdır)

Olması gerektiği gibi öznel, bunun spec'in amacına en yakın olduğu bir gerçektir.

letVarsayılan olarak kullanan insanlar genellikle constdeğişkenleri sabit olarak görürler (ki bu zorunlu değil, tasarım gereğidir!). Her biri kendilerine göre, ancak amaçları amaçlarına göre kullanmayı tercih ediyorum, insanlar yanlış anlaşmaya dayanarak oluşturdukları bazı anlamlar için değil.

Kullanılması constsabitleri için sadece kullanmak gibidir HTML <aside>elemanı sadece yan çubuğu içeriği için.

Benim kişisel yaklaşımım, kodların okunabilirliği ve anlaşılmasına yardımcı olduğu düşüncesi:

letyalnızca kısa ömürlü değişkenler içindir, tek bir satırda tanımlanır ve sonra değiştirilmez. Genellikle sadece yazma miktarını azaltmak için var olan değişkenler. Örneğin:

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]
  ...
}

consttüm modül boyunca sabit olduğu bilinen tüm isimler için. Yerel olarak sabit değerler dahil değil. valueYukarıdaki örnekte, örneğin, kapsamı içinde sabittir ve ile ilan edilerek const, ancak birçok iterasyon vardır ve her biri için orada aynı olan bir değer olduğundan ismi , "değer" düşünce içine, o okuyucu yanıltabilirsiniz valueher zaman aynısı. Modüller ve fonksiyonlar constdeğişkenlerin en iyi örneğidir :

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

vardeğişken olan veya olmayan her şey için. Yerel olarak sabit olsalar bile let(ve basit bir doğrudan beyanda tamamlanmadıysa) uygun olmayan (yani basit bir doğrudan beyanda tamamlanmadı) bile, insanları kodları okuyanlarla karıştırabilecek isimler beyan edilmek için uygulanır var. Örneğin:

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
}

Daha yorum ve gelecekteki olası güncellemeleri burada .

JavaScript, değişkenler fonksiyonlar ve bunun gibi olabileceği için biraz özeldir, ancak C #, Java veya başka bir C tarzı dilde düşünün:

const public void DoSomething()

Bu constgarip ve bu nedenle bu dillerdeki yöntem bildirimleri değişemez, başka bir şey haline getirildikten sonra, ne olursa olsun (var olabilecek bazı korkunç saldırıları gözardı ederek) yaptıkları budur.

JavaScript neden farklı olsun ki? Bu yüzden derlenmedi, ama bu derleyicilerin sağlayabileceği güvenliği ortadan kaldırmamız gerektiği anlamına gelmiyor. constAnahtar kelimeyi kullanmak bize daha fazla güvenlik sağlar, bu da kesinlikle daha sağlam uygulamalara yol açacaktır.