NOT : Bu soru ECMAScript sürüm 3 veya 5 açısından sorulmuştur. Cevaplar, ECMAScript 6 sürümünde yeni özelliklerin kullanılmaya başlamasıyla modası geçmiş olabilir.

varJavaScript'teki anahtar kelimenin işlevi tam olarak nedir ve arasındaki fark nedir?

var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;

ve

someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;

?

İkisinden birini ne zaman kullanırsınız ve neden / ne işe yarar?

Eğer küresel kapsamdaysanız, o zaman fazla bir fark yoktur. Açıklama için Kangax'ın cevabını okuyun

Eğer bir fonksiyondaysanız var, yerel bir değişken yaratacaksa, "no var" değişkeni bulana veya global kapsama ulaşana kadar kapsam zincirini arayacaktır (hangi noktada onu oluşturacaktır):

// These are both globals
var foo = 1;
bar = 2;

function()
{
    var foo = 1; // Local
    bar = 2;     // Global

    // Execute an anonymous function
    (function()
    {
        var wibble = 1; // Local
        foo = 2; // Inherits from scope above (creating a closure)
        moo = 3; // Global
    }())
}

Bir ödev yapmıyorsanız kullanmanız gerekir var:

var x; // Declare x

Bir fark var .

var x = 1 xgeçerli kapsamda değişken olarak bildirir (yürütme bağlamı olarak da bilinir). Bildirim bir işlevde görünüyorsa - yerel bir değişken bildirilir; küresel kapsamda ise - global bir değişken bildirilir.

x = 1Öte yandan, sadece bir mülk atamasıdır. Önce xkapsam zincirine karşı çözüm bulmaya çalışır . Bu kapsam zincirinde herhangi bir yerde bulursa, atama gerçekleştirir; bulamazsa x, ancak o zaman genel bir nesnede (bir kapsam zincirinde en üst düzey bir nesne olan) özellik oluştururx .

Şimdi, global değişken bildirmediğine, global bir özellik oluşturduğuna dikkat edin.

İkisi arasındaki fark anlaşılır ve değişken bildirimlerin de özellikler (yalnızca Değişken Nesnede) oluşturduğunu ve Javascript'teki (well, ECMAScript) her özelliğin özelliklerini tanımlayan belirli bayrakları olduğunu anlamadığınız sürece kafa karıştırıcı olabilir - ReadOnly, DontEnum ve DontDelete.

Değişken bildirimi DontDelete bayrağıyla özellik oluşturduğundan, var x = 1ve x = 1(global kapsamda yürütüldüğünde) arasındaki fark, eski değişken değişken bildiriminin DontDelete'able özelliğini oluşturması ve ikincisinin oluşturmamasıdır. Sonuç olarak, bu örtük atama ile oluşturulan özellik genel nesneden silinebilir ve birincisi - değişken bildirimi ile oluşturulan özellik - silinemez.

Ancak bu sadece elbette teoridir ve pratikte, uygulamalardaki çeşitli hatalar (IE'den gelenler gibi) nedeniyle ikisi arasında daha fazla fark vardır .

Umarım her şey mantıklıdır :)

[Güncelleme 2010/12/16]

ES5'te (ECMAScript 5; son zamanlarda standartlaştırılmış, dilin 5. sürümü), "katı mod" olarak adlandırılır - kayıt dışı atamaların davranışını biraz değiştiren bir tercihli dil modu. Katı modda, bildirilmemiş bir tanımlayıcıya atama ReferenceError olur . Bunun mantığı, istenmeyen küresel özelliklerin yaratılmasını önleyerek, yanlışlıkla yapılan ödevleri yakalamaktı. Bazı yeni tarayıcılar katı mod için destek vermeye başladı bile. Örneğin, uyumlu tabloma bakın .

Bunun " yerel ve küresel " arasındaki farkın tamamen doğru olmadığını söylemek.

Bunu " yerel ve en yakın " arasındaki fark olarak düşünmek daha iyi olabilir . En yakın kişi kesinlikle küresel olabilir, ancak durum her zaman böyle olmayacaktır.

/* global scope */
var local = true;
var global = true;

function outer() {
    /* local scope */
    var local = true;
    var global = false;

    /* nearest scope = outer */
    local = !global;

    function inner() {
        /* nearest scope = outer */
        local = false;
        global = false;

        /* nearest scope = undefined */
        /* defaults to defining a global */
        public = global;
    }
}

Javascript bir tarayıcıda yürütüldüğünde, tüm kodunuz şöyle bir with ifadesiyle çevrilidir:

with (window) {
    //Your code
}

Daha fazla bilgi with- MDN

Yana vardeğişken bildirir geçerli kapsamda , ilan arasında hiçbir fark yoktur var penceresinin içinde hiç deklare değil.

Fark, doğrudan pencerenin içinde olmadığınızda, örneğin bir fonksiyonun içinde veya bir blok içinde olduğunuzda ortaya çıkar.

Kullanmak var, aynı ada sahip harici değişkenleri gizlemenizi sağlar. Bu şekilde "özel" bir değişkeni simüle edebilirsiniz, ancak bu başka bir konudur.

Temel kural her zaman kullanmaktır var, çünkü aksi takdirde ince hatalar yapma riskiyle karşı karşıya kalırsınız.

EDIT: Aldığım eleştirilerden sonra, aşağıdakileri vurgulamak istiyorum:

• vargeçerli kapsamda bir değişken bildirir
• Küresel kapsam window
• Kullanmıyor varvar kapsamda (pencere) örtülü olarak bildirilmiyor
• Genel kapsamda (pencere) bir değişkeni kullanarak bildirme var , onu atlamakla aynıdır.
• Kullanarak pencereden farklı kapsamlarda değişken bildirme var bir değişkeni bildirmek, değişkeni olmayan bir değişkeni bildirmekle aynı şey değildir.var
• Her zaman varaçıkça beyan et çünkü iyi uygulama

varDeğişkenleri bildirmek için her zaman anahtar kelimeyi kullanın. Neden? İyi kodlama uygulaması kendi başına bir neden olmalıdır, ancak bunu atlamak, küresel kapsamda beyan edildiği anlamına gelir (böyle bir değişkene "zımni" küresel denir). Douglas Crockford , zımni globalleri ve Apple JavaScript Kodlama Yönergeleri'ne göre asla kullanılmamasını önerir :

var Anahtar kelime olmadan oluşturulan herhangi bir değişken , global kapsamda oluşturulur ve işlev geri döndüğünde (kapsam dışına çıkmadığından) bellek sızıntısı fırsatı sunan çöp toplanmaz.

Aşağıda, yerel değişkenleri aşağıdakilerle bildirmekten nasıl kurtulabileceğinize dair iyi bir örnek verilmiştir var:

<script>
one();

function one()
{
    for (i = 0;i < 10;i++)
    {
        two();
        alert(i);
    }
}

function two()
{
    i = 1;
}
</script>

( idöngüde yerel olarak fordeğil küresel olarak bildirildiği için döngünün her yinelemesinde sıfırlanır ) sonunda sonsuz döngü ile sonuçlanır

Kullanmanın daha iyi olduğunu söyleyebilirim varÇoğu durumda .

Yerel değişkenler her zaman küresel kapsamdaki değişkenlerden daha hızlıdır.

Kullanmazsan varBir değişkeni bildirmek için , değişken genel kapsamda olur.

Daha fazla bilgi için Google'da "kapsam zinciri JavaScript'i" ni arayabilirsiniz.

Kullanma var !

varES6 öncesi değişkeni bildirmenin yoludur. Biz şimdi gelecekte ve bu şekilde kod yazmalısınız.

Kullan constvelet

constvakaların% 95'inde kullanılmalıdır. Değişken başvurusunun değişememesini sağlar, böylece dizi, nesne ve DOM düğümü özellikleri değişebilir ve olması gerekir const.

letyeniden atanması beklenen herhangi bir değişken için kullanılmalıdır. Buna bir for döngüsü dahil. varName =Başlatma işleminin ötesinde bir şey yazarsanız , kullanın let.

Her ikisinin de diğer dillerde beklendiği gibi blok düzeyinde kapsam belirlemesi vardır.

başka bir fark örneğin

var a = a || [] ; // works 

süre

a = a || [] ; // a is undefined error.

varDeğişkenlerin global kapsamı karıştırmasını ve değişkenlerin birbiriyle çatışmasını önlemek ve istenmeyen üzerine yazmaya neden olmak için kullanmak her zaman iyi bir fikirdir.

varKüresel değişken olmadan .

Her zamanvar yerel bağlamda init global değişkeni kötü olduğu için HER ZAMAN deyimi kullanmanız şiddetle önerilir . Ancak, bu kirli numaraya ihtiyacınız varsa, sayfanın başında yorum yazmalısınız:

/* global: varname1, varname2... */

Bu konsepti anlamanız için yazdığım örnek kod:

var foo = 5; 
bar = 2;     
fooba = 3;

// Execute an anonymous function
(function() {    
    bar = 100;             //overwrites global scope bar
    var foo = 4;           //a new foo variable is created in this' function's scope
    var fooba = 900;       //same as above
    document.write(foo);   //prints 4
    document.write(bar);   //prints 100
    document.write(fooba); //prints 900
})();

document.write('<br/>');
document.write('<br/>');
document.write(foo);       //prints 5
document.write(bar);       //prints 100
document.write(fooba);     //prints 3

@Chris S varve no arasındaki pratik farkı (ve tehlikeyi) gösteren güzel bir örnek verdi var. İşte bir tane daha, bunu özellikle tehlikeli buluyorum çünkü fark sadece asenkron bir ortamda görülebilir, böylece test sırasında kolayca kayabilir.

Aşağıdaki snippet çıktılarını beklediğiniz gibi ["text"]:

function var_fun() {
  let array = []
  array.push('text')
  return array
}

console.log(var_fun())

Aşağıdaki kod parçacığı da öyle (daha letönce eksik olanı not edin array):

function var_fun() {
  array = []
  array.push('text')
  return array
}

console.log(var_fun())

Veri manipülasyonunun eşzamansız olarak yürütülmesi, tek bir yürütücüde aynı sonucu verir:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

var_fun().then(result => {console.log(result)})

Ancak birden fazla olanla farklı davranır:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})

Ancak let'i kullanarak:

function var_fun() {
  let array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})

Bazıları bunu öğrenmeye çalışırken ben böyle görüyorum. Yukarıdaki örnekler yeni başlayanlar için biraz fazla karmaşık olabilir.

Bu kodu çalıştırırsanız:

var local = true;
var global = true;


function test(){
  var local = false;
  var global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

Çıktı şu şekilde okunur: yanlış, yanlış, doğru, doğru

Fonksiyondaki değişkenleri, bunun dışındaki değişkenlerden ayrı olarak gördüğü için, yerel değişken terimi ve atamada var kullandığımız içindi. Fonksiyondaki var'ı şimdi şöyle okuduğunuzdan çıkarırsanız:

var local = true;
var global = true;


function test(){
  local = false;
  global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

Çıktı yanlış, yanlış, yanlış, yanlış

Bunun nedeni, yerel kapsamda veya işlevde yeni bir değişken oluşturmak yerine, genel değişkenleri kullanması ve bunları false olarak yeniden atamasıdır.

Var olan veya olmayan değişkenler ve işlevin içinde veya dışında değişkenler bildirirken insanların kafası karıştığını görüyorum . İşte bu adımlarda size yol gösterecek derin bir örnek:

Jsfiddle'da aşağıdaki senaryoya bakın

a = 1;// Defined outside the function without var
var b = 1;// Defined outside the function with var
alert("Starting outside of all functions... \n \n a, b defined but c, d not defined yet: \n a:" + a + "\n b:" + b + "\n \n (If I try to show the value of the undefined c or d, console.log would throw 'Uncaught ReferenceError: c is not defined' error and script would stop running!)");

function testVar1(){
    c = 1;// Defined inside the function without var
    var d = 1;// Defined inside the function with var
    alert("Now inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};


testVar1();
alert("Run the 1. function again...");
testVar1();

function testVar2(){
    var d = 1;// Defined inside the function with var
    alert("Now inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};

testVar2();

alert("Now outside of all functions... \n \n Final Values: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n You will not be able to see d here because then the value is requested, console.log would throw error 'Uncaught ReferenceError: d is not defined' and script would stop. \n ");
alert("**************\n Conclusion \n ************** \n \n 1. No matter declared with or without var (like a, b) if they get their value outside the function, they will preserve their value and also any other values that are added inside various functions through the script are preserved.\n 2. If the variable is declared without var inside a function (like c), it will act like the previous rule, it will preserve its value across all functions from now on. Either it got its first value in function testVar1() it still preserves the value and get additional value in function testVar2() \n 3. If the variable is declared with var inside a function only (like d in testVar1 or testVar2) it will will be undefined whenever the function ends. So it will be temporary variable in a function.");
alert("Now check console.log for the error when value d is requested next:");
alert(d);

Sonuç

1. Var ile veya onsuz (a, b gibi) değerlerini işlevin dışında alırlarsa, değerlerini koruyacaklarsa, değerlerini koruyacaklar ve ayrıca komut dosyası aracılığıyla çeşitli işlevlere eklenen diğer değerler korunacaktır.
2. Değişken bir işlev içinde (c gibi) var olmadan bildirilirse, önceki kural gibi davranır, bundan sonra tüm işlevler içindeki değerini koruyacaktır. Ya testVar1 () fonksiyonunda ilk değerini aldı, hala testVar2 () fonksiyonunda değeri koruyor ve ek değer alıyor
3. Değişken yalnızca bir işlev içinde var ile bildirilirse (testVar1 veya testVar2'deki d gibi), işlev sona erdiğinde tanımsız olur. Yani bir işlevde geçici değişken olacaktır.

Bir değişkeni var kullanmadan kullanırsanız, o zaman otomatik olarak var var_adı genel kapsamda yer alır;

someFunction() {
    var a = some_value; /*a has local scope and it cannot be accessed when this
    function is not active*/
    b = a; /*here it places "var b" at top of script i.e. gives b global scope or
    uses already defined global variable b */
}

Kapsam sorununun yanı sıra, bazı kişiler de kaldırma işleminden bahsetmektedir , ancak hiç kimse bir örnek vermedi. Küresel kapsam için bir tane:

console.log(noErrorCase);
var noErrorCase = "you will reach that point";

console.log(runTimeError);
runTimeError = "you won't reach that point";

"Var" değişkenleri kullanılmadan sadece bir değer ayarlandığında tanımlanabilir. Örnek olarak:

my_var;

küresel kapsamda veya başka herhangi bir kapsamda çalışamaz . Değer gibi olmalıdır:

my_var = "value";

Öte yandan, bir vaiable gibi tanımlayabilirsiniz;

var my_var;

Değeri undefined(Değeri değildir nullve nullilginç bir şekilde eşit değildir .).

Değişkenin tarayıcıdaki pencere nesnesine eklenmesini istemiyorsanız var anahtar sözcüğünü kullanmalısınız. Burada, küresel kapsam belirleme ile yerel kapsam belirleme ve wihtout var anahtar kelimesi arasındaki kapsamı ve farkı açıklayan bir bağlantı bulunmaktadır.

Değişkenler var anahtar sözcüğü kullanılmadan tanımlandığında, basit bir “atama” işlemi gibi görünür.

Değer javascript'teki bir değişkene atandığında, yorumlayıcı önce "değişken bildirimini" atama ile aynı bağlamda / kapsamda bulmaya çalışır. Tercüman yürütüldüğündedummyVariable = 20 , işlevin başlangıcında dummyVariable bildirimini arar. (Tüm Değişken bildirimleri javascript yorumlayıcısı tarafından bağlamın başına taşındığından buna kaldırma adı verilir)

Javascript'te kaldırmaya bakmak da isteyebilirsiniz