ÔÇťLetÔÇŁ ve ÔÇťvarÔÇŁ kullanmak aras─▒ndaki fark nedir?


Al─▒nan cevaba git


ECMAScript 6 tan─▒t─▒ld─▒ deyimi . let

Bunun "yerel" bir de─či┼čken olarak tan─▒mland─▒─č─▒n─▒ duydum, ancak var anahtar kelimeden nas─▒l farkl─▒ davrand─▒─č─▒n─▒ hala tam olarak bilmiyorum .

Farkl─▒l─▒klar nedir? Ne zaman let kullan─▒lmal─▒ var ?


4114





2009-04-17




Cevap say─▒s─▒n─▒ say: 30






Kapsam kurallar─▒

Temel fark, kapsam kurallar─▒. var Anahtar s├Âzc├╝kle bildirilen de─či┼čkenler hemen i┼člev g├Âvdesine (dolay─▒s─▒yla i┼člev kapsam─▒na), let de─či┼čkenler taraf─▒ndan g├Âsterilen hemen i├žine alan blo─ča i┼čaretlenir (bu nedenle de i┼člev { } kapsam─▒).

 function run() {
  var foo = "Foo";
  let bar = "Bar";

  console.log(foo, bar);

  {
    let baz = "Bazz";
    console.log(baz);
  }

  console.log(baz); // ReferenceError
}

run();
 

let Anahtar s├Âzc├╝─č├╝n dile tan─▒t─▒lmas─▒n─▒n nedeni kapsam kapsam─▒ kafa kar─▒┼čt─▒r─▒c─▒yd─▒ ve javascript'teki ana hata kaynaklar─▒ndan biriydi.

Bu ├Ârne─če ba┼čka bir stackoverflow sorusundan bak─▒n :

 var funcs = [];
// let's create 3 functions
for (var i = 0; i < 3; i++) {
  // and store them in funcs
  funcs[i] = function() {
    // each should log its value.
    console.log("My value: " + i);
  };
}
for (var j = 0; j < 3; j++) {
  // and now let's run each one to see
  funcs[j]();
}
 

My value: 3 her seferinde konsola ├ž─▒kt─▒ verildi funcs[j](); , ├ž├╝nk├╝ ads─▒z i┼člevler ayn─▒ de─či┼čkene ba─čl─▒yd─▒.

─░nsanlar d├Âng├╝lerden do─čru de─čeri elde etmek i├žin hemen ├ža─čr─▒lan i┼člevler olu┼čturmak zorunda kald─▒lar ancak bu ayn─▒ zamanda k─▒ll─▒yd─▒.

kald─▒rma

var Anahtar kelime ile bildirilen de─či┼čkenler , blo─čun ├╝st k─▒sm─▒na "kald─▒r─▒lm─▒┼č" olmas─▒na ra─čmen, ilan edilmeden ├Ânce bile, kapsamlar─▒nda eri┼čilebilir olduklar─▒ anlam─▒na gelir:

 function run() {
  console.log(foo); // undefined
  var foo = "Foo";
  console.log(foo); // Foo
}

run();
 

tan─▒mlar─▒ de─čerlendirilinceye kadar de─či┼čkenlerin ba┼člat─▒lmamas─▒na izin verin. Ba┼člatmadan ├Ânce bunlara eri┼čmek, a ile sonu├žlan─▒r ReferenceError . De─či┼čken, ba┼člang─▒├ž ÔÇőÔÇői┼člemine kadar blo─čun ba┼člang─▒c─▒ndan "ge├žici ├Âl├╝ b├Âlge" i├žinde oldu─ču s├Âylenir.

 function checkHoisting() {
  console.log(foo); // ReferenceError
  let foo = "Foo";
  console.log(foo); // Foo
}

checkHoisting();
 

Global nesne ├Âzelli─či olu┼čturma

En ├╝st d├╝zeyde, let aksine var , global nesne ├╝zerinde bir ├Âzellik olu┼čturmaz:

 var foo = "Foo";  // globally scoped
let bar = "Bar"; // globally scoped

console.log(window.foo); // Foo
console.log(window.bar); // undefined
 

yeniden bildirilmi┼č

S─▒k─▒ modda, bir SyntaxError y├╝kseltirken var ayn─▒ de─či┼čkeni ayn─▒ kapsamda yeniden bildirmenize izin verir let .

 'use strict';
var foo = "foo1";
var foo = "foo2"; // No problem, 'foo' is replaced.

let bar = "bar1";
let bar = "bar2"; // SyntaxError: Identifier 'bar' has already been declared
 

5600







let kapama problemlerini ├Ânlemek i├žin de kullan─▒labilir. A┼ča─č─▒daki ├Ârneklerde g├Âsterildi─či gibi eski bir referans─▒ tutmak yerine, taze de─čeri ba─člar.

 for(var i=1; i<6; i++) {
  $("#div" + i).click(function () { console.log(i); });
} 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div id="div1">1</div>
<div id="div2">2</div>
<div id="div3">3</div>
<div id="div4">4</div>
<div id="div5">5</div> 

Yukar─▒daki kod klasik bir JavaScript kapatma problemini g├Âstermektedir. i De─či┼čkene yap─▒lan ba┼čvuru , ger├žek de─čeri yerine, t─▒klama i┼čleyicisi kapan─▒┼č─▒nda saklan─▒yor i .

Her bir t─▒klama i┼čleyicisi ayn─▒ nesneye ba┼čvurur ├ž├╝nk├╝ 6'y─▒ tutan tek bir saya├ž nesnesi vard─▒r, b├Âylece her t─▒klamada alt─▒ puan al─▒rs─▒n─▒z.

Genel bir ge├žici ├ž├Âz├╝m, bunu ads─▒z bir i┼čleve sarmak ve i bir arg├╝man olarak iletmektir. Bu konular da kullanarak art─▒k ├Ânlenebilir let yerine var a┼ča─č─▒da kodda g├Âsterildi─či.

(Chrome ve Firefox 50'de test edilmi┼čtir)

 for(let i=1; i<6; i++) {
  $("#div" + i).click(function () { console.log(i); });
} 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div id="div1">1</div>
<div id="div2">2</div>
<div id="div3">3</div>
<div id="div4">4</div>
<div id="div5">5</div> 


568







Aras─▒ndaki fark nedir let ve var ?

  • Bir ifade kullan─▒larak tan─▒mlanan de─či┼čken , fonksiyonun ba┼člang─▒c─▒ndan itibaren tan─▒mland─▒─č─▒ fonksiyon var boyunca bilinir . *
  • Bir kullan─▒larak tan─▒mlanan bir de─či┼čken let deyimi sadece bilinen blo─čunun bunun ileriye tan─▒mlan─▒r andan itibaren, bu tan─▒mlanm─▒┼čt─▒r. **

Fark─▒ anlamak i├žin a┼ča─č─▒daki kodu g├Âz ├Ân├╝nde bulundurun:

 // i IS NOT known here
// j IS NOT known here
// k IS known here, but undefined
// l IS NOT known here

function loop(arr) {
    // i IS known here, but undefined
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( var i = 0; i < arr.length; i++ ) {
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( let j = 0; j < arr.length; j++ ) {
        // i IS known here, and has a value
        // j IS known here, and has a value
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here
}

loop([1,2,3,4]);

for( var k = 0; k < arr.length; k++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
};

for( let l = 0; l < arr.length; l++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS known here, and has a value
};

loop([1,2,3,4]);

// i IS NOT known here
// j IS NOT known here
// k IS known here, and has a value
// l IS NOT known here
 

Burada, de─či┼čkenimizin j sadece ilki i├žin ilk ├Ânce bilindi─čini ancak ├Ânce ve sonra bilinmedi─čini g├Ârebiliriz . Yine de de─či┼čkenimiz i t├╝m fonksiyonda bilinmektedir.

Ayr─▒ca, blok kapsam─▒ndaki de─či┼čkenlerin ilan edilmeden ├Ânce bildirilmedi─činden bilinmedi─čini unutmay─▒n. Ayn─▒ blok i├žinde ayn─▒ blok kapsam─▒ de─či┼čkenini yeniden bildirmenize de izin verilmez. Bu, blok kapsam─▒ndaki de─či┼čkenleri, genel olarak veya fonksiyon kapsam─▒ndaki de─či┼čkenlere g├Âre daha az hataya e─čilimli k─▒lar; bunlar, kald─▒r─▒lm─▒┼č ve birden fazla bildirim durumunda herhangi bir hata ├╝retmez.


let Bug├╝n kullanmak g├╝venli mi?

Baz─▒ insanlar ileride SADECE let ifadelerini kullanaca─č─▒m─▒z─▒ ve var ifadelerinin eski olaca─č─▒n─▒ savunurlar. JavaScript gurusu Kyle Simpson , neden b├Âyle olmayaca─č─▒na inand─▒─č─▒na dair ├žok ayr─▒nt─▒l─▒ bir makale yazd─▒ .

Bug├╝n ise, bu kesinlikle b├Âyle de─čil. Asl─▒nda, let ifadeyi kullanman─▒n g├╝venli olup olmad─▒─č─▒n─▒ kendimize sormam─▒z gerekiyor . Bu sorunun cevab─▒ ortam─▒n─▒za ba─čl─▒d─▒r:

  • Sunucu taraf─▒ JavaScript kodu ( Node.js ) yaz─▒yorsan─▒z, let bildirimi g├╝venle kullanabilirsiniz .

  • ─░stemci taraf─▒ JavaScript kodu yaz─▒yorsan─▒z ve taray─▒c─▒ tabanl─▒ bir aktar─▒c─▒ kullan─▒yorsan─▒z ( Traceur veya babel-ba─č─▒ms─▒z ) gibi bir let ifade kullan─▒yorsan─▒z, ancak kodunuz performans a├ž─▒s─▒ndan en uygun olan─▒ olabilir.

  • ─░stemci taraf─▒ JavaScript kodu yaz─▒yorsan─▒z ve D├╝─č├╝m tabanl─▒ bir transpiler kullan─▒yorsan─▒z ( traceur kabu─ču beti─či veya Babel gibi ), let ifadeyi g├╝venle kullanabilirsiniz . Taray─▒c─▒n─▒z yaln─▒zca aktar─▒lan kodu bildi─činden, performans─▒n sak─▒ncal─▒ olmas─▒ s─▒n─▒rl─▒ olmal─▒d─▒r.

  • ─░stemci taraf─▒ JavaScript kodu yaz─▒yorsan─▒z ve bir aktar─▒c─▒ kullanm─▒yorsan─▒z, taray─▒c─▒ deste─čini g├Âz ├Ân├╝nde bulundurman─▒z gerekir.

    Hala desteklemeyen baz─▒ taray─▒c─▒lar var let :


Destek tablosu


Taray─▒c─▒ deste─čini nas─▒l takip edersiniz?

let Bu yan─▒t─▒ okudu─čunuz s─▒rada hangi taray─▒c─▒lar─▒n a├ž─▒klamay─▒ destekledi─čine dair genel bir bak─▒┼č i├žin bu Can I Use sayfaya bak─▒n .


* K├╝resel ve i┼člevsel olarak kapsam dahilindeki de─či┼čkenler, bildirilmeden ├Ânce ba┼člat─▒labilir ve kullan─▒labilir ├ž├╝nk├╝ JavaScript de─či┼čkenleri kald─▒r─▒lm─▒┼čt─▒r . Bu, bildirimlerin her zaman kapsam─▒n en ├╝st├╝nde oldu─ču anlam─▒na gelir.

** Blok kapsam─▒ndaki de─či┼čkenler kald─▒r─▒lmaz


151







─░┼čte baz─▒ ├Ârnekler ile anahtar kelimenin bir a├ž─▒klamas─▒ let .

let ├žok benziyor var . Ana fark, bir var de─či┼čkenin kapsam─▒n─▒n t├╝m ├ževreleme i┼člevi olmas─▒d─▒r.

http://en.wikipedia.org/wiki/JavaScript%23Version_history#Version_historyWikipedia'daki bu tablo hangi taray─▒c─▒lar─▒n Javascript 1.7'yi destekledi─čini g├Âsterir.

Yaln─▒zca Mozilla ve Chrome taray─▒c─▒lar─▒n─▒n destekledi─čini unutmay─▒n. IE, Safari ve potansiyel olarak di─čerleri yoktur.


143







Kabul edilen cevapta bir nokta eksik:

 {
  let a = 123;
};

console.log(a); // ReferenceError: a is not defined
 

108







let

Blok kapsam─▒

let Anahtar kelime kullan─▒larak bildirilen de─či┼čkenler blok kapsaml─▒d─▒r ve bu, yaln─▒zca bildirildikleri blokta kullan─▒labilir olduklar─▒ anlam─▒na gelir .

├ťst seviyede (bir fonksiyonun d─▒┼č─▒nda)

En ├╝st d├╝zeyde, kullanarak bildirilen de─či┼čkenler let global nesnede ├Âzellik olu┼čturmaz.

 var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined
 

Bir fonksiyonun i├žinde

Bir i┼člevin i├žinde (ancak bir blo─čun d─▒┼č─▒nda), let ayn─▒ kapsamdad─▒r var .

 (() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined
 

Bir blo─čun i├žinde

let Bir blo─čun i├žinde bildirilen de─či┼čkenlere o blo─čun d─▒┼č─▒ndan eri┼čilemez.

 {
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined
 

Bir d├Âng├╝ i├žinde

let D├Âng├╝lerde bildirilen de─či┼čkenlere yaln─▒zca bu d├Âng├╝n├╝n i├žinde referans verilebilir.

 for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.
 

Kapakl─▒ halkalar

D├Âng├╝ let yerine kullan─▒rsan─▒z var , her yinelemede yeni bir de─či┼čken al─▒rs─▒n─▒z. Bu, bir d├Âng├╝ i├žinde g├╝venli bir ┼čekilde kapak kullanabilece─činiz anlam─▒na gelir.

 // Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}
 

Ge├žici ├Âl├╝ b├Âlge

Zamansal ├Âl├╝ b├Âlge nedeniyle, bildirilen de─či┼čkenlere bildirilmeden let ├Ânce eri┼čilemez. Bunu yapmaya ├žal─▒┼čmak bir hata at─▒yor.

 console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;
 

Yeniden beyan yok

Ayn─▒ de─či┼čkeni kullanarak birden fazla kez bildiremezsiniz let . Ayr─▒ca, kulland─▒─č─▒ let bildirilen ba┼čka bir de─či┼čkenle ayn─▒ tan─▒mlay─▒c─▒y─▒ kullanarak bir de─či┼čken tan─▒mlayamazs─▒n─▒z var .

 var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared
 

const

const Olduk├ža benzer let - blok kapsaml─▒d─▒r ve TDZ'ye sahiptir. Ancak, farkl─▒ olan iki ┼čey var.

Yeniden atama yok

Kullan─▒larak bildirilen de─či┼čken const tekrar atanamaz.

 const a = 42;
a = 43; // TypeError: Assignment to constant variable.
 

De─čerin de─či┼čmez oldu─ču anlam─▒na gelmedi─čine dikkat edin. ├ľzellikleri hala de─či┼čtirilebilir.

 const obj = {};
obj.a = 42;
console.log(obj.a); // 42
 

De─či┼čmez bir nesneye sahip olmak istiyorsan─▒z kullanmal─▒s─▒n─▒z Object.freeze() .

Ba┼člat─▒c─▒ gerekli

Kullanarak bir de─či┼čken bildirirken her zaman bir de─čer belirtmelisiniz const .

 const a; // SyntaxError: Missing initializer in const declaration
 

70







─░┼čte ikisi aras─▒ndaki fark─▒n bir ├Ârne─či: (krom i├žin yeni destek ba┼člad─▒):

g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

G├Ârd├╝─č├╝n├╝z gibi var j de─či┼čken hala for loop kapsam─▒ d─▒┼č─▒nda bir de─čere sahip (Block Scope), ancak let i de─či┼čken for loop kapsam─▒ d─▒┼č─▒nda tan─▒ms─▒z.

 "use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
  console.log(j);
}

console.log(j);

console.log("let:");
for (let i = 0; i < 2; i++) {
  console.log(i);
}

console.log(i); 


48







Baz─▒ ince farklar vard─▒r - let kapsam belirleme, de─či┼čken kapsam belirleme, di─čer dillerdeki az veya ├žok dilde oldu─ču gibi davran─▒r.

├ľrn: ekteki blo─ču kapsamlar, ilan edilmeden ├Ânce yoklar, vb.

Ancak bunun let , yeni Javascript uygulamalar─▒n─▒n yaln─▒zca bir par├žas─▒ oldu─čunu ve farkl─▒ derecelerde taray─▒c─▒ deste─čine sahip oldu─čunu belirtmekte fayda var .


46







Temel fark, kapsam fark─▒d─▒r ; yaln─▒zca d├Âng├╝ i├žin oldu─ču gibi, bildirilen kapsam dahilinde bulunmas─▒na izin verilirken , ├Ârne─čin d├Âng├╝n├╝n d─▒┼č─▒na var eri┼čilebilir. MDN'deki belgelerden (ayr─▒ca MDN'den ├Ârnekler):https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let

izin verilen s─▒n─▒rl─▒, de─či┼čkenleri, kullan─▒ld─▒─č─▒ blok, ifade veya ifadeye bildirmenize izin verir. Bu, blok kapsam─▒na bakmaks─▒z─▒n, bir de─či┼čkeni global olarak veya yerel olarak t├╝m bir i┼čleve tan─▒mlayan var anahtar s├Âzc├╝─č├╝nden farkl─▒d─▒r .

De─či┼čkenler taraf─▒ndan ilan let kendi kapsam─▒ gibi blok hangi tan─▒mland─▒klar─▒ gibi herhangi i├žerdi─či alt bloklar halinde olan var. Bu ┼čekilde, ├žok var gibi ├žal─▒┼čmas─▒na izin verin . Ana fark, bir de─či┼čken de─či┼čkeninin kapsam─▒n─▒n t├╝m ├ževreleme i┼člevi olmas─▒d─▒r:

 function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}`
 

Program ve fonksiyonlar─▒ ├╝st d├╝zeyde, izin aksine, var , k├╝resel nesne ├╝zerinde bir ├Âzellik olu┼čturmaz. ├ľrne─čin:

 var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined
 

Bir blok i├žinde kullan─▒ld─▒─č─▒nda, de─či┼čkenin kapsam─▒n─▒ o blokla s─▒n─▒rland─▒r─▒n. Kapsam─▒, bildirildi─či i┼člevin i├žinde olan var aras─▒ndaki fark─▒ not al─▒n .

 var a = 1;
var b = 2;

if (a === 1) {
  var a = 11; // the scope is global
  let b = 22; // the scope is inside the if-block

  console.log(a);  // 11
  console.log(b);  // 22
} 

console.log(a); // 11
console.log(b); // 2
 

Ayr─▒ca ECMA6 ├Âzelli─čini de unutmay─▒n, bu y├╝zden hen├╝z tam olarak desteklenmiyor, bu y├╝zden Babil web sitesini ziyaret ederek her zaman ECMA5'e aktar─▒r ...https://babeljs.io


25







  • De─či┼čken Kald─▒rmad─▒

    let olacak de─čil vin├ž onlar g├Âr├╝n├╝r blo─čunun t├╝m kapsam─▒yla. Buna kar┼č─▒l─▒k, var a┼ča─č─▒daki gibi kald─▒r─▒rlar ba┼člad─▒.

     {
       console.log(cc); // undefined. Caused by hoisting
       var cc = 23;
    }
    
    {
       console.log(bb); // ReferenceError: bb is not defined
       let bb = 23;
    }
     

    Asl─▒nda Ba┼č─▒na @Bergi, Hem var ve let ask─▒ya al─▒r .

  • ├ç├Âp toplama

    Blok kapsam─▒ let haf─▒zay─▒ geri kazanmak i├žin kapaklar ve ├ž├Âp toplama ile ilgilidir. D├╝┼č├╝nmek,

     function process(data) {
        //...
    }
    
    var hugeData = { .. };
    
    process(hugeData);
    
    var btn = document.getElementById("mybutton");
    btn.addEventListener( "click", function click(evt){
        //....
    });
     

    click ─░┼čleyici geri arama ihtiyac─▒ yoktur hugeData hi├ž de─či┼čkeni. Teorik olarak, process(..) ├žal─▒┼čt─▒rmadan sonra , b├╝y├╝k veri yap─▒s─▒ hugeData ├ž├Âp toplanabilir. Bununla birlikte, baz─▒ JS motorlar─▒n─▒n bu devasa yap─▒y─▒ korumak zorunda kalmas─▒ olas─▒d─▒r, ├ž├╝nk├╝ click fonksiyon b├╝t├╝n kapsam─▒ ├╝zerinde kapan─▒r.

    Bununla birlikte, blok kapsam─▒ bu b├╝y├╝k veri yap─▒s─▒n─▒ toplanan ├ž├Âplere yapabilir.

     function process(data) {
        //...
    }
    
    { // anything declared inside this block can be garbage collected
        let hugeData = { .. };
        process(hugeData);
    }
    
    var btn = document.getElementById("mybutton");
    btn.addEventListener( "click", function click(evt){
        //....
    });
     
  • let d├Âng├╝ler

    let d├Âng├╝ i├žinde, onu ├Ânceki d├Âng├╝ yinelemenin sonundan itibaren yeniden atad─▒─č─▒n─▒zdan emin olarak, d├Âng├╝n├╝n her yinelemesine yeniden ba─člayabilir. D├╝┼č├╝nmek,

     // print '5' 5 times
    for (var i = 0; i < 5; ++i) {
        setTimeout(function () {
            console.log(i);
        }, 1000);  
    }
     

    Ancak, yerine var ile let

     // print 1, 2, 3, 4, 5. now
    for (let i = 0; i < 5; ++i) {
        setTimeout(function () {
            console.log(i);
        }, 1000);  
    }
     

    Bu let isimler i├žin yeni bir s├Âzc├╝ksel ortam yarat─▒n ├ž├╝nk├╝ a) ba┼člat─▒c─▒ ifade b) her bir yineleme (art─▒┼č ifadesini de─čerlendirmek i├žin), burada daha fazla ayr─▒nt─▒ vard─▒r .


23







─░┼čte ba┼čkalar─▒n─▒n zaten yazd─▒klar─▒n─▒ eklemek i├žin bir ├Ârnek. adderFunctions Her bir fonksiyonun tek bir Number arg├╝man─▒ ald─▒─č─▒ ve arg├╝man─▒n toplam─▒n─▒ ve dizideki fonksiyonun indeksini d├Ând├╝ren bir fonksiyon dizisi yapmak istedi─činizi varsayal─▒m . Anahtar kelimeyi adderFunctions kullanarak bir d├Âng├╝ olu┼čturmaya var ├žal─▒┼čmak, birisinin naif bir ┼čekilde bekleyebilece─či ┼čekilde ├žal─▒┼čmaz:

 // An array of adder functions.
var adderFunctions = [];

for (var i = 0; i < 1000; i++) {
  // We want the function at index i to add the index to its argument.
  adderFunctions[i] = function(x) {
    // What is i bound to here?
    return x + i;
  };
}

var add12 = adderFunctions[12];

// Uh oh. The function is bound to i in the outer scope, which is currently 1000.
console.log(add12(8) === 20); // => false
console.log(add12(8) === 1008); // => true
console.log(i); // => 1000

// It gets worse.
i = -8;
console.log(add12(8) === 0); // => true
 

Yukar─▒daki i┼člem, istenen i┼člev dizisini olu┼čturmaz ├ž├╝nk├╝ i kapsam─▒, for her i┼člevin olu┼čturuldu─ču blo─čun yinelemesinin ├Âtesine uzan─▒r . Bunun yerine, d├Âng├╝n├╝n sonunda, i her bir i┼člevin kapan─▒┼č─▒ i , i├žindeki her ads─▒z i┼člev i├žin d├Âng├╝n├╝n (1000) sonundaki de─čerini ifade eder adderFunctions . ─░stedi─čimiz ┼čey bu de─čil: ┼čimdi ayn─▒ davran─▒┼ča sahip bellekte 1000 farkl─▒ fonksiyon dizimiz var. Ve daha sonra de─čerini g├╝ncellersek i , mutasyon hepsini etkileyecektir adderFunctions .

Ancak, let anahtar kelimeyi kullanarak tekrar deneyebiliriz :

 // Let's try this again.
// NOTE: We're using another ES6 keyword, const, for values that won't
// be reassigned. const and let have similar scoping behavior.
const adderFunctions = [];

for (let i = 0; i < 1000; i++) {
  // NOTE: We're using the newer arrow function syntax this time, but 
  // using the "function(x) { ..." syntax from the previous example 
  // here would not change the behavior shown.
  adderFunctions[i] = x => x + i;
}

const add12 = adderFunctions[12];

// Yay! The behavior is as expected. 
console.log(add12(8) === 20); // => true

// i's scope doesn't extend outside the for loop.
console.log(i); // => ReferenceError: i is not defined
 

Bu kez, d├Âng├╝n├╝n i her yinelemesinde ribaunt edilir for . Her bir fonksiyon ┼čimdi i fonksiyonun yarat─▒ld─▒─č─▒ zaman─▒n de─čerini adderFunctions koruyor ve beklendi─či gibi davran─▒yor.

┼×imdi, resim iki davran─▒┼člar─▒ kar─▒┼čt─▒rma ve yeni kar─▒┼čt─▒rmak i├žin tavsiye edilmez neden muhtemelen g├Âreceksiniz let ve const daha eski olan var ayn─▒ senaryodaki. Bunu yapmak, baz─▒ ┼ča┼č─▒rt─▒c─▒ kafa kar─▒┼čt─▒r─▒c─▒ kodlara neden olabilir.

 const doubleAdderFunctions = [];

for (var i = 0; i < 1000; i++) {
    const j = i;
    doubleAdderFunctions[i] = x => x + i + j;
}

const add18 = doubleAdderFunctions[9];
const add24 = doubleAdderFunctions[12];

// It's not fun debugging situations like this, especially when the
// code is more complex than in this example.
console.log(add18(24) === 42); // => false
console.log(add24(18) === 42); // => false
console.log(add18(24) === add24(18)); // => false
console.log(add18(24) === 2018); // => false
console.log(add24(18) === 2018); // => false
console.log(add18(24) === 1033); // => true
console.log(add24(18) === 1030); // => true
 

Bunun sana olmas─▒na izin verme. Bir linter kullan─▒n.

NOT: Bu, d├Âng├╝lerdeki var / let davran─▒┼č─▒ ve ayr─▒ca anla┼č─▒lmas─▒ kolay olan fonksiyon kapan─▒┼člar─▒yla g├Âstermeyi ama├žlayan bir ├Â─čretim ├Ârne─čidir . Bu say─▒ eklemek i├žin korkun├ž bir yol olurdu. Ancak, anonim i┼člev kapan─▒┼člar─▒nda veri yakalaman─▒n genel tekni─či, ger├žek d├╝nyada ba┼čka ba─člamlarda da g├Âr├╝lebilir. YMMV.


18







Fark, her biri ile bildirilen de─či┼čkenlerin kapsam─▒d─▒r .

Uygulamada, kapsamdaki fark─▒n bir tak─▒m yararl─▒ sonu├žlar─▒ vard─▒r:

  1. let de─či┼čkenler yaln─▒zca en yak─▒n ├ževreleyen blokunda ( { ... } ) g├Âr├╝n├╝r .
  2. let de─či┼čkenler yaln─▒zca de─či┼čken bildirildikten sonra ortaya ├ž─▒kan kod sat─▒rlar─▒nda kullan─▒labilir ( kald─▒r─▒lsalar bile !).
  3. let de─či┼čkenler sonraki var veya taraf─▒ndan tekrarlanamaz let .
  4. Global let de─či┼čkenler global window nesneye eklenmez .
  5. let de─či┼čkenlerin kapaklarla kullan─▒m─▒ kolayd─▒r ( yar─▒┼č ko┼čullar─▒na neden olmaz ).

Uygulanan k─▒s─▒tlamalar let de─či┼čkenlerin g├Âr├╝n├╝rl├╝─č├╝n├╝ azalt─▒r ve beklenmeyen ad ├žarp─▒┼čmalar─▒n─▒n erken bulunma olas─▒l─▒─č─▒n─▒ artt─▒r─▒r. Bu, eri┼čilebilirli─či de dahil olmak ├╝zere de─či┼čkenler hakk─▒nda izlemeyi kolayla┼čt─▒r─▒r (neden kullan─▒lmayan belle─či geri kazanmaya yard─▒mc─▒ olur).

Sonu├ž olarak, let de─či┼čkenlerin b├╝y├╝k programlarda kullan─▒ld─▒─č─▒nda veya ba─č─▒ms─▒z olarak geli┼čtirilen ├žer├ževeler yeni ve beklenmeyen ┼čekillerde birle┼čtirildi─činde sorun yaratma olas─▒l─▒─č─▒ daha d├╝┼č├╝kt├╝r.

var Bir d├Âng├╝de (# 5) bir kapatma kullan─▒rken veya kodunuzda (4) harici olarak g├Âr├╝lebilen global de─či┼čkenler bildirirken tek ciltleme efektini istedi─činizden eminseniz hala yararl─▒ olabilir. Aktar─▒m var i├žin kullan─▒m─▒, export aktar─▒c─▒ alan─▒ d─▒┼č─▒ndan ve ana dile ge├žilirse desteklenebilir.

├ľrnekler

1. En yak─▒n ├ževreleyen blo─čun d─▒┼č─▒nda kullan─▒m yok: Bu kod blo─ču referans hatas─▒ verir, ├ž├╝nk├╝ ikinci kullan─▒m x blo─ču d─▒┼č─▒nda bildirilir let :

 {
    let x = 1;
}
console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".
 

Buna kar┼č─▒l─▒k, var eserler ile ayn─▒ ├Ârnek .

2. Bildirimden ├Ânce kullan─▒lamaz:
Bu kod blo─ču, kod ReferenceError ├žal─▒┼čt─▒r─▒lmadan ├Ânce bir atar; ├ž├╝nk├╝ x bildirilmeden ├Ânce kullan─▒l─▒r:

 {
    x = x + 1;  // ReferenceError during parsing: "x is not defined".
    let x;
    console.log(`x is ${x}`);  // Never runs.
}
 

Buna kar┼č─▒l─▒k, ayn─▒ ├Ârnek, var istisnalar atmadan ayr─▒┼čt─▒r─▒r ve ├žal─▒┼č─▒r.

3. Yeniden bildirim yap─▒lmaz: A┼ča─č─▒daki kod, bildirilen bir de─či┼čkenin let daha sonra yeniden bildirilemeyece─čini g├Âsterir :

 let x = 1;
let x = 2;  // SyntaxError: Identifier 'x' has already been declared
 

4. Ba─čl─▒ olmayan globaller window :

 var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link);  // OK
console.log(window.link);  // undefined (GOOD!)
console.log(window.button);  // OK
 

5. Kapaklarla kolay kullan─▒m: ile bildirilen de─či┼čkenler, var halkalar─▒n i├žindeki kapaklarla iyi ├žal─▒┼čmaz. De─či┼čkenin i zaman i├žindeki farkl─▒ noktalar─▒nda bulunan de─čerlerin s─▒ras─▒n─▒ veren basit bir d├Âng├╝ :

 for (let i = 0; i < 5; i++) {
    console.log(`i is ${i}`), 125/*ms*/);
}
 

├ľzellikle, bu ├ž─▒kt─▒:

 i is 0
i is 1
i is 2
i is 3
i is 4
 

JavaScript'te genellikle de─či┼čkenleri, olu┼čturuldu─čundan daha ├Ânemli bir zamanda kullan─▒r─▒z. Bunu, ├ž─▒kt─▒y─▒ bir kapatma ile geciktirerek g├Âsterdi─čimizde setTimeout :

 for (let i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}
 

... dayand─▒─č─▒m─▒z s├╝rece ├ž─▒kt─▒ de─či┼čmeden kal─▒r let . Aksine, var i bunun yerine kullanm─▒┼č olsayd─▒k :

 for (var i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}
 

... d├Âng├╝ beklenmedik bir ┼čekilde be┼č kez "i 5" dir:

 i is 5
i is 5
i is 5
i is 5
i is 5
 

15







A┼ča─č─▒daki iki fonksiyon fark─▒ g├Âsterebilir:

 function varTest() {
    var x = 31;
    if (true) {
        var x = 71;  // Same variable!
        console.log(x);  // 71
    }
    console.log(x);  // 71
}

function letTest() {
    let x = 31;
    if (true) {
        let x = 71;  // Different variable
        console.log(x);  // 71
    }
    console.log(x);  // 31
}
 

12







let ilgin├ž, ├ž├╝nk├╝ bize b├Âyle bir ┼čey yapmam─▒za izin veriyor:

 (() => {
    var count = 0;

    for (let i = 0; i < 2; ++i) {
        for (let i = 0; i < 2; ++i) {
            for (let i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();
 

Bu sayma ile sonu├žlan─▒r [0, 7].

Buna kar┼č─▒l─▒k

 (() => {
    var count = 0;

    for (var i = 0; i < 2; ++i) {
        for (var i = 0; i < 2; ++i) {
            for (var i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();
 

Sadece [0, 1] say─▒l─▒r.


12







─░┼člev VS blok kapsam─▒:

Aras─▒ndaki temel fark var ve let bu de─či┼čkenler ile deklare oldu─ču var edilmektedir i┼člevi kapsaml─▒ . Fonksiyonlar ile beyan Oysa let olan blok kapsaml─▒ . ├ľrne─čin:

 function testVar () {
  if(true) {
    var foo = 'foo';
  }

  console.log(foo);
}

testVar();  
// logs 'foo'


function testLet () {
  if(true) {
    let bar = 'bar';
  }

  console.log(bar);
}

testLet(); 
// reference error
// bar is scoped to the block of the if statement 
 

De─či┼čkenler var :

─░lk fonksiyon testVar ├ža─čr─▒ld─▒─č─▒nda foo de─či┼čkeni ├ža─čr─▒ld─▒─č─▒nda ifadenin var d─▒┼č─▒nda eri┼čilebilir durumdad─▒r if . Bu de─či┼čken foo kullan─▒labilir olacak yerde kapsam─▒nda testVar fonksiyonu .

De─či┼čkenler let :

─░kinci i┼čleve testLet ├ža─čr─▒ld─▒─č─▒nda de─či┼čken ├žubuk ├ža─čr─▒ld─▒─č─▒nda let , yaln─▒zca if ifade i├žinde eri┼čilebilir . De─či┼čkenler ile bildirilen i├žin let olan blok kapsaml─▒ (blok yuvarlak parantezler aras─▒nda kodudur ├Ârne─čin if{} , for{} , function{} ).

let de─či┼čkenler kalkmaz:

Aras─▒ndaki bir di─čer fark var ve let birlikte beyan ile de─či┼čkenler oldu─čunu let hoisted alamad─▒m . Bir ├Ârnek, bu davran─▒┼č─▒ g├Âstermenin en iyi yoludur:

ile de─či┼čkenler let yok hoisted olsun:

 console.log(letVar);

let letVar = 10;
// referenceError, the variable doesn't get hoisted
 

ile de─či┼čkenler var do olsun ├çekilen:

 console.log(varVar);

var varVar = 10;
// logs undefined, the variable gets hoisted
 

Global a┼ča─č─▒dakilerle ba─člant─▒ let kurmuyor window :

let Global kapsamda bildirilen bir de─či┼čken (bu, bir i┼člevde olmayan kod) global window nesnede bir ├Âzellik olarak eklenmez . ├ľrne─čin (bu kod genel kapsamdad─▒r):

 var bar = 5;
let foo  = 10;

console.log(bar); // logs 5
console.log(foo); // logs 10

console.log(window.bar);  
// logs 5, variable added to window object

console.log(window.foo);
// logs undefined, variable not added to window object
 


Ne zaman let kullan─▒lmal─▒ var ?

Kullan─▒m let ├╝zerinde var bunu basit├že daha spesifik kapsama ald─▒─č─▒ ├ž├╝nk├╝ her. Bu, ├žok say─▒da de─či┼čkenle u─čra┼č─▒rken ortaya ├ž─▒kabilecek olas─▒ adland─▒rma ├žat─▒┼čmalar─▒n─▒ azalt─▒r. var A├ž─▒k├ža k├╝resel bir de─či┼čkenin window nesne ├╝zerinde olmas─▒n─▒ istedi─činizde kullan─▒labilir (bunun ger├žekten gerekli olup olmad─▒─č─▒n─▒ her zaman dikkatlice d├╝┼č├╝n├╝n).


12







Ayr─▒ca, en az─▒ndan Visual Studio 2015'te, TypeScript 1.5, "var", bir blokta ayn─▒ de─či┼čken ad─▒n─▒n birden ├žok bildirilmesine izin veriyor ve "let" izin vermiyor.

Bu derleme hatas─▒ olu┼čturmaz:

 var x = 1;
var x = 2;
 

Bu irade:

 let x = 1;
let x = 2;
 

8


2015-08-11





var k├╝resel kapsam (kald─▒rma yetene─či) de─či┼čkenidir.

let ve const blok kapsam─▒d─▒r.

test.js

 {
    let l = 'let';
    const c = 'const';
    var v = 'var';
    v2 = 'var 2';
}

console.log(v, this.v);
console.log(v2, this.v2);
console.log(l); // ReferenceError: l is not defined
console.log(c); // ReferenceError: c is not defined 


7







Kullan─▒rken let

let Anahtar kelime ne olursa olsun blo─čun (genellikle kapsam─▒na de─či┼čken bildiriminde verdi─či { .. } o i├žerdi─či oluyor ├žifti). Ba┼čka bir deyi┼čle, let ├Ârt├╝k olarak de─či┼čken beyan─▒ i├žin herhangi blo─čun kapsam─▒n─▒ hijacks.

let De─či┼čkenler window nesnede eri┼čilemez ├ž├╝nk├╝ genel olarak eri┼čilemezler.

 function a(){
    { // this is the Max Scope for let variable
        let x = 12;
    }
    console.log(x);
}
a(); // Uncaught ReferenceError: x is not defined
 

Kullan─▒rken var

var ES5'teki de─či┼čkenler, fonksiyonlar─▒n kapsam─▒ d─▒┼č─▒ndad─▒r, yani de─či┼čkenler fonksiyonun d─▒┼č─▒nda de─čil fonksiyonun i├žinde ge├žerlidir.

var window Nesnede de─či┼čkenlere eri┼čilebilir, ├ž├╝nk├╝ bunlara genel olarak eri┼čilemez.

 function a(){ // this is the Max Scope for var variable
    { 
        var x = 12;
    }
    console.log(x);
}
a(); // 12
 

Daha fazla bilgi edinmek istiyorsan─▒z a┼ča─č─▒daki okumaya devam edin

kapsam─▒na en ├╝nl├╝ g├Âr├╝┼čme sorulardan biri de tam kullan─▒m─▒n─▒ yeterli olabilir let ve var a┼ča─č─▒daki gibi;

Kullan─▒rken let

 for (let i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 0 to 9, that is literally AWW!!!
        }, 
        100 * i);
}
 

Bunun nedeni let , her d├Âng├╝ yinelemesinde de─či┼čken de─či┼čkenin kapsam─▒ al─▒nm─▒┼č ve kendi kopyas─▒na sahip olmas─▒d─▒r.

Kullan─▒rken var

 for (var i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 10 times 10
        }, 
        100 * i);
}
 

Bunun nedeni var , her d├Âng├╝ yinelemesinde de─či┼čken de─či┼čkenin kapsam─▒ al─▒nm─▒┼č ve payla┼č─▒lan kopyaya sahip olmas─▒d─▒r.


7







├ľzellikleri do─čru okudu─čumda, yaln─▒zca okunabilirli─či azaltan, hata ay─▒klamay─▒ zorla┼čt─▒ran, ger├žek bir kod korumas─▒ ya da ba┼čka bir fayda sa─člayan hi├žbir pop├╝ler bir tasar─▒m deseni olan, yaln─▒zca birinin kodunu doyurmadan, hata ay─▒klamay─▒ zorla┼čt─▒ran, ger├žek kod korumas─▒ ya da ba┼čka bir fayda sa─člayan pop├╝ler bir tasar─▒m deseni olan kendi kendine ├ža─č─▒ran i┼člevlerden ka├ž─▒nmak i├žin let m├╝te┼čekkir olarak da yararlan─▒labilir. anlambilim i├žin arzu, bu y├╝zden kullanmay─▒ b─▒rak─▒n. / ranthttps://stackoverflow.com/questions/592396/what-is-the-purpose-of-a-self-executing-function-in-javascript%23592414#592414

 var SomeConstructor;

{
    let privateScope = {};

    SomeConstructor = function SomeConstructor () {
        this.someProperty = "foo";
        privateScope.hiddenProperty = "bar";
    }

    SomeConstructor.prototype.showPublic = function () {
        console.log(this.someProperty); // foo
    }

    SomeConstructor.prototype.showPrivate = function () {
        console.log(privateScope.hiddenProperty); // bar
    }

}

var myInstance = new SomeConstructor();

myInstance.showPublic();
myInstance.showPrivate();

console.log(privateScope.hiddenProperty); // error
 

Bkz. ' ├ľzel aray├╝zleri taklit etme '


6







Baz─▒ hack'lerle let :

1.

     let statistics = [16, 170, 10];
    let [age, height, grade] = statistics;

    console.log(height)
 

2.

     let x = 120,
    y = 12;
    [x, y] = [y, x];
    console.log(`x: ${x} y: ${y}`);
 

3.

     let node = {
                   type: "Identifier",
                   name: "foo"
               };

    let { type, name, value } = node;

    console.log(type);      // "Identifier"
    console.log(name);      // "foo"
    console.log(value);     // undefined

    let node = {
        type: "Identifier"
    };

    let { type: localType, name: localName = "bar" } = node;

    console.log(localType);     // "Identifier"
    console.log(localName);     // "bar"
 

Getter ve setter ile let :

 let jar = {
    numberOfCookies: 10,
    get cookies() {
        return this.numberOfCookies;
    },
    set cookies(value) {
        this.numberOfCookies = value;
    }
};

console.log(jar.cookies)
jar.cookies = 7;

console.log(jar.cookies)
 

3







var vs. Her ┼čey kapsam ile ilgili .

var de─či┼čkenler globaldir ve temel olarak her yere eri┼čilebilir, de─či┼čkenler global de─čildir ve sadece kapan─▒┼č parantezi onlar─▒ ├Âld├╝rene kadar var olur.

A┼ča─č─▒daki ├Ârne─če bak─▒n ve lion (let) de─či┼čkeninin iki konsolda nas─▒l farkl─▒ davrand─▒─č─▒n─▒ not edin; 2. console.log dosyas─▒nda kapsam d─▒┼č─▒ olur.

 var cat = "cat";
let dog = "dog";

var animals = () => {
    var giraffe = "giraffe";
    let lion = "lion";

    console.log(cat);  //will print 'cat'.
    console.log(dog);  //will print 'dog', because dog was declared outside this function (like var cat).

    console.log(giraffe); //will print 'giraffe'.
    console.log(lion); //will print 'lion', as lion is within scope.
}

console.log(giraffe); //will print 'giraffe', as giraffe is a global variable (var).
console.log(lion); //will print UNDEFINED, as lion is a 'let' variable and is now out of scope.
 

3







es6'n─▒n bir par├žas─▒ olal─▒m. Bu fonksiyonlar fark─▒ kolay bir ┼čekilde a├ž─▒klayacakt─▒r.

 function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}
 

2







Daha ├Ânce JavaScript'te yaln─▒zca iki kapsam vard─▒, yani i┼člevsel ve k├╝resel. ' let ' ─░le birlikte JavaScript art─▒k block-level de─či┼čkenleri getirmi┼čtir .

'Let' anahtar kelimesini tam olarak anlayabilmek i├žin ES6: 'let' anahtar kelimesini JavaScript'te de─či┼čken ilan etmek yard─▒mc─▒ olacakt─▒r.


1







┼×imdi de─či┼čkenleri a┼ča─č─▒daki ifadeleri kullanarak daha iyi ifade edebilece─čini d├╝┼č├╝n├╝yorum let :

 function printnums()
{
    // i is not accessible here
    for(let i = 0; i <10; i+=)
    {
       console.log(i);
    }
    // i is not accessible here

    // j is accessible here
    for(var j = 0; j <10; j++)
    {
       console.log(j);
    }
    // j is accessible here
}
 

San─▒r─▒m insanlar buradan sonra izin kullanmaya ba┼člayacaklar, b├Âylece di─čer diller, Java, C # vb. Gibi JavaScriptÔÇÖde benzer kapsamlara sahip olacaklar.

Daha ├Ânce hata yapmak i├žin JavaScriptÔÇÖte kapsam belirleme konusunda net bir anlay─▒┼č─▒ olmayan ki┼čiler.

Kald─▒rma kullan─▒m─▒ desteklenmiyor let .

Bu yakla┼č─▒mla JavaScript'te bulunan hatalar kald─▒r─▒lmaktad─▒r.

Bak─▒n─▒z ES6 olarak Derinli─či: let ve const daha iyi anlamak i├žin.


1







Bu makale, var, let ve const aras─▒ndaki fark─▒ a├ž─▒k├ža tan─▒mlar.

const tan─▒mlay─▒c─▒n─▒n atanmayaca─č─▒ bir sinyaldir.

let , de─či┼čkenin bir d├Âng├╝ i├žindeki bir saya├ž veya bir algoritmadaki bir de─čer takas─▒ gibi atanabilece─či bir sinyaldir. Ayr─▒ca de─či┼čkenin yaln─▒zca i├žinde tan─▒mland─▒─č─▒ blokta kullan─▒laca─č─▒n─▒n sinyallerini verir, bu her zaman t├╝m i├žerme fonksiyonu de─čildir.

var ┼čimdi JavaScript'te bir de─či┼čken tan─▒mlad─▒─č─▒n─▒zda mevcut en zay─▒f sinyal. De─či┼čken yeniden atanm─▒┼č olabilir veya olmayabilir ve de─či┼čken t├╝m fonksiyon i├žin veya sadece bir blok veya d├Âng├╝ amac─▒yla kullan─▒labilir veya kullan─▒lmayabilir.

https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b


1







Yukar─▒da da belirtildi─či gibi:

Fark kapsaml─▒. var En yak─▒n i├žin kapsaml─▒ fonksiyon blo─ču ve let odaklanan yak─▒n par├ža blok bir fonksiyon blok daha k├╝├ž├╝k olabilir. Her ikisi de herhangi bir blo─čun d─▒┼č─▒ndaysa globaldir. Bir ├Ârnek g├Ârelim:

├ľrnek 1:

Her iki ├Ârne─čimde de bir fonksiyonum var myfunc . 10'a e┼čit myfunc bir de─či┼čken i├žerir myvar . ─░lk myvar ├Ârne─čimde 10 ( myvar==10 ) 'a e┼čit olup olmad─▒─č─▒n─▒ kontrol ediyorum . Evetse, agian anahtar kelimeyi myvar kullanarak bir de─či┼čken (┼čimdi iki myvar de─či┼čkenim var) bildirir var ve yeni bir de─čer atar─▒m (20). Bir sonraki sat─▒rda de─čerini konsoluma bas─▒yorum. Ko┼čullu bloktan sonra tekrar myvar konsolumun de─čerini yazd─▒rd─▒m . E─čer ├ž─▒k─▒┼č─▒nda bakarsak myfunc , myvar de─čer 20'ye e┼čittir vard─▒r.


anahtar kelimeye izin ver

├ľrnek2: ─░kinci ├Ârne─čimde var ┼čartl─▒ blo─čumda anahtar kelime kullanmak yerine, anahtar kelime myvar kulland─▒─č─▒m─▒ ilan ediyorum let . ┼×imdi arad─▒─č─▒mda myfunc iki farkl─▒ ├ž─▒kt─▒ al─▒yorum: myvar=20 ve myvar=10 .

Yani fark ├žok basit yani kapsam─▒.


1








g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

Bu resme bir bak─▒n, ben const ve let de─či┼čkenlerin g├Âsterilmesi i├žin ├žok basit bir ├Ârnek olu┼čturdum . G├Ârd├╝─č├╝n├╝z gibi, const de─či┼čkeni de─či┼čtirmeye ├žal─▒┼čt─▒─č─▒n─▒zda hata alacaks─▒n─▒z ( sabit olan 'isim' ge├žersiz k─▒lmaya ├žal─▒┼č─▒l─▒yor ), ancak let de─či┼čkene bir g├Âz at─▒n ...

├ľncelikle beyan ederiz let age = 33 ve sonra ba┼čka bir de─čer atar─▒z age = 34; ki bu tamam, let de─či┼čkeni de─či┼čtirmeye ├žal─▒┼čt─▒─č─▒m─▒zda herhangi bir hatam─▒z olmaz.


1







Terimlerin ve ├Ârneklerin ├žo─čunun biraz ezici oldu─čunu d├╝┼č├╝n├╝yorum, Ki┼čisel olarak fark etti─čim as─▒l mesele "Blok" un ne oldu─čunu anlamak. Bir noktada fark ettim ki, bir blok IF ifadesi d─▒┼č─▒nda herhangi bir parantez i├žine al─▒nacakt─▒ . bir { i┼člevin veya d├Âng├╝n├╝n a├ž─▒l─▒┼č braketi yeni bir blok tan─▒mlayacakt─▒r, let i├žinde tan─▒mlanm─▒┼č herhangi bir ┼čey } , ayn─▒ ┼čeyin kapan─▒┼č dirsekinden sonra kullan─▒lamaz (i┼člev veya d├Âng├╝); Bunu ak─▒lda tutarak, anlamak daha kolayd─▒:

 let msg = "Hello World";

function doWork() { // msg will be available since it was defined above this opening bracket!
  let friends = 0;
  console.log(msg);

  // with VAR though:
  for (var iCount2 = 0; iCount2 < 5; iCount2++) {} // iCount2 will be available after this closing bracket!
  console.log(iCount2);
  
    for (let iCount1 = 0; iCount1 < 5; iCount1++) {} // iCount1 will not be available behind this closing bracket, it will return undefined
  console.log(iCount1);
  
} // friends will no be available after this closing bracket!
doWork();
console.log(friends); 


1







┼×u anda JavaScript'i derinlemesine anlamaya ├žal─▒┼čt─▒─č─▒m i├žin, halihaz─▒rda tart─▒┼č─▒lan harika par├žalar─▒n baz─▒lar─▒n─▒ ve di─čer detaylar─▒ farkl─▒ bir bak─▒┼č a├ž─▒s─▒yla i├žeren k─▒sa ara┼čt─▒rmam─▒ payla┼čaca─č─▒m.

Aras─▒ndaki fark─▒ anlama var ve let biz aras─▒ndaki fark─▒ anlamak e─čer daha kolay olabilir fonksiyonu ve blok kapsam─▒ .

A┼ča─č─▒daki davalar─▒ ele alal─▒m:

 (function timer() {
    for(var i = 0; i <= 5; i++) {
        setTimeout(function notime() { console.log(i); }, i * 1000);
    }
})();


   Stack            VariableEnvironment //one VariablEnvironment for timer();
                                       // when the timer is out - the value will be the same value for each call
5. [setTimeout, i]  [i=5] 
4. [setTimeout, i]  
3. [setTimeout, i]
2. [setTimeout, i]
1. [setTimeout, i]
0. [setTimeout, i]

####################    

(function timer() {
    for (let i = 0; i <= 5; i++) {
        setTimeout(function notime() { console.log(i); }, i * 1000);
    }
})();

   Stack           LexicalEnvironment - each iteration has a new lexical environment
5. [setTimeout, i]  [i=5]       
                      LexicalEnvironment 
4. [setTimeout, i]    [i=4]     
                        LexicalEnvironment 
3. [setTimeout, i]      [i=3]       
                         LexicalEnvironment 
2. [setTimeout, i]       [i=2]
                           LexicalEnvironment 
1. [setTimeout, i]         [i=1]
                             LexicalEnvironment 
0. [setTimeout, i]           [i=0]
 

zaman timer() ├ža─čr─▒lan ExecutionContext i├žerecektir ki olu┼čturulur VariableEnvironment ve LexicalEnvironments her yineleme kar┼č─▒l─▒k gelir.

Ve daha basit bir ├Ârnek

─░┼člev Kapsam─▒

 function test() {
    for(var z = 0; z < 69; z++) {
        //todo
    }
    //z is visible outside the loop
}
 

Blok Kapsam─▒

 function test() {
    for(let z = 0; z < 69; z++) {
        //todo
    }
    //z is not defined :(
}
 

1







Bu anahtar kelimeleri Y├╝r├╝tme Ba─člam─▒na ba─člamak istiyorum, ├ž├╝nk├╝ Y├╝r├╝tme Ba─člam─▒ t├╝m bunlarda ├Ânemlidir. Y├╝r├╝tme Ba─člam─▒n─▒n iki a┼čamas─▒ vard─▒r: Bir Olu┼čturma A┼čamas─▒ ve Y├╝r├╝tme A┼čamas─▒. Ayr─▒ca, her Y├╝r├╝tme Ba─člam─▒nda De─či┼čken Ortam ve D─▒┼č Ortam (Lexical Ortam) bulunur.

Bir Y├╝r├╝tme Ba─člam─▒n─▒n Olu┼čturma A┼čamas─▒ s─▒ras─▒nda, var, let and const, de─či┼čkenini, verilen Y├╝r├╝tme Ba─člam─▒n─▒n De─či┼čken Ortam─▒nda tan─▒mlanmam─▒┼č bir de─čere sahip bellekte saklayacakt─▒r. Fark, Y├╝r├╝tme A┼čamas─▒ndad─▒r. E─čer ba┼čvuru bir de─čere atanmadan ├Ânce var ile tan─▒mlanm─▒┼č bir de─či┼čken kullan─▒rsan─▒z, sadece tan─▒ms─▒z olacakt─▒r. Bir istisna ortaya ├ž─▒kmayacak.

Bununla birlikte, bildirilene kadar let veya const ile bildirilen de─či┼čkeni referans g├Âsteremezsiniz. Bildirilmeden ├Ânce kullanmaya ├žal─▒┼č─▒rsan─▒z, Y├╝r├╝tme Ba─člam─▒n─▒n Y├╝r├╝tme A┼čamas─▒ s─▒ras─▒nda bir istisna ortaya ├ž─▒kar. Art─▒k de─či┼čken hala bellekte olacak ve Y├╝r├╝tme Ba─člam─▒n─▒n Olu┼čturma A┼čamas─▒ izniyle, ancak Motor kullanman─▒za izin vermeyecektir:

 function a(){
    b;
    let b;
}
a();
> Uncaught ReferenceError: b is not defined
 

Motor, de─či┼čkeni ge├žerli Y├╝r├╝tme Ba─člam─▒n─▒n De─či┼čken Ortam─▒nda bulamazsa, de─či┼čken ile tan─▒mlanm─▒┼čsa, kapsam zincirine (D─▒┼č Ortam) ├ž─▒kacak ve de─či┼čken i├žin D─▒┼č Ortam─▒n De─či┼čken Ortam─▒n─▒ kontrol edecektir. Orada bulamazsa, Kapsam Zincirini aramaya devam eder. Let ve const ile durum b├Âyle de─čil.

Izin ikinci ├Âzelli─či, blok kapsam─▒ tan─▒tmas─▒d─▒r. Bloklar k├╝me parantezleri ile tan─▒mlan─▒r. ├ľrnekler, e─čer bloklar, bloklar vs. i├žin fonksiyon bloklar─▒n─▒ i├žerir. Bir blo─čun i├žini let ile birlikte bir de─či┼čken bildirdi─činizde, de─či┼čken sadece blo─čun i├žinde bulunur. Asl─▒nda, bir for d├Âng├╝s├╝ i├žinde oldu─ču gibi blok her ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda bellekte yeni bir de─či┼čken yaratacakt─▒r.

ES6 ayr─▒ca de─či┼čkenleri bildirmek i├žin const anahtar s├Âzc├╝─č├╝n├╝ sunar. const ayr─▒ca blok kapsamdad─▒r. Let ve const aras─▒ndaki fark, const de─či┼čkenlerinin bir ba┼člat─▒c─▒ kullan─▒larak bildirilmesi gerekti─či veya bir hata ├╝retece─čidir.

Ve son olarak, Y├╝r├╝tme Ba─člam─▒na gelince, var ile tan─▒mlanan de─či┼čkenler 'this' nesnesine eklenecektir. Genel Y├╝r├╝tme Ba─člam─▒nda, bu taray─▒c─▒lardaki pencere nesnesi olacakt─▒r. Bu izin veya const i├žin durum b├Âyle de─čil.


0



─░lgili yay─▒nlar


Numpy dizileri ve matrisler aras─▒ndaki farklar nelerdir? Hangisini kullanmal─▒y─▒m?

CGFloat ve float kullanmak aras─▒ndaki fark nedir?

Alt i┼člem Popen ve ├ža─čr─▒ aras─▒ndaki fark nedir (nas─▒l kullanabilirim)?

Globals (), locals () ve vars () aras─▒ndaki fark nedir?

Aray├╝z ve s─▒n─▒f aras─▒ndaki fark nedir ve y├Ântemleri s─▒n─▒fta do─črudan uygulayabildi─čimde neden bir aray├╝z kullanmal─▒y─▒m?

Python'da bir mod├╝l ile bir k├╝t├╝phane aras─▒ndaki fark nedir?

ÔÇťShÔÇŁ ve ÔÇťsourceÔÇŁ kullanmak aras─▒ndaki fark nedir?

Django redirect ve HttpResponseRedirect kullanmak aras─▒ndaki fark nedir?

.Exists? Ve .present kullanmak aras─▒ndaki fark nedir? Ruby'de mi?

Etiketle ilgili di─čer sorular [javascript]


Bir Linux kabuk beti─činde Evet / Hay─▒r / ─░ptal giri┼čini nas─▒l isteyebilirim?

2B dizide tepe alg─▒lama

Facebook'taki shebang / hashbang (#!) Ve yeni Twitter URL'leri ne i├žin?

Bir muteks nedir?

Eval, exec ve compile aras─▒ndaki fark nedir?

Gradle'da Java'da kullan─▒labilir bir de─či┼čken bildirmek m├╝mk├╝n m├╝?

Python Image Library ÔÇťdekoder JPEG mevcut de─čilÔÇŁ mesaj─▒ ile ba┼čar─▒s─▒z oluyor - PIL

Android / ARM hedefleri i├žin Delphi XEx kod ├╝retimini nas─▒l etkiler?

Sat─▒r i├ži i┼člevler C#?

Java y├Ântemi i├žin y├╝r├╝tme s├╝resini ├Âl├ž├╝n