JavaScript: Değişken Kapsam. Değişken kapsam Fonksiyondaki Js global değişkeni

Merhaba! Bugün değişkenlerin kapsamı hakkında konuşacağız (değişkenin ne olduğunu okuyun). Gerçek şu ki, bir işlevde bir değişken oluşturduğunuzda ve onun adı, işlevin dışındaki bir değişkenin adıyla çakışırsa, değişkenin global ve yerel kapsamlarıyla ilgili çeşitli ilginç durumlar olabilir.

Bununla bu dersi anlayacağız.

Küresel değişken

İşlevin dışında oluşturduğunuz tüm değişkenler globaldir. Ve var anahtar sözcüğünü kullanarak bir değişken oluşturmak zorunludur, eğer bu yapılmazsa, değişken programın her yerinde görülebilir ve dahası, katı mod etkinleştirildiğinde, bu bir hataya neden olur. Katı modu etkinleştirmek için, komut dosyanızın başına "sıkı kullan" satırını yazmanız yeterlidir. Bu, JavaScript yorumlayıcısına JavaScript standardına kesinlikle uymasını söyleyecektir. İşte global değişken kullanan bir örnek

Var a \u003d 6; // global değişken function double () (return alert (a * a); // global bir değişken kullanarak) double ();

Örnek, 6 değerinin atandığı global bir a değişkenini bildirir. Fonksiyonda, bu değişkene erişebiliriz ve hatta daha fazlasını değiştirebiliriz ve bu değer her yerde değişecektir.

Bir fonksiyonda global bir değişkenin değerinin değiştirildiği bir örneğe bakalım ve sonra fonksiyonun dışındaki global değişkene erişip fonksiyonun kendisinde ona ayarlanmış olan değeri görelim.

Var a \u003d 6; function double () (a \u003d 5; // fonksiyondaki global değişkenin değerini değiştirin return alert (a * a);) double (a); // document.write (a) işlevini çağırın; // global değişkenin değeri

Örnekten de görebileceğiniz gibi, bir fonksiyondaki global bir değişkenin değerini değiştirirseniz, hem fonksiyonda hem de dışında her yerde zaten onunla kalır.

Yerel değişken.

Bir işlevde bir değişken tanımladığınızda, bu değişken yerel hale gelir ve yalnızca işlevin içinden erişilebilir. İf / else, for, while, do ... while ifadelerinin değişkenlerin kapsamını etkilemediğine dikkat edilmelidir.

Bu nedenle, bir işlevde global bir değişkene erişebileceğiniz, ancak genel olarak bir işlevin dışında işlevin gövdesinde oluşturulan yerel bir değişkene erişemeyeceğiniz ortaya çıkar. Bir örneğe bakalım.

Function double () (var a \u003d 6; return alert (a * a);) double (); document.write (a); // yerel bir değişkene erişmeye çalışıyorum

Örnekte, değişken global olarak değil, fonksiyonda yani yerel olarak bildirilmiştir. Daha sonra işlevi çağırıp yerel değişkene erişmeye çalışıyoruz, ancak hiçbir şey olmuyor ve konsolda değişkenin tanımlanmadığı şeklinde bir hata görüyoruz.

Ve son seçenek, hem global bir değişken hem de aynı ada sahip bir yerel değişken oluşturulduğunda, o zaman ne olacağıdır. Bir örnek görelim.

Var a \u003d 7; function double () (var a \u003d 6; return alert (a * a);) document.write (a);

Gördüğünüz gibi, fonksiyonda, adı global olanla örtüşmesine rağmen başka bir değişken yaratılmış gibi ve fonksiyonda mevcut olacak yerel değişkendir; bu örnekte gösterildiği gibi global olanın üzerine yazamaz.

Tüm bunlardan ne sonuç çıkarılabilir? Bu nedenle, işlevin içinde ve dışında farklı adlara sahip değişkenler kullanmaya çalışmak. Ancak yerel ve küresel kapsamlar hakkında bilgi sahibi olmanız gerekir.

Sonuçlar.

Bir fonksiyonun dışında oluşturulan bir değişken globaldir.

Fonksiyondan global değişkene erişebilir ve değerini değiştirebilirsiniz.

Değişkenler, bilgi depolamak için "kaplar" görevi görür.

Okul Cebirini Hatırlıyor musunuz?

Okul cebirini hatırlıyor musun? x \u003d 5, y \u003d 6, z \u003d x + y

Bir değeri (örneğin 5) saklamak için bir harfin (örneğin x) kullanılabileceğini ve yukarıdaki bilgileri z'nin 11 olduğunu hesaplamak için kullanabileceğinizi hatırlıyor musunuz?

Bu harflere denir değişkenlerve değişkenler değerleri (x \u003d 5) veya ifadeleri (z \u003d x + y) depolamak için kullanılabilir.

JavaScript değişkenleri

Cebirde olduğu gibi, JavaScript değişkenleri değerleri veya ifadeleri saklamak için kullanılır.

Bir değişken, x gibi kısa bir ada veya araba adı gibi daha açıklayıcı bir ada sahip olabilir.

JavaScript değişken adları için kurallar:

• Değişken adları büyük / küçük harfe duyarlıdır (y ve Y iki farklı değişkendir)
• Değişken adları bir harf veya alt çizgiyle başlamalıdır

Yorum Yap: JavaScript büyük / küçük harfe duyarlı olduğundan, değişken adları da büyük / küçük harfe duyarlıdır.

Misal

Bir değişkenin değeri kod yürütme sırasında değişebilir. Değerini görüntülemek veya değiştirmek için bir değişkene adıyla başvurabilirsiniz.

JavaScript Değişkenlerini Bildirme (Oluşturma)

JavaScript'te değişkenler oluşturmak, daha çok "değişkenleri bildiren" olarak adlandırılır.

Anahtar kelimeyi kullanarak JavaScript değişkenleri bildiriyorsunuz var:

Yukarıdaki önerileri uyguladıktan sonra, değişken x değeri içerecek 5 ve araba adı değeri içerecek Mercedes.

Yorum Yap: Bir değişkene bir metin değeri atarken, onu tırnak işaretleri içine alın.

Yorum Yap: Bir değişkeni yeniden bildirirseniz, değerini kaybetmez.

JavaScript Yerel Değişkenleri

Bir JavaScript işlevi içinde bildirilen bir değişken, YEREL ve yalnızca bu işlev içinde kullanılabilecektir. (değişkenin yerel kapsamı vardır).

Yerel değişkenler, bildirildikleri işlevde tanındığından, farklı işlevlerde aynı ada sahip yerel değişkenler bildirebilirsiniz.

Fonksiyon çıktığında yerel değişkenler yok edilir.

Daha sonraki JavaScript derslerinde işlevler hakkında daha fazla bilgi edineceksiniz.

JavaScript Global Değişkenleri

Bir işlevin dışında bildirilen değişkenler olur KÜRESELve sayfadaki tüm komut dosyaları ve işlevler bunlara erişebilir.

Sayfayı kapattığınızda global değişkenler yok edilir.

"Var" kullanmadan bir değişken bildirirseniz, değişken her zaman olur KÜRESEL.

Belirtilmemiş JavaScript Değişkenlerine Değer Atama

Henüz bildirilmemiş değişkenlere değerler atarsanız, değişkenler otomatik olarak genel değişkenler olarak bildirilir.

Bu öneriler:

Bir sonraki JavaScript eğitiminde operatörler hakkında daha fazla bilgi edineceksiniz.

JavaScript'teki global değişkenler

Global değişkenler nelerdir: değişkenler, programın yürütülmesinin herhangi bir noktasında "görülebilir", her yerde okunabilir ve üzerine yazılabilir.
Genellikle global değişkenler, herhangi bir bloğun (()) dışında programın en başında tanımlanır.
J'ler söz konusu olduğunda, koddan veya diğer tüm işlevlerden sonra ayarlanırlar

merhaba \u003d "Merhaba"; // global bir değişken ayarlayın ve kontrol edin
document.writeln ("-\u003e 1" + merhaba + "her biri
"); // -\u003e 1 Herkese merhaba

Eğer doğruysa)
// if (yanlış)
{
var hello \u003d "Merhaba Dolly ve"; // bu da global
dünya \u003d "dünya"; // global
var cont \u003d ", devam ediyoruz" // global
document.writeln ("-\u003e 1.2" + merhaba + dünya + devam + "
");
//1.
}
document.writeln ("-\u003e 2" + merhaba + dünya + devam + "
");
// -\u003e 2 Merhaba Dolly ve dünya, devam ediyoruz

Doğruysa cevabı alırız

-\u003e Herkese 1 Merhaba
-\u003e 1.2 Merhaba Dolly ve dünya, devam ediyoruz
-\u003e 2 Merhaba Dolly ve dünya, devam ediyoruz

Yürütme iptal edildi

Bu nedenle, var kullanımının global kapsamı hiçbir şekilde etkilemediği ortaya çıktı. Bir komut dosyasında prosedürlerin dışında belirtilen bir değişken, blok için if while'ın parantezleri () içine alınmış olsa bile küresel olarak kabul edilir ve diğer kapsamlar döngülerin içinde bile global kalır

Kısaca sonuçlar

* genel kapsamda kullanılan değişkenler için var'ın varlığı önemli değildir.
* Yerel kapsam oluşturmazsa sonrasındaki engeller (diğer dillerde olduğu gibi)

Yerel değişkenler, çalıştırılabilir blok (fonksiyon) içinde ayarlanan değişkenlerdir ve diğer fonksiyonları etkilemez. ve dış çevre, yani küresel kapsam.

Boy \u003d "Jhone";
did \u003d "Kenny'yi öldürür"; // böylece 2 global değişkenimiz var
function doit ()
{
// yazdırma zaten --1 geçti ve verileri değiştiriyoruz, verileri değiştiriyoruz
var boy \u003d "Gary"; // bir yerel ayar oluştur
did \u003d "Anny'ye yardım eder"; // globali değiştir
;
document.writeln ("- 2" + boy + "" + did + "
");
// - 2 Gary, Anny'ye yardım ediyor
;
// şimdi, fonksiyonun içinde yerel ve global değişkenleri ayarlayın
var good \u003d "o iyi bir çocuktu
"; // yerel ayar!
kötü \u003d "kötü kızlardan hoşlanır
"; // genel
}
;
document.writeln ("- 1" + boy + "" + did + "
");
// - 1 Jhone Kenny'yi öldürür
yap ();
// - 2 Gary, Anny'ye yardım ediyor
document.writeln ("- 3" + boy + "" + did + "
");
// - 3 Jhone, Anny'ye yardım ediyor
;
Eğer doğruysa)
// if (! false)
{
document.writeln ("- 4" + iyi);
// bu bloğun çalıştırılması bir hata oluşturacaktır.
// şu anda yerel kapsam dışındayız
// doit () işlevi, bu nedenle bizim için var aracılığıyla verilir
// iyi değişkeni mevcut değil
}
document.writeln ("- 5" + kötü);
// - 5 kötü kızlardan hoşlanır

Sonuç:

1 Jhone Kenny'yi öldürür
--2 Gary, Anny'ye yardım eder
--3 Jhone, Anny'ye yardım ediyor
--5 kötü kızlardan hoşlanır

JavaScript'teki yerel değişkenler

* var, yerel bir değişken bildirerek bir işlev içinde çalışır. Bu onun ana görevi.

* Javascrip si'den çok farklıdır, çünkü sadece (?) Bir fonksiyon içinde yerel değişkenler mümkündür.
* var'ı kullanmak ya da genel kapsamda kullanmamak yalnızca kişisel deneyiminize bağlıdır. Ama benim için tembel olmamak daha iyi. incide buna sıkı kullanım denir

\u003e\u003e\u003e var, genel kapsamda kullanılan değişkenler için önemli değildir

Önemli. İlk olarak, "değişkenler" silinemez (silme kullanılarak). İkinci olarak, bunların somutlaştırılması "sıfır satırında" (çalışmaya "satır satır" başlamadan önce) gerçekleşir ve burada tanımsız değer hemen atanır ve ancak o zaman değişken yeni bir değer alabilir (veya almayabilir):

Var glb_1 \u003d 1;
eğer (yanlış) (var glb_2 \u003d 2; glb_3 \u003d 3;)

Alert (glb_1) // somutlaştırıldı ve 1 değerini aldı
alert (glb_2) // ortaya çıktı ve 'tanımsız' değerini aldı
alert (glb_3) // hiç değişken değil (var yok), çağırırken bir hata

Son güncelleme: 05.04.2018

Tüm JavaScript değişkenlerinin, içinde hareket edebilecekleri belirli bir kapsamı vardır.

Global Değişkenler

İşlevlerin dışında bildirilen tüm değişkenler globaldir:

Burada x ve d değişkenleri globaldir. Programın herhangi bir yerinden erişilebilirler.

Ancak z değişkeni, işlevin içinde tanımlandığı için global değildir.

Yerel değişkenler

Bir işlev içinde tanımlanan bir değişken yereldir:

İşlev displaySquare () (var z \u003d 10; console.log (z); let b \u003d 8; console.log (b);)

Z ve b değişkenleri yereldir, sadece fonksiyon içinde bulunurlar. Bir işlevin dışında kullanılamazlar:

İşlev displaySquare () (var z \u003d 10; console.log (z);) console.log (z); // z tanımsız olduğu için hata

İşlev çalışmasını bitirdiğinde, işlevde tanımlanan tüm değişkenler yok edilir.

Değişkenleri Gizleme

Ya iki değişkenimiz varsa, biri global, diğeri yerel, aynı ada sahip:

Var z \u003d 89; function displaySquare () (var z \u003d 10; console.log (z); // 10) displaySquare (); // on

Bu durumda, işlev doğrudan işlevde tanımlanan z değişkenini kullanır. Yani, yerel değişken global olanı gizleyecektir.

var ya da izin ver

Let deyimini kullanırken, her bir kod bloğu, değişkenin var olduğu yeni bir kapsamı tanımlar. Örneğin, aynı anda hem blok seviyesinde hem de fonksiyon seviyesinde bir değişken tanımlayabiliriz:

Z \u003d 10 olsun; function displayZ () (let z \u003d 20; (let z \u003d 30; console.log ("Blok:", z);) console.log ("Fonksiyon:", z);) displayZ (); console.log ("Global:", z);

Burada, displayZ fonksiyonunun içinde, z değişkeninin tanımlandığı bir kod bloğu tanımlanır. Global değişkeni ve işlev düzeyi z değişkenini gizler. Gerçek bir programda, bir blok yuvalanmış bir işlevi, bir for döngüsünü veya if ifadelerini temsil edebilir. Ancak her durumda, böyle bir blok, dışında değişkenin olmadığı yeni bir kapsamı tanımlar.

Ve bu durumda, aşağıdaki konsol çıktısını alıyoruz:

Blok: 30 Fonksiyon: 20 Global: 10

Var ifadesiyle, bu işlevde hem bir işlevde hem de bir kod bloğunda aynı ada sahip bir değişkeni aynı anda tanımlayamayız:

İşlev displaySquare () (var z \u003d 20; (var z \u003d 30; // Hata! Değişken z zaten tanımlanmış console.log ("Blok:", z);) console.log ("Function:", z);)

Yani, var kullanarak, işlev düzeyinde veya kod bloğu düzeyinde aynı ada sahip bir değişken tanımlayabiliriz.

Sabitler

Let deyimiyle ilgili her şey, sabitleri tanımlamanıza izin veren const deyimi için de geçerlidir. Kod blokları sabitlerin kapsamını tanımlar ve iç içe kod bloklarında tanımlanan sabitler, aynı ada sahip harici sabitleri gizler:

Sabit z \u003d 10; function displayZ () (const z \u003d 20; (const z \u003d 30; console.log ("Blok:", z); // 30) console.log ("Fonksiyon:", z); // 20) displayZ ( ); console.log ("Global:", z); // on

Belirtilmemiş değişkenler

Bir fonksiyonda bir değişken tanımlarken bu anahtar kelimeyi kullanmazsak, böyle bir değişken global olacaktır. Örneğin:

İşlev çubuğu () (foo \u003d "25";) bar (); console.log (foo); // 25

Foo, bar işlevinin dışında herhangi bir yerde tanımlanmamış olsa da, dış bağlamda işlevin dışında da kullanılabilir.

Değeri yalnızca değişkene atamakla kalmayıp, aynı zamanda onu da tanımlasaydık farklı olurdu:

İşlev çubuğu () (var foo \u003d "25";) bar (); console.log (foo); // hata

katı mod

Fonksiyonlarda global değişkenlerin tanımlanması potansiyel hatalara yol açabilir. Bunlardan kaçınmak için katı mod veya katı mod kullanılır:

"sıkı kullanın"; function bar () (foo \u003d "25";) bar (); console.log (foo);

Bu durumda, foo değişkeninin tanımlanmadığını gösteren SyntaxError: Beklenmeyen tanımlayıcı hatası alacağız.

Katı modu ayarlamanın iki yolu vardır:

javaScript kodunun başına "katı kullan" ifadesini eklerseniz, katı mod tüm koda uygulanacaktır.

işlev gövdesinin başına "katı kullan" ifadesini eklerseniz, katı mod yalnızca bu işlev için uygulanacaktır.

Bu dört bölümlük ders, uzun bir süre sonra projeye geri dönmeniz gerekse bile, bakımı ve geliştirilmesi kolay kaliteli JavaScript kodunun nasıl yazılacağını araştırıyor.

Korunması gerekeceği beklentisiyle kod yazın

Yazılım hatalarının bir bedeli vardır. Maliyetleri, onları düzeltmek için geçen süre cinsinden ifade edilir. Halka açık projelerdeki hatalar özellikle maliyetlidir. Kodun yapısı hafızada hala tazeyken hataları hemen düzeltebilmeniz ve sorunlu bölgeyi hızlıca bulabilmeniz çok iyidir. Ancak diğer görevlere geçtiyseniz ve belirli bir kodun özelliklerini zaten kısmen unuttuysanız, projeye geri dönmeniz şunları gerektirecektir:

• Sorunu inceleme ve anlama zamanı.
• Sorunun kaynağı olan kodu anlama zamanı.

Büyük projeleri veya şirketleri etkileyen bir başka sorun da, hataları onaran kişinin onları yaratan kişi olmamasıdır (ve genellikle onları projede bulan kişi değildir). Bu nedenle, kodu anlamak için süreyi azaltmak, kodu bir süre önce kendiniz yazmış olsanız da ekibinizdeki başka bir geliştirici tarafından yazılmış olsa da kritik bir sorun haline gelir. Sorunun cevabı, hem projenin finansal sonucunu hem de geliştiricilerin memnuniyet düzeyini önemli ölçüde etkileyecektir, çünkü bazen her şeyi yeni bir şekilde yapmak, eski anlaşılmaz kodu korumak için saatler ve günler harcamaktan daha iyidir.

Yazılım geliştirmeyle ilgili bir diğer gerçek ise, genellikle daha uzun sürmesidir. okuma kod oluşturmak değil. Problemin ilk ayarında, geliştirici soruya odaklanır ve kendini konuya kaptırır ve sonra oturur ve bir akşam önemli kodlar oluşturabilir. Daha sonra kod muhtemelen çalışır, ancak yazılım ürünlerinin doğal doğası gereği, kodun tekrar tekrar revize edilmesini gerektiren durumlar ortaya çıkar. Örneğin:

• Hatalar belirlenir.
• Projeye yeni özellikler eklendi.
• Uygulama yeni bir ortamda başlatılmalıdır (örneğin, yeni bir tarayıcı ortaya çıktı).
• Kodun amacı değişiyor.
• Kodun tamamen yeniden yazılması veya başka bir mimariye veya programlama diline aktarılması gerekir.

Sonuç olarak, kodu yazmak birkaç adam-saat ve okumak için birkaç adam-gün sürecektir. Bu nedenle, bakımı kolay kod oluşturmak, uygulamanızın başarısı için çok önemlidir.

Bakımı kolay kod aşağıdaki özelliklere sahiptir:

• Okuması kolay.
• İyi yapılandırılmış ve parçalar birbirine uyuyor.
• Tahmin edilebilir.
• Görünüşe göre bir kişi tarafından yazılmış.
• Belgelenmiş.

Global değişkenlerin kullanımını en aza indirme

JavaScript, bağlamı değiştirmek için işlevler kullanır. İşlevlerin içinde bildirilen değişkenler onlar için yereldir ve işlevlerin dışında kullanılamaz. Global değişkenler, işlevlerin dışında bildirilir veya bildirim olmaksızın basitçe kullanılır.

Her JavaScript ortamında, işlevlerin dışında kullanılan genel bir nesne vardır. Oluşturduğunuz her global değişken, global nesnenin bir özelliği haline gelir. Kolaylık sağlamak için tarayıcılar, (genellikle) global nesnenin kendisine işaret eden, pencere adı verilen genel nesnenin ek bir özelliğine sahiptir. Aşağıdaki kod, tarayıcı ortamında genel değişkenler oluşturma ve bunlara erişme örneğini gösterir:

Var myglobal \u003d "merhaba"; console.log (myglobal); // "merhaba" console.log (window.myglobal); // "merhaba" console.log (window ["myglobal"]); // "merhaba" console.log (this.myglobal); // "Merhaba"

Global değişkenlerle ilgili sorunlar

Global değişkenlerle ilgili sorun, uygulamanızın veya sayfanızın JavaScript kodu boyunca kullanılabilecek olmalarıdır. Global ad alanındadırlar ve uygulamanın iki farklı bölümü aynı adla ancak farklı amaçlarla global değişkenleri tanımladığında her zaman çakışmaları adlandırma şansı vardır.

Ayrıca, tipik olarak bir web sayfası diğer geliştiriciler tarafından yazılan kodu içerir. Örneğin:

• Diğer JavaScript kitaplıkları.
• Reklam ortağı komut dosyaları.
• Kullanıcı izleme ve analiz kodu.
• Çeşitli widget'lar, düğmeler ve eklentiler.

Diyelim ki üçüncü taraf komut dosyalarından biri, örneğin sonuç adı verilen global bir değişkeni tanımlıyor. Ardından, işlevlerinizden birinde başka bir global değişken tanımlar ve buna sonuç adını verirsiniz. Sonuç olarak, sonuç değişkeninin son bildirimi ilkini geçersiz kılar ve üçüncü taraf komut dosyası çalışmayı durdurabilir.

Bu nedenle, aynı sayfada farklı kodu başarılı bir şekilde birleştirmek için olabildiğince az genel değişken kullanmak önemlidir. Bu soruda, değişkenleri bildirirken var direktifinin kullanılması önemli bir rol oynar.

Ne yazık ki, iki özellik nedeniyle JavaScript'te yanlışlıkla global bir değişken oluşturmak çok kolaydır. İlk olarak, bir değişkeni bildirmeden kullanabilirsiniz. İkinci olarak, JavaScript'in dolaylı bir genel tanımı vardır; bu, bildirilmemiş herhangi bir değişkenin genel nesnenin bir özelliği haline geleceği (ve uygun şekilde bildirilmiş bir genel değişken olarak erişileceği) anlamına gelir. Örneğin:

İşlev toplamı (x, y) (// kötü: örtük genel sonuç \u003d x + y; sonuç döndür;)

Bu kodda sonuç değişkeni bildirim olmadan kullanılır. Kod harika çalışıyor, ancak işlevi çağırdıktan sonra, genel ad alanında başka bir sonuç değişkeni alacaksınız ve bu da sorunlara yol açabilir.

Küçültme kuralı, değişkenleri var direktifini kullanarak tanımlamaktır. Aşağıda sum () işlevinin geliştirilmiş bir sürümü bulunmaktadır:

İşlev toplamı (x, y) (var sonuç \u003d x + y; sonuç döndür;)

Zımni küreseller oluşturmak için başka bir kötü seçenek, bir var bildirimi içinde bir değer zincirlemektir. Aşağıdaki örnekte, a değişkeni yerel olacak ve b değişkeni global hale gelecektir, bu muhtemelen kod oluşturucunun hedefler listesinde yer almamaktadır:

// kötü, foo () işlevini kullanma (var a \u003d b \u003d 0; // ...)

Olanlara şaşırırsanız, bu sağdan sola bir hesaplamadır. İlk olarak b \u003d 0 ifadesi çalıştırılır ve bu nedenle b değişkeni bildirilmez. İfadenin dönüş değeri 0 olacaktır ve bu, var yönergesi tarafından bildirilen yeni yerel değişken a'ya atanır. Bu değişken tanımı aşağıdaki gösterime eşdeğerdir:

Var a \u003d (b \u003d 0);

Değişkenleri önceden tanımladıysanız, zincirleme görünüm iyi çalışır ve istenmeyen globaller oluşturmaz:

Fonksiyon foo () (var a, b; a \u003d b \u003d 0; // her iki değişken de yereldir)

Global değişkenleri kullanmaktan kaçınmanın bir başka nedeni taşınabilirliktir. Kodunuzu farklı bir ortamda çalıştırmayı planlıyorsanız, global değişkenler orijinal ortamda olmayan nesnelerin üzerine yazabilir (bu nedenle, kullanılan ad güvenli gibi görünebilir).

Unutulmuş var beyanının yan etkisi

Açıkça tanımlanmış ve zımni küreseller arasında küçük bir fark vardır. Silme operatörünü kullanarak bir değişkeni silme yeteneğinden oluşur:

• Bir var bildirimiyle bildirilen (programdaki işlevlerin dışında oluşturulan) genel değişken silinemez.
• Bildirim olmadan oluşturulan örtük bir global değişken (nerede oluşturulduğuna bakılmaksızın) silinebilir.

Teknik olarak, zımni bir global değişken, bir değişken değil, global nesnenin bir özelliğidir. Özellikler silme operatörü kullanılarak silinebilir ancak değişkenler şunları yapamaz:

// üç global değişken tanımlayın var global_var \u003d 1; global_novar \u003d 2; // kötü (işlev () (global_fromfunc \u003d 3; // kötü) ()); // delete global_var; // yanlış sil global_novar; // true sil global_fromfunc; // true // silmeyi kontrol edin typeof global_var; // "sayı" typeof global_novar; // "tanımsız" typeof global_fromfunc; // "Tanımsız"

Global nesneye erişim

Tarayıcılarda, global nesne kodun herhangi bir yerinde pencere özelliği aracılığıyla kullanılabilir (pencere adında yerel bir değişken bildirmek gibi özel veya beklenmedik bir şey yapmadığınız sürece). Ancak diğer ortamlarda, bu kullanışlı özellik başka bir şekilde mevcut olabilir (veya programcı için hiç mevcut olmayabilir). Pencere tanımlayıcısını kullanmadan global nesneye erişmeniz gerekiyorsa, aşağıdaki yöntemi iç içe geçmiş işlev ad alanının herhangi bir düzeyinde kullanabilirsiniz:

Var global \u003d (function () (bunu döndür;) ());

Bu nedenle, global nesneye erişmek her zaman mümkündür, çünkü bir işlev olarak adlandırılan bir işlevin içinde (ve yeni bir bildirime sahip bir kurucu olarak değil) bu her zaman global nesneyi işaret eder.

Tek değişkenli bildirim şablonu

İşlevinizin tepesinde tek bir değişken bildirimi kullanmak çok yararlı bir uygulamadır. Bu yöntemin aşağıdaki avantajları vardır:

• Bir işlevin tüm yerel değişkenlerini bildirmek için tek bir yer sağlar.
• Boole hataları, bir değişken bildirilmeden önce kullanıldığında önlenir.
• Yerel değişkenleri bildirmeyi hatırlamanıza yardımcı olur ve bu nedenle genel değişkenlerin sayısını azaltır.

Tek değişken bildirimine sahip bir şablon şuna benzer:

İşlev func () (var a \u003d 1, b \u003d 2, toplam \u003d a + b, nesnem \u003d (), i, j; // İşlev kodu ...)

Virgülle ayrılmış birden çok değişkeni bildirmek için bir değişken bildirimi kullanıyorsunuz. Mükemmel bir ekleme, değişkenleri bildirildiklerinde orijinal verilerle başlatmak olacaktır. Bu, mantıksal hataları önler (tüm başlatılmamış değişkenler varsayılan olarak tanımsızdır) ve kodun okunabilirliğini artırır. Koda daha sonra baktığınızda, bir değişkenin amacını başlangıç \u200b\u200bdeğerine göre nasıl belirleyebilirsiniz (örneğin, onun bir nesne veya bir tam sayı olduğunu hemen göreceksiniz).

Önceki örnek koddan sum \u003d a + b gibi bir değişken bildirirken de bir işlem gerçekleştirebilirsiniz. DOM manipülasyonu başka bir çalışma örneğidir. Yerel değişkenlere DOM öğelerine başvurular atarken şunları bildirebilirsiniz:

Function updateElement () (var el \u003d document.getElementById ("result"), style \u003d el.style; // el ve style ile işlemler yap ...)

Kaldırma: dağınık varyasyon bildirimleriyle ilgili sorun

JavaScript, bir işlevin herhangi bir yerinde birden çok değişken bildirimine izin verir ve nereye yerleştirildiklerine bakılmaksızın aynı şekilde çalışırlar. Bu özellik "kaldırma" olarak bilinir. Bu davranış, bir değişken kullandığınızda mantıksal hatalara neden olabilir ve daha sonra onu daha fazla işlev kodu için bildirir. JavaScript için, bir değişken aynı isim alanında (aynı işlevde) olduğu için, var direktifinden önce kullanılsa bile bildirildiği varsayılır. Örneğin

// kötü adim \u003d "global"; // genel değişken function func () (alert (myname); // "tanımsız" var myname \u003d "local"; alert (myname); // "yerel") func ();

Bu örnekte, birinci alert () çağrısının "global" mesajını ve ikincisinin "yerel" mesajını üretmesi beklenmektedir. Bu makul bir beklentidir, çünkü ilk çağrıda myname yerel değişkeni bildirilmez ve işlev global değişken myname'i kullanmak zorundadır. Ancak gerçekte her şey farklı çalışır. İlk alert () çağrısı, "tanımsız" sonucunu döndürür çünkü myname, işlevde bildirilmiş bir yerel değişken olarak ele alınır (daha sonra bildirilecek olmasına rağmen). Tüm değişken bildirimleri fonksiyona kaldırılır. Bu nedenle, bu tür bir hatayı önlemek için, tüm değişkenleri işlevin üst kısmında bildirmeniz gerekir.

Önceki örnek şu şekilde uygulanmış gibi davranacaktır:

Myname \u003d "global"; // genel değişken işlevi func () (var myname; // ile aynı -\u003e var myname \u003d tanımsız; alert (myname); // "tanımsız" myname \u003d "yerel"; alert (myname); // " yerel ") func ();

Kodun gerçek uygulamasının daha karmaşık olduğunu belirtmekte fayda var. Kod işlemenin iki aşaması vardır. İlk aşama değişkenler, işlev bildirimleri ve biçimsel parametreler oluşturur ve bağlamı tanımlar. İkinci aşama kodu yürütür, fonksiyonları değerlendirir ve nitelenmemiş tanımlayıcılar (bildirilmemiş değişkenler) oluşturur. Ancak pratik kullanım için, kodun davranışını iyi tanımlayan kaldırma kavramı kullanılabilir.