Var anahtar kelimesinin amacı nedir ve ne zaman kullanmalıyım (veya atlamalıyım)?


1543

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?


3
Değişken bildirimlerini zincirlerken, virgülden sonra yeni satır koymak davranışı etkiler mi? var x = 1, y = 2, [dönüş] z = 3;
Alfabravo

4
"Var" işlevinin kullanılmaması, seçtiğiniz değişken adının daha önce tanımlanmış bir global değişken olması durumunda da sizi açıkta bırakır. Keder yolculuğuma buradan bakın: stackoverflow.com/questions/16704014/…
Scott C Wilson

5
@Ray Toal'ın meloncard blog yazısı (kesinlikle okunmaya değer) blog.safeshepherd.com/23/how-one-missing-var-ruined-our-launch
Hephaestus

Bir şiirin bana programlı bir problem için düşünmemize ilham verebileceğini hiç düşünmemiştim
Félix Gagnon-Grenier

1
@Gibolt ama soru tarihine bakın, bunu söylemek için 2009 sorusunu biraz adil olmayan bir çağırma. Her ne kadar, hala güncelliğini korumak için geçerli olsa da, orada bir dizi "modern JS" kodu yok.
Andre Figueiredo

Yanıtlar:


1356

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

31
"Çok fazla fark yok" == "Fark Yok" mu?
Alex

65
Aslında evet, fark var :) Bu farkın önemli olup olmadığı başka bir soru. Cevabımı daha aşağıya bakın: stackoverflow.com/questions/1470488/…
kangax

4
Sanırım bu Alex'in noktası olabilir, bu yüzden "eşittir" operatörünü kullanarak yazmış!
James Bedford

18
Bu bir Railgun ile kendini vurmak gibi bir şey ... Kişinin değişken önce 'var' koyun ve değişken değiştirerek sonuna kadar Forget bir yere kapsam zincirinde ... Java / C / Python / vb ikna deneyin. JavaScript'in değerli olduğu geliştiricidir. Ha! C / C ++ tuzakları kontrast ile güzel görünüyor. JavaScript hatalarını ayıklamak zorunda olduğunuzu düşünün ... Ve bazı insanlar bunu elbette yapıyor. Ve JavaScript'te yazılmış çok fazla kod var (basit kod değil, dikkat edin) ...
Albus Dumbledore

6
Eğer küresel kapsamdaysanız, hiçbir fark yoktur. >> Aşağıdaki cevapta açıklanan bir fark var
Max Koretskyi

746

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 .


Doğru hatırlıyorsam, bir zamanlar bir kesmek deleteile var beyan edilen bir değişkene ulaşabilmenin bir yolunu bulduğumu düşünüyorum eval. Tam numarayı hatırlarsam buraya gönderirim.
Kule

3
@Mageek Silinebilir değerlendirilen değişkenleri alıyor olabilir. Bunun hakkında bir kez blog yazısı yazdım .
kanguru

1
Biraz konu dışı, ama burada referans için söz. "let", "var" a çok benzer ve Mozilla'da desteklenir. Temel fark, bir değişkenin kapsamının, tüm "kapalı" işlevinin bloğu ile sınırlı olduğu tüm kapalı fonksiyon olmasıdır
mac

@kangax Alex'in örneklerinin son iki satırı karışık olsaydı: var someObject = {}ve someObject.someProperty = 5? Misiniz somePropertynesne kalıntıların bir özellik yerel iken, küresel hale?
snapfractalpop

1
@Kangax adlandırdığı için Spec adı DontDelete bayrağı olan (= yapılandırılabilir false) , sen açısından bu konuda okuyabilir Object.definePropertyveObject.getOwnPropertyDescriptor
Paul S.

137

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

3
outerTanımladığınız en yakın kapsam değil var global = false;mi?
Snekse

@Snekse: <code> var global = false; </code> bildirildiğinde 'en yakın' uygulanmaz. Bu bildirgede, bildiride 'var' kullanıldığı için 'global' dış () kapsamına yerleştirilir. 'Var' iç () öğesinde kullanılmadığından, sonraki (sonraki) dıştaki () değeri değiştirecektir.
Mitch

Bu satırı değiştirirseniz yorumunuzun değişip değişmeyeceğini merak ediyorum var global = local;, bu durumda yerelin yakın kapsamı aktif olarak tanımlanmış olan "yerel" dış kapsam olacaktır. Aynı satırı değiştirmeniz garip olsa da var global = global, bu durumdaglobal genel pencere kapsamında bir seviye yukarı çıkacaktır.
Snekse

80

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

1
Seni küçümsemedim, ama kapsam muhtemelen pencereden daha iyi bir kelime. Bütün açıklaman biraz geniş.
Robert Harvey

4
Ben sadece ismiyle şeyleri çağırıyorum, buna "küresel kapsam" demek istersiniz, tamam, ama müşteri tarafı, konvansiyonla, pencere nesnesidir, bu kapsam zincirinin son elemanıdır, bu yüzden her fonksiyonu ve pencerede her nesne yazma olmadan "pencere".
kentaromiura

2
+1 bu gerçekten güzel bir açıklama - daha önce böyle böyle çerçeveli var / hayır var sorunu duymadım (hayır pun amaçlanan).
doug

Bu cevabın çoğu letES6'da kullanımdan kaldırılmıştır .
Evan Carroll

3
@EvanCarroll Bu cevap ayrıca teknik olarak yanlıştır, çünkü var parametresini atlamak herhangi bir değişken bildirmez, bunun yerine global nesne üzerinde silinebilir bir özellik oluşturur, ES5 "katı" modunu kullanmanın yanı sıra cevabın çoğu doğru değildir, izin vermedi ' Bu soruda bile, söz konusu zamanda, referans standardının (o zaman) ECMA 262 3. Baskı olduğunu ima eden javascript sürümüne (dün eklenmiş) herhangi bir referans olmadığı göz önünde bulundurulmuştur.
kentaromiura

43

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.


17
"İyi kodlama uygulaması" asla kendi başına yeterli bir sebep olmamalıdır. "İnternetteki bazı adamlar kodumun böyle görünmesi gerektiğini söyledi" anlamına geliyor. Bu, kuralın arkasındaki nedeni en azından belirsiz bir şekilde anlamadığı sürece, "öğretmenim dedi" den bile daha az geçerlidir.
cHao

@cHao good coding practiceBu ve en iyi Javascript yazarları tarafından önerilen en iyi uygulama ise her zaman yeterli bir sebep olduğunu düşünüyorum .
Chris S

8
@ChrisS: Hayır, "iyi kodlama uygulaması" kendi başına bir neden değildir. Nedeni iyi uygulama olarak kabul edilir önemli olan. Bu yazarlar size neden önerdiklerini söylemedikçe, önerileri hiçbir şekilde ağırlık taşımamalıdır. Sebepleri kabul etmiyorsanız, o zaman kötü tavsiyeyi düşünmekte özgürsünüz. Ve bunu nedenini sormadan takip ederseniz, kargo kültürü böyle başlar.
cHao

30

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


Olmadı! Sadece bu yazım hatası nedeniyle oluşabilecek tüm hataları hayal edebiliyorum.
BonsaiOak

2
merak ediyorum, neden ben ikiye argüman olarak geçiyorsun ()? (for döngüsü içinde) bu gereksiz mi?
kalin

İki () işlevi parametre olmadan tanımlandığından, bağımsız değişken bir () işlevinde kapsüllenmiş iki () işlevinde yok sayılır. Oldukça haklısın, rol oynamadığı için gerekli değil.
KK.

Hata veya özellik?
TheMaster

13

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.


Bir değişkeni var anahtar sözcüğünü kullanarak bildirirseniz, çalışma zamanında oluşturulur, bu yüzden daha yavaş olmamalıdır? Çünkü diğeri ayrıştırılmış zamanda oluşturulur.
Barış Velioğlu

@RyuKaplan - hey, bu doğru mu? Google'ı denedim ve konuyla ilgili herhangi bir bilgi alamadım! Bu iddia için kaynak yetkiniz var mı? Thx
mike kemirgen

@RyuKaplan Ayrıştırma / derleme aslında kodu çalıştırmaktan farklıdır.
gcampbell

11

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.


2
Tüm 'var' ifadesini 'const' ile değiştirin (tümünü değiştirin). Yeniden atanan değişkenlerinizin nerede olduğunu hemen fark edeceksiniz. Bunlardan çok fazla varsa, büyük olasılıkla anti-desen olarak kodlarsınız: yeniden atanabilir değişkenlerin çoğu kapanışlara veya nesne özellikleri olarak gömülebilir. Eğer birkaçınız varsa: onlar için 'let' kullanın. Son olarak, 'var' ile hiç açıklanmayan bazı değişkenler bildirilmemiş olarak kalırlar ve hala küresel alanda bulunurlar, dikkat edin. @Gibolt hakkında yorum 'bir for döngüsü içinde', ayrıca "vakaların% 95" ;-): dizi yöntemleri harika bu tür döngüleri önlemek için önerilir.
allez l'OM

Const'un vakaların% 95'inde kullanılması gerektiğini söyleyerek, iyi uygulamadan uzaklaşıp dogmaya gidiyoruz gibi görünüyor.
Agamemnus

9

başka bir fark örneğin

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

süre

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

1
'Var' ile tanımlanmış değişken ve var ile tanımlanmamış değişken durumunda neden çalıştığını açıklayabilir misiniz? Değişken, görevin sağ tarafının değerlendirilmesinden önce yaratılıyor varmu?
matt

6
@Lucek var a, kapsamın en üstüne kaldırıldığı ve değişkeni bildiren ancak başlatmayan null olarak ayarlandığından, atamada false olarak değerlendirilen ve atamayı ayarlayan tanımlanmamış bir null değişkene başvurunuz olur []. İkinci olarak, mülke Bir görevin var amülkiyet a. Var olmayan bir özelliğe atayabilirsiniz - atamada oluşturma, ancak size ReferenceErroratılmadan var olmayan bir özellikten okuyamazsınız .
Evan Carroll

1
@EvanCarroll: kapsamın üstüne çekilir ve null yerine undefined olarak ayarlanır.
mithunsatheesh

8

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.


8

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

3

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

2
Fonksiyon hiçbir şekilde "anonim" değildir. Aslında, olabildiğince görünür bir şekilde adlandırılmıştır.
Ingo Bürk

Ingo Bürk'ün yorumuna cevaben cevabınızı düzenlediğiniz için teşekkür ederiz.
Dave Burton

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)})
})


@Thisismydesign örneği için teşekkürler! Son iki örnekle ilgili olarak, sondan bir önceki örnek üç öğeden oluşan bir diziyi üç kez yazılmış metinle günlüğe kaydederken, nihai örnek dizideki öğe başına yalnızca bir kez "metin" kaydeder? (Sonuncunun "dizi" yi bir değişken olarak bildirdiğini ve bu nedenle yerel kapsamda olduğunu anlıyorum, oysa sondan bir önceki örnek bunu atladı ve "dizi" i ima edilen küresel kapsamın bir parçası haline getirdi.) çıktı? ForEach "i" işlev ve tüm global değişkenler üzerinde yinelediği için mi?
AlmostPitt

2

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.


2

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.

Bu konuyu göstermek için zaman ayırdığınız için teşekkür ederiz. Yukarıdaki kodda aşağıdaki bölüm eksik. Bu nedenle cevabınızı düzenlemek isteyebilirsiniz: a = 1; // var var olmadan fonksiyon dışında tanımlandı b = 1; // var alert ile fonksiyon dışında tanımlandı ("Tüm fonksiyonların dışında başlıyor ... \ n \ na, b tanımlandı, ancak c, d henüz tanımlanmadı: \ na: "+ a +" \ nb: "+ b +" \ n \ n (Tanımlanmamış c'nin değerini göstermeye çalışırsam veya d, console.log 'Yakalanmayan ReferenceError: c tanımlı değil' hatası verir ve komut dosyası çalışmayı durdurur!) ");
Sankofa

1

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 */
}

1

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


0

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


my_var;aslında geçerli bir ifade ifadesidir.
lexicore

Değişken daha önce tanımlanmışsa geçerli bir ifadedir. Aksi takdirde "... tanımlı değil" hatası verir.
umut

3
Bir değişkenin önceden tanımlanıp tanımlanmadığına bakılmaksızın geçerli bir ifadedir . :) Geçerli bir ifade, ifadeyi geçersiz kılmayan bir hata verebilir .
lexicore

Bu konuda kafam karıştı. Geçerli beyan nedir? Bana geçersiz bir ifade örneği verebilir misiniz?
umut

Son zamanlarda özür dilemeliyim - çok fazla ECMAScript dilbilgisi. my_var;geçerli bir ifade ifadesidir . /my_var;geçersiz bir ifade olur. Ama dediğim gibi, bu dilbilgisi casuistics, özür dilerim, yorumum aslında uygun değildi.
lexicore

0

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

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.