Agar siz global miqyosda bo'lsangiz, unda unchalik katta farq yo'q. Tushuntirish uchun Kangax javobini o'qing.

Agar siz funktsiyada bo'lsangiz, var mahalliy o'zgaruvchini yaratadi, "no var" o'zgaruvchini topmaguncha yoki global qamrovga tegmaguncha (o'sha paytda u uni yaratadi) qamrov zanjirini qidiradi. ):

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

Agar siz topshiriqni bajarmasangiz, var dan foydalanishingiz kerak:

var x; // Declare x

Farq bor.

var x = 1 oʻzgaruvchini eʼlon qiladi x joriy koʻlamda (aka ijro konteksti). Agar deklaratsiya funktsiyada paydo bo'lsa - mahalliy o'zgaruvchi e'lon qilinadi; agar u global miqyosda bo'lsa - global o'zgaruvchi e'lon qilinadi.

x = 1, aksincha, faqat mulkiy topshiriqdir. U birinchi navbatda qamrov zanjiriga qarshi x ni hal qilishga harakat qiladi. Agar u ushbu tarmoq zanjirining istalgan joyidan topsa, u topshiriqni bajaradi; agar u x ni topmasa, u holda u global ob'ektda x xossasini yaratadi(bu qamrov zanjiridagi yuqori darajadagi ob'ekt).

Endi e'tibor bering, u global o'zgaruvchini e'lon qilmaydi, u global xususiyat yaratadi.

Ikkisi o'rtasidagi farq juda nozik va chalkash bo'lishi mumkin, agar sizo'zgaruvchan deklaratsiyalar ham xususiyatlar yaratishini (faqat o'zgaruvchan ob'ektda) va Javascriptdagi (yaxshi, ECMAScript) har bir xususiyatda tavsiflovchi ma'lum bayroqlarga ega ekanligini tushunmasangiz. ularning xususiyatlari - ReadOnly, DontEnum va DontDelete.

O'zgaruvchilar deklaratsiyasi DontDelete bayrog'i bilan xususiyat yaratganligi sababli, var x = 1 va x = 1 (global miqyosda bajarilganda) o'rtasidagi farq shundaki, birinchisi - o'zgaruvchilar deklaratsiyasi DontDelete'able xususiyatini yaratadi, ikkinchisi esa yaratmaydi. Natijada, ushbu yashirin topshiriq orqali yaratilgan xususiyat global ob'ektdan o'chirilishi mumkin va birinchisi - o'zgaruvchan deklaratsiya orqali yaratilgan - o'chirilmaydi.

Lekin bu, albatta, faqat nazariya vaamalda ikkalasi o'rtasida yanada ko'proq farqlar mavjuduni amalga oshirishdagi turli xatolar (masalan, IE dagilar) tufayli.

Umid qilamanki, hammasi mantiqiy :)

[Yangilanish 2010/12/16]

ES5 da (ECMAScript 5; yaqinda standartlashtirilgan, tilning 5-nashri) "qat'iy rejim" deb ataladigan - qo'shilgan til rejimi mavjud bo'lib, u e'lon qilinmagan topshiriqlarning xatti-harakatlarini biroz o'zgartiradi. Qattiq rejimda e'lon qilinmagan identifikatorga tayinlash ReferenceErrordir. Buning asosi tasodifiy topshiriqlarni qo'lga kiritish, istalmagan global xususiyatlarning paydo bo'lishiga to'sqinlik qilish edi. Ba'zi yangi brauzerlar allaqachon qattiq rejimni qo'llab-quvvatlashni boshladilar. Masalan, mening mos jadvalim ga qarang.

Buni "mahalliy va global" o'rtasidagi farq deb aytish mutlaqo to'g'ri emas.

Buni "mahalliy va eng yaqin" o'rtasidagi farq deb hisoblagan ma'qul. Eng yaqini, albatta, global bo'lishi mumkin, lekin bu har doim ham shunday bo'lmaydi.

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

Brauzerda Javascript bajarilganda, sizning barcha kodingiz with iborasi bilan o'ralgan bo'ladi, masalan:

with (window) {
    //Your code
}

Batafsil ma'lumot with - MDN

var o'zgaruvchini joriy doirada e'lon qilganligi sababli, var ichki oynani e'lon qilish va uni umuman e'lon qilmaslik o'rtasida farq yo'q.

Farqi siz to'g'ridan-to'g'ri deraza ichida bo'lmaganingizda paydo bo'ladi, masalan. funktsiya ichida yoki blok ichida.

var dan foydalanish bir xil nomga ega bo'lgan tashqi o'zgaruvchilarni yashirish imkonini beradi. Shu tarzda siz "xususiy" o'zgaruvchini simulyatsiya qilishingiz mumkin, ammo bu boshqa mavzu.

Asosiy qoida har doim var dan foydalanishdir, chunki aks holda siz nozik xatolarni kiritish xavfini tug'dirasiz.

EDIT: Men olgan tanqidlardan so'ng, men quyidagilarni ta'kidlamoqchiman:

• var oʻzgaruvchini joriy doirada eʼlon qiladi
• Global qamrovi window
• var dan foydalanmaslik global miqyosda var ni bilvosita e'lon qiladi (oyna)
• O'zgaruvchini global miqyosda (oynada) var yordamida e'lon qilish uni o'tkazib yuborish bilan bir xil.
• O'zgaruvchini oynadan farqli doiralarda var yordamida e'lon qilish bir xil narsa emas o'zgaruvchini varsiz e'lon qilish
• Har doim var ni aniq e'lon qiling, chunki bu yaxshi amaliyot

O'zgaruvchilarni e'lon qilish uchun har doim var kalit so'zidan foydalaning. Nega? Yaxshi kodlash amaliyoti o'z-o'zidan sabab bo'lishi kerak, lekin uni tashlab qo'yish uglobalda e'lon qilinganligini anglatadi (bunday o'zgaruvchi "ko'zda tutilgan" global deb ataladi). Duglas Krokford hech qachon nazarda tutilgan global ma'lumotlardan foydalanmaslikni tavsiya qiladi va Apple JavaScript-ni kodlash bo‘yicha qo‘llanma a>:

var bilan mahalliy o'zgaruvchilarni e'lon qilmaslikdan qanday qutulish mumkinligiga juda yaxshi misol:

<script>
one();

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

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

(i siklning har bir iteratsiyasida qayta oʻrnatiladi, chunki u for tsiklida mahalliy emas, balki global miqyosda e'lon qilingan) oxir-oqibat cheksiz tsiklga olib keladi

Ko'p hollarda var dan foydalanish yaxshiroq, deyman.

Mahalliy o'zgaruvchilar har doim global miqyosdagi o'zgaruvchilardan tezroq.

Agar oʻzgaruvchini eʼlon qilish uchun var dan foydalanmasangiz, oʻzgaruvchi global miqyosda boʻladi.

Qo'shimcha ma'lumot olish uchun Google'da "JavaScript qamrovi zanjiri" ni qidirishingiz mumkin.

var ishlatmang!

var o'zgaruvchini e'lon qilishning ES6 dan oldingi usuli edi. Biz endi kelajakdamiz va siz shunday kodlashingiz kerak.

const va let dan foydalaning

const 95% hollarda qo'llanilishi kerak. Bu o'zgaruvchan havolani o'zgartira olmasligini ta'minlaydi, shuning uchun massiv, ob'ekt va DOM tugunining xususiyatlari o'zgarishi mumkin va const bo'lishi mumkin.

let qayta tayinlanishi kutilayotgan har qanday o'zgaruvchi uchun ishlatilishi kerak. Bunga for tsikli kiradi. Agar siz initsializatsiyadan tashqari varName = yozsangiz, let dan foydalaning.

Boshqa tillarda kutilganidek, ikkalasi ham blok darajasiga ega.

boshqa farq, masalan

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

esa

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

var dan foydalanish har doim o'zgaruvchilar global miqyosni chalkashtirib yuborishi va o'zgaruvchilar bir-biriga zid bo'lishining oldini olish uchun yaxshi fikr bo'lib, istalmagan qayta yozishga olib keladi.

varsiz - global o'zgaruvchi.

DOIMO var iborasidan foydalanish tavsiya etiladi, chunki mahalliy kontekstda init global o'zgaruvchisi - yomon. Ammo, agar sizga bu iflos hiyla kerak bo'lsa, sahifaning boshida sharh yozishingiz kerak:

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

Bu tushunchani tushunishingiz uchun men yozgan misol kodi:

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

@Kris S var va yo'q var o'rtasidagi amaliy farqni (va xavfni) ko'rsatuvchi yaxshi misol keltirdi. Mana yana biri, men buni ayniqsa xavfli deb bilaman, chunki farq faqat asinxron muhitda ko'rinadi, shuning uchun u sinov paytida osongina o'tib ketishi mumkin.

Siz kutganingizdek, quyidagi snippet natijalari ["text"]:

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

console.log(var_fun())

Quyidagi parcha ham shunday (array dan oldin etishmayotgan let ga e'tibor bering):

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

console.log(var_fun())

Ma'lumotlar manipulyatsiyasini asinxron tarzda bajarish bitta ijrochi bilan bir xil natijani beradi:

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

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

Ammo bir nechtasi bilan boshqacha harakat qiladi:

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

Biroq, let dan foydalanish:

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

Buni o'rganishga harakat qilayotgan odam sifatida men buni shunday ko'raman. Yuqoridagi misollar yangi boshlanuvchilar uchun biroz murakkab edi.

Agar siz ushbu kodni ishga tushirsangiz:

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

Chiqish quyidagicha o'qiladi: noto'g'ri, noto'g'ri, rost, rost

Funktsiyadagi o'zgaruvchilarni uning tashqarisidagilardan alohida ko'rganligi sababli, mahalliy o'zgaruvchi atamasi va bu biz topshiriqda var dan foydalanganimiz uchun. Funktsiyadagi var ni olib tashlasangiz, u endi shunday o'qiydi:

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

Chiqish noto'g'ri, noto'g'ri, noto'g'ri, noto'g'ri

Buning sababi shundaki, mahalliy miqyosda yoki funktsiyada yangi o'zgaruvchi yaratish o'rniga u global o'zgaruvchilardan foydalanadi va ularni yolg'onga qayta tayinlaydi.

Ko'rib turibmanki, odamlar o'zgaruvchilarnivarli yoki funksiyasiz, funksiya ichida yoki tashqarisida e'lon qilishda chalkashib ketishadi. Mana sizga ushbu qadamlar orqali yordam beradigan chuqur misol:

Quyidagi skriptni jsfiddle orqali ko‘ring

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

Xulosa

1. Var bilan yoki bo'lmasdan e'lon qilinganidan qat'iy nazar (a, b kabi) agar ular o'z qiymatini funktsiyadan tashqarida olsalar, ular o'z qiymatini saqlab qoladilar va skript orqali turli funktsiyalarga qo'shilgan boshqa qiymatlar ham saqlanib qoladi.
2. Agar o'zgaruvchi funktsiya ichida varsiz e'lon qilinsa (masalan, c), u avvalgi qoida kabi ishlaydi va bundan buyon barcha funktsiyalarda o'z qiymatini saqlab qoladi. Yoki u testVar1() funktsiyasida o'zining birinchi qiymatini oldi, u hali ham qiymatni saqlab qoladi va testVar2() funktsiyasida qo'shimcha qiymat oladi.
3. Agar o'zgaruvchi faqat funksiya ichida var bilan e'lon qilingan bo'lsa (masalan, testVar1 yoki testVar2 da d), funktsiya tugashi bilan u aniqlanmagan bo'ladi. Shunday qilib, u funktsiyada vaqtinchalik o'zgaruvchi bo'ladi.

Kod ichida siz var ishlatmasdan o'zgaruvchidan foydalansangiz, avtomatik ravishda var var_name global miqyosga joylashtiriladi, masalan:

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

Ko'lamlar masalasidan tashqari, ba'zi odamlar ko'tarish haqida ham eslatib o'tishadi, lekin hech kim misol keltirmadi. Bu global miqyos uchun:

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

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

"Var" dan foydalanmasdan o'zgaruvchilar faqat qiymat o'rnatilganda aniqlanishi mumkin. Masalan:

my_var;

global miqyosda yoki boshqa miqyosda ishlay olmaydi. U quyidagi qiymatga ega bo'lishi kerak:

my_var = "value";

Boshqa tomondan, siz kabi o'zgaruvchini belgilashingiz mumkin;

var my_var;

Uning qiymati undefined (Uning qiymati null emas va u null ga teng emas.).

Agar oʻzgaruvchini brauzerda oyna obyektiga biriktirmoqchi boʻlmasangiz, var kalit soʻzidan foydalanishingiz kerak. Mana bu havolada qamrovni aniqlash va var kalit so'zi bilan va bo'lmagan holda glokal qamrov va mahalliy miqyos o'rtasidagi farq.

O'zgaruvchilar var kalit so'zidan foydalanmasdan aniqlanganda, bu oddiy "tayinlash" operatsiyasiga o'xshaydi.

Qiymat javascriptdagi o'zgaruvchiga tayinlanganda, tarjimon avval "o'zgaruvchi deklaratsiyasini" tayinlash bilan bir xil kontekst/ko'lamda topishga harakat qiladi. Tarjimon dummyVariable = 20 ni bajarganda, funktsiya boshida dummyVariable deklaratsiyasini qidiradi. (Chunki barcha o'zgaruvchan deklaratsiyalar javascript tarjimoni tomonidan kontekstning boshiga ko'chiriladi va bu ko'tarish deb ataladi)

Shuningdek, siz ko'tarishni ko'rib chiqishingiz mumkin. javascript