Hata örnekleri js global değişkenleri. JavaScript. Değişkenler (global, yerel, sabitler). Küresel nesnelerin özellikleri

Javascript'te küresel değişkenler

Global değişkenler nelerdir: program yürütmenin herhangi bir noktasında "görünür" olan ve her yerde okunabilen ve üzerine yazılabilen değişkenler.
Tipik olarak global değişkenler programın en başında herhangi bir bloğun (()) dışında tanımlanır.
J'ler söz konusu olduğunda, komut dosyasından veya her türlü işlevden sonra ayarlanırlar

merhaba = "Merhaba"; //global bir değişken ayarlayıp kontrol ediyoruz
document.writeln("->1 "+ merhaba +" her biri
");//->1 Herkese merhaba

Eğer doğruysa)
//eğer(yanlış)
{
var hello = "Merhaba Dolly ve "; //bu aynı zamanda globaldir
dünya = "dünya"; //küresel
var cont = ", devam ediyoruz" //global
document.writeln("->1.2 " + merhaba + dünya + devam+"
");
//1.
}
document.writeln("->2 " + merhaba + dünya + devam+"
");
//->2 Merhaba Dolly ve dünya, devam ediyoruz

Eğer doğruysa cevabı alırız

->1 Herkese merhaba
->1.2 Merhaba Dolly ve dünya, devam ediyoruz
->2 Merhaba Dolly ve dünya, devam ediyoruz

Yürütme iptal edilir

Dolayısıyla var kullanımının küresel kapsam üzerinde hiçbir etkisinin olmadığı ortaya çıktı. Prosedürlerin dışında bir komut dosyasında adı geçen bir değişken, if while for bloğunda parantez () içine alınmış olsa bile küresel olarak kabul edilir ve diğer alanlar, döngülerin içinde bile küresel kalacaktır.

Kısaca sonuçlar

* Küresel görünürlük bölgesinde kullanılan değişkenler için var'ın varlığı önemli değildir.
* if while for'dan sonraki bloklar yerel kapsam oluşturmaz (diğer dillerde olduğu gibi)

Yerel değişkenler yürütülebilir blok (fonksiyon) içinde tanımlanan değişkenlerdir ve diğer fonksiyonları etkilemezler. ve dış ortam, yani küresel alan.

Oğlan = "Jhone";
did = "Kenny'yi öldürdü"; // yani 2 global değişkenimiz var
işlev doit()
{
//print zaten --1'i geçti ve verileri değiştiriyoruz verileri değiştiriyoruz
var boy = "Gary"; //yerel ayar oluştur
did = "Anny'ye yardım eder"; // globali değiştir
;
document.writeln("--2 " + oğlan + " " + yaptı + "
");
//--2 Gary, Anny'ye yardım ediyor
;
//şimdi fonksiyonun içinde yerel ve global değişkenleri ayarlayacağız
var good = "iyi bir çocuktu
";//yerel ayar!
kötü = "kötü kızlardan hoşlanıyor
";//genel
}
;
document.writeln("--1 " + oğlan + " " + yaptı + "
");
//--1 Jhone Kenny'yi öldürür
yap();
//--2 Gary, Anny'ye yardım ediyor
document.writeln("--3 " + oğlan + " " + yaptı + "
");
//--3 Jhone, Anny'ye yardım ediyor
;
Eğer doğruysa)
//eğer(!yanlış)
{
document.writeln("--4 " + iyi);
//bu bloğun çalıştırılması hataya neden olacaktır.
//artık yerel kapsamın dışındayız
//doit() fonksiyonu, dolayısıyla bize var aracılığıyla verildi
//iyi değişkeni basitçe mevcut değil
}
document.writeln("--5 " + hatalı);
//--5 kötü kızlardan hoşlanıyor

Sonuç:

1 Jhone Kenny'yi öldürdü
--2 Gary, Anny'ye yardım ediyor
--3 Jhone, Anny'ye yardım ediyor
--5 kötü bir kızdan hoşlanıyor

Javascript'teki yerel değişkenler

* var bir fonksiyonun içinde çalışır ve yerel bir değişken bildirir. Bu onun asıl görevi

* Javascript, bir fonksiyonun içinde yalnızca(?) yerel değişkenlerin mümkün olması açısından C'den çok farklıdır.
* var'ı global kapsamda kullanıp kullanmamak yalnızca kişisel deneyiminize bağlıdır. Ama benim için tembel olmamak daha iyi. Perl'de buna sıkı kullanım denir

>>>küresel görünürlük bölgesinde kullanılan değişkenler için var'ın varlığı önemli değildir

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

Var glb_1 = 1;
if (false) (var glb_2 = 2; glb_3 = 3;)

Alert(glb_1) // başlatıldı ve 1 değeri verildi
uyarı(glb_2) // belirtildi ve 'tanımsız' değeri alındı
uyarı(glb_3) // hiç değişken değil (var değil), erişim sırasında hata

JavaScript'in üç kapsamı vardır: genel, işlev ve blok kapsamı. Değişken kapsamı, bir programın kaynak kodunda değişkenlerin ve işlevlerin görülebildiği ve kullanılabildiği alandır. Küresel kapsama aynı zamanda üst düzey kod da denir.

Küresel Değişkenler

Bir fonksiyonun veya bloğun dışında bildirilen değişkene global denir. Global değişken kaynak kodun herhangi bir yerinde mevcuttur:

Var sayısı = 5; function foo() ( console.log(num); ) foo(); // 5 console.log(sayı); // 5 ( console.log(sayı); // 5 )

Yerel değişkenler

Bir fonksiyonun içinde bildirilen değişkene yerel denir. Yerel bir değişkene, bildirildiği işlevin gövdesi içinde herhangi bir yerden erişilebilir. Yerel değişken, işlev her çağrıldığında yeniden oluşturulur ve işlevden çıkıldığında (işlev tamamlandığında) yok edilir:

Function foo() ( var sayi = 5; console.log(sayı); ) foo(); // 5 console.log(typeof sayi); //Tanımsız

Yerel değişken, aynı adı taşıyan global değişkene göre önceliklidir; bu, bir fonksiyonun içinde global değişken yerine yerel değişkenin kullanılacağı anlamına gelir:

Var x = "küresel"; // Global değişken işlevi checkscope() ( var x = "local"; // Global değişkenle aynı adı taşıyan yerel değişken document.write(x); // Global değişken değil, yerel değişken kullanın) checkscope() ; // => "yerel" Deneyin »

Değişkenleri Blokla

Let anahtar sözcüğü kullanılarak bir bloğun içinde bildirilen değişkene blok değişkeni adı verilir. Bir blok değişkenine, bildirildiği bloğun herhangi bir yerinden erişilebilir:

Sayı = 0 olsun; ( let sayı = 5; console.log(sayı); // 5 ( let sayı = 10; console.log(sayı); // 10 ) console.log(sayı); // 5 ) console.log(sayı) ; // 0

Yeniden duyuru

Aynı adda (aynı kapsamda) bir değişkeni yeniden bildirmek için var anahtar sözcüğünü kullanırsanız, hiçbir şey olmaz:

Var a = 10; var a; console.log(a); // 10

Yeniden bildirime bir başlatma eşlik ediyorsa, bu tür bir ifade, yeni bir değerin normal ataması gibi davranır:

Var a = 10; var a = 5; // a = 5 ile aynı; console.log(a); // 5

Aynı ada sahip (aynı kapsamdaki) bir değişkeni yeniden bildirmek için let anahtar sözcüğünü kullanırsanız, bir hata atılır:

Var a = 10; a'ya izin ver; // Hata.

Kapsam zinciri

Aşağıdaki örneği düşünün:

Var sayısı = 5; function foo() ( var sayi2 = 10; function bar() ( var sayi3 = 15; ))

Bu kodun üç kapsamı vardır: global, foo() işlev kapsamı ve bar() işlev kapsamı. Global kapsam, num değişkenini ve foo() fonksiyonunu tanımlar. foo() fonksiyonunun kapsamı num2 değişkenini ve bar() fonksiyonunu tanımlar ve global kapsamdaki num değişkeni de burada mevcuttur. bar() işlevinin kapsamı, yalnızca bar() işlevi içinden erişilebilen bir değişken olan num3'ü içerir. bar() işlevinin kapsamı, diğer iki kapsamdaki değişkenlere de erişebilir çünkü bunlar onun ebeveynleridir. Bu örneğin kapsam zinciri aşağıdaki şekilde gösterilmektedir:

Şekilde farklı görünürlük alanları farklı renkteki dikdörtgenlerle gösterilmiştir. Bir kapsamlar zincirindeki iç kapsamın, dış kapsamlardaki her şeye erişimi vardır, ancak dış kapsamların, iç kapsamlardan hiçbir şeye erişimi yoktur.

Kapsam zinciri sıralanır. Yorumlayıcı, kapsam zincirindeki tanımlayıcıları içeriye değil dışarıya doğru arar. Bu, ad aramasının tanımlayıcıya erişilen kapsamdan başladığı anlamına gelir. Kimlik adı bulunursa arama durdurulur. Eğer bir isim mevcut kapsamda bulunamazsa bir sonraki (dış) kapsamda vb. arama yapılır. Böylece bulunduğu kapsamdaki tanımlayıcı kullanılacaktır. Tanımlayıcı kapsamların hiçbirinde bulunamazsa, JavaScript bir hata üretecektir:

Var str = "küresel"; var sayısı = 5; function foo() ( var str = "local"; // Yerel değişken kullanılıyor str num = 10; // Global değişken num kullanılıyor // uyarı(x); // Hata. x değişkeni herhangi bir kapsamda değil ) foo( ) ; uyarı(str); // "genel" uyarı(sayı); // 10

Bir fonksiyonun gövdesinde bildirilmemiş bir değişkene değer atarsanız, fonksiyon çağrıldığında, global kapsamda aynı isimde bir değişken yoksa yeni bir global değişken yaratılacaktır:

foo() işlevi ( sayı = 2; ) foo(); // Yeni bir global değişken oluşturuldu num warning(num); // 2

Reklamların yükselişi

JavaScript'te, bildirilen değişkenlere kapsamlarına göre her yerden erişilebilir; bu, değişkenlerin kodda bildirilmeden önce bile görülebileceği anlamına gelir. JavaScript'in bu özelliğine gayri resmi olarak kaldırma denir: program kodu, değişken bildirimleri örtülü olarak (başlatma olmadan) kapsamlarının en üstüne kaldırılmış gibi davranır.

Aşağıdaki kod parçacığını göz önünde bulundurun:

Var str = "küresel"; function foo() ( uyarı(str); // tanımsız var str = "yerel"; uyarı(str); // "yerel" ) foo();

Koda baktığınızda, yerel değişken str'nin bildirimi henüz yapılmadığından ilk uyarının "global" dizesini yazdırması gerektiğini düşünebilirsiniz. Ancak gerçekte unDefinition değerini verir. Bildirimleri yükselterek, yukarıdaki işlev, değişken bildiriminin işlevin başlangıcına yükseltildiği aşağıdaki uygulamaya eşdeğerdir:

Function foo() ( var str; // Fonksiyonun başlangıcında yerel bir değişkenin bildirimi warning(str); // Burada mevcut ancak başlatılmamış str = "local"; // Burada başlatıldı uyarı( str); // Ve burada beklenen değer var - "local")

Aynısı global kapsam için de geçerlidir; altta bildirilen değişkene üstten erişilebilir:

Uyarı(sayı); // tanımsız var sayısı = 10; uyarı(sayı); // 10

JavaScript'te değişkenler ve sabitler. Değişkenleri bildirmek ve onlara değer atamak. Küresel ve yerel değişkenler. Sabitleri kullanma

JavaScript'te Değişkenleri Bildirmek

JavaScript'teki değişken adları harflerden, rakamlardan, $ işaretinden ve _ işaretinden oluşabilir ve değişken adı bir sayıyla başlayamaz. JavaScript'in büyük/küçük harfe duyarlı olduğunu ve a1 ile A1 değişkenlerinin farklı değişkenler olduğunu unutmayın. Mümkün olmasına rağmen Kiril alfabesinin kullanılması önerilmez.
JavaScript'teki değişkenler var anahtar sözcüğüyle bildirilir:

Var Peremennaya_1 var Peremennaya_2

JavaScript'te değişkenlerin bildirimsiz kullanılması önerilmez. Bu mümkündür ancak hatalara yol açabilir.

Değişkenlere Değer Atama

JavaScript'te bildirilen değişkenlere değer atama:

Peremennaya_1 = 25 Peremennaya_2 = "Atanan metin düz tırnak işaretleri içine alınmıştır"

Bildirimden hemen sonra değişkenlere bir değer atayabilirsiniz:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Atanan metin düz tırnak işaretleri içine alınmıştır"

JavaScript'teki bir değişkenin değeri programın yürütülmesi sırasında değişebilir. Bir değişkene metin yazarken düz tırnak içine alınmalıdır.

Yerel ve küresel değişkenler

Bir değişken bir fonksiyonun içinde bildirilirse, o zaman yereldir ve yalnızca bu fonksiyon içinde erişilebilir (görünür) olacaktır. Bir işlevden çıkıldığında, JavaScript'teki yerel değişkenler yok edilir, böylece aynı addaki değişkenleri farklı işlevlerde kullanabilirsiniz.

Bir değişken işlevlerin dışında bildirilirse, bu durumda bu değişken globaldir ve sayfadaki tüm işlevlerde kullanılabilir (görünür) olacaktır. Sayfa kapatıldığında JavaScript'te genel değişkenler yok edilir.

JavaScript'teki sabitler

Sabitler, tekrarlanan değerleri veya ifadeleri kullanmanız gerektiğinde kodunuzun çalışmasını kolaylaştırmak için tasarlanmıştır. Sabitin değerini bir kez ayarlamanız yeterlidir ve programlarınızın kodlarına ekleyerek istediğiniz kadar kullanabilirsiniz. JavaScript'in sabitleri bildirecek bir anahtar sözcüğü yoktur; sabitler yerine normal değişkenler kullanılır. Sabitleri değişkenlerden ayırmak için genellikle büyük harflerle gösterilirler ve gerekirse alt çizgi kullanılır:

Var DRUG_CHELOVEKA = "Köpek"

Verilen sabit örneği tam olarak tamamlanmamıştır, çünkü “Köpek” kelimesinin hatırlanması ve ihtiyaç duyulan yere eklenmesi zaten kolaydır. Hatırlanması zor kodlar, karakter kümeleri, uzun metinler, web adresleri, e-posta adresleri, telefon numaraları ve çeşitli oranlar gibi daha karmaşık değerleri kaydetmek ve eklemek için JavaScript'teki sabitleri kullanabilirsiniz.

JavaScript'te sabitler değişkenler olarak yeniden yazılabilir, ancak bunu yaparsanız sabitlerin anlamı kaybolur.

Son güncelleme: 04/05/2018

JavaScript'teki tüm değişkenlerin, içinde hareket edebilecekleri belirli bir kapsamı vardır.

Küresel Değişkenler

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

var x = 5; d = 8 olsun; function displaySquare())( var z = x * x; console.log(z); )

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

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

Yerel değişkenler

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

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

z ve b değişkenleri yereldir, yalnızca fonksiyonun içinde bulunurlar. Bir fonksiyonun dışında kullanılamazlar:

Function displaySquare())( var z = 10; console.log(z); ) console.log(z); //hata çünkü z tanımlı değil

Bir fonksiyon işini bitirdiğinde fonksiyonda tanımlanan tüm değişkenler yok edilir.

Değişkenleri Gizleme

Peki ya aynı ada sahip iki değişkenimiz (biri global, diğeri yerel) varsa:

Var z = 89; function displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

Bu durumda fonksiyon, doğrudan fonksiyonda tanımlanan z değişkenini kullanacaktır. Yani yerel değişken global olanı gizleyecektir.

var veya izin ver

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

z = 10 olsun; function displayZ())( let z = 20; ( let z = 30; console.log("Blok:", z); ) console.log("Fonksiyon:", z); ) displayZ(); console.log("Genel:", z);

Burada displayZ fonksiyonunun içerisinde z değişkeninin tanımlandığı bir kod bloğu bulunmaktadır. Fonksiyon seviyesinde tanımlanan global değişkeni ve z değişkenini gizler. Gerçek bir programda, bir blok iç içe geçmiş bir işlevi, bir for döngü bloğunu veya bir if yapısını temsil edebilir. Ancak her durumda böyle bir blok, dışında değişkenin bulunmadığı yeni bir kapsamı tanımlar.

Ve bu durumda aşağıdaki konsol çıktısını elde edeceğiz:

Blok: 30 Fonksiyon: 20 Genel: 10

Var operatörüyle, hem bir fonksiyonda hem de o fonksiyonun içindeki bir kod bloğunda aynı isimde bir değişken tanımlayamayız:

Function displaySquare())( var z = 20; ( var z = 30; // Hata! z değişkeni zaten tanımlı console.log("Blok:", z); ) console.log("Fonksiyon:", z) ;)

Yani var ile tek isimli bir değişkeni ya fonksiyon seviyesinde ya da kod bloğu seviyesinde tanımlayabiliriz.

Sabitler

Let operatörü için geçerli olan her şey, sabitleri tanımlamanıza olanak tanıyan const operatörü için de geçerlidir. Kod blokları, sabitlerin kapsamını tanımlar ve iç içe geçmiş kod bloklarında tanımlanan sabitler, aynı adı taşıyan harici sabitleri gizler:

Sabit z = 10; function displayZ())( const z = 20; ( const z = 30; console.log("Blok:", z); // 30 ) console.log("Fonksiyon:", z); // 20 ) displayZ ( ); console.log("Genel:", z); // 10

Bildirilmemiş değişkenler

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

Fonksiyon bar())( foo = "25"; ) bar(); console.log(foo); // 25

Foo değişkeni bar fonksiyonunun dışında herhangi bir yerde tanımlanmamış olsa da, yine de harici bağlamda fonksiyonun dışında mevcuttur.

Bir değişkene yalnızca değer atamakla kalmayıp onu tanımlasaydık farklı olurdu:

Fonksiyon bar())( var foo = "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ı modu kullanın:

"katı kullanın"; function bar())( foo = "25"; ) bar(); console.log(foo);

Bu durumda, foo değişkeninin tanımlanmadığını gösteren SyntaxError: Unexpected identifier hatasını alırız.

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

JavaScript kodunun başına "use strict" ifadesini ekleyin, ardından katı mod tüm kodlara uygulanacaktır

işlev gövdesinin başına "use strict" ifadesini eklerseniz katı mod yalnızca bu işleve uygulanacaktır

İyi günler, JavaScript hayranları ve sadık abonelerim. Bugünkü yazımda sizlere JavaScript'te global ve local değişkenlerin nasıl oluşturulduğunu detaylı olarak anlatacağım. Kesinlikle önemli terimleri tanımlayacağım, değişkenleri bildirme ve başlatma özelliklerinden bahsedeceğim, kapsamın ne olduğunu ve oluşturulan öğelerin içinde nasıl çalıştığını anlatacağım.

Bütün bunlar dilin en temel, temel bilgisi için geçerlidir. Tüm bunları anlamadan ilerlemeniz ve js programlama becerilerinizi geliştirmeniz mümkün olmayacaktır. Ayrıca anahtar kavramlar sadece bu uzmanlıkta değil genel olarak BT alanında da işinize yarayacaktır. Peki, haydi başlayalım!

Değişken nedir ve nasıl oluşturulur?

Değişken, bir hafıza alanının tahsis edildiği ve belirli değerlerin saklandığı bir programlama dilinin bir öğesidir.

Çok sayıda değişken olabilir ve hepsinin benzersiz bir adı olmalıdır.

İki tür değişken vardır: küresel ve yerel. Aralarındaki fark yalnızca değişkenlerin farklı kapsamlarında yatmaktadır. Böylece, global öğeler kodun tamamında görünür, yerel öğeler ise yalnızca bildirildikleri küçük alanda görünür.

Bu arada ilk günden itibaren, ilk kodunuzdan itibaren elemanları mantıklı ve anlaşılır isimlerle adlandırmaya çalışın. Çünkü daha sonra ağır programlarla çalıştığınızda bir süre sonra örneğin “aa1” veya “perem3”ün ne anlama geldiğini hatırlamayacaksınız.

Ve başlıktan kesinlikle hiçbir şey net değil! Bu o kadar da kötü değil sonuçta, kendi yazılarınızı anlamak o kadar da zor değil. Daha önce adını bile duymadığınız başka bir programda görevleri tamamlama görevi size verilirse ne yapacaksınız? Bu tür adlarla yazılım uygulamasını analiz etmek, çok fazla yararlı zaman kaybına yol açacaktır.

Gösterimi okudum, şimdi değişkenleri bildirmeye geri dönelim.

Bir değişken oluşturmak için önce var anahtar kelimesini, ardından adın kendisini yazmalısınız. Şuna benziyor:

var text = “Merhaba kullanıcı!”

Bundan sonra metne “var” olmadan erişilir:

metin = “Yeni metin.”

Bu durumda değerin üzerine yazılacaktır.

Daha iyi anlamak için tek bir değişkenin oluşturulduğu bir örneği düşünün. Yeniden yazmadan önce ve sonra anlamına döneceğiz.

1 2 3 4

var text = “Merhaba kullanıcı!”; uyarı(metin); // “Merhaba kullanıcı!” yazacaktır. metin= “Yeni metin!”; uyarı(metin); // “Yeni metin!” yazdıracak

var text = “Merhaba kullanıcı!”; uyarı(metin); // “Merhaba kullanıcı!” yazacaktır. metin= “Yeni metin!”; uyarı(metin); // “Yeni metin!” yazdıracak

Küresel nesnelerin özellikleri

Js kodunda oluşturulan tüm nesneler global ve yerel olarak bölünmüştür. Yukarıda aralarındaki farkın ne olduğunu açıkladım. Şimdi küresel nesnelere daha yakından bakalım.

Bunların hepsi kodun ana gövdesinde bildirilen işlevler ve değişkenlerdir; herhangi bir işlevin içinde değil. Js'deki bunların tümü otomatik olarak global bir nesnenin özellikleri haline gelir ve bu, tarayıcılarda açıkça kelime penceresi altında bulunur. Bir örneğe bakalım.

var fiyatı = 145; // global bir değişken yaratıyoruz

uyarı(pencere.fiyat); // cevap: 145

Buraya kadar her şey basit ama tuzaklara hazırlıklı olun. Bazen değişken değerleri kaydetmenin ve üzerine yazmanın ayrıntılarını bilmeden çok önemli parametrelerin üzerine yazabilirsiniz. Bu tür hataların izini sürmek oldukça zordur ve derleyicileri kullanarak bulmak imkansızdır. Bu nedenle aşağıdaki materyali dikkatlice analiz edin.

Tuzaklar ve kapsam

Sorunu daha iyi anlamak için önce bir fonksiyonda yerel bir değişken yaratacağım, sonra da onun sınırlarının dışında global bir değişken yaratacağım küçük bir program göstereceğim.

function test() ( p = 2; return p; ) alarm(p); // un tanımsız p = “önemli metin”; uyarı(p); // “önemli metin”i görüntüleyecektir test(); // alarm(p) fonksiyonunu çağırın; // 2 yazdıracak

Başlangıçta test fonksiyonunda 2 değerine sahip bir yerel değişken başlattım ve ardından bazı önemli verileri saklayan bir global metin değişkeni oluşturdum.

Ve burada o “su altı bloğu” ortaya çıkıyor.

Öncelikle, öğelerin oluşturulmasını eski JavaScript standardının kurallarına göre kullandığım için, tüm "p" değişkenleri yalnızca atama sırasında oluşturuldu (var yönergesini kullanırken, değişkenler hemen değerle oluşturulur) tanımsızdır ve başlatma sırasında “= » değerinin üzerine yazılır).

İkinci olarak, bu durumda, js'de örtülü olarak oluşturulan öğelere bir değer atamak için mevcut bir değer kullanılır veya yeni bir global değişken oluşturulur. Bu nedenle yukarıdaki örnekte test fonksiyonu çağrıldıktan sonra global “p”nin değeri kaybolmuştur.

Çökmelerden kaçınmak için her zaman var anahtar sözcüğünü kullanın. Daha sonra tüm nesneler açıkça bildirilecek ve yenileri oluşturulacaktır.

İşte düzeltilmiş örnek:

fonksiyon test() ( var p = 2; uyarı (p); dönüş p; ) uyarı(p); // tanımsız var p = "önemli metin"; uyarı(p); // “önemli metin” testini görüntüleyecektir(); // işlevi çağırın, bu durumda 2 uyarı(p) görüntülenecektir; // "önemli metin" görüntülenecek

Artık kod düzgün çalışıyor. Fark ettiğiniz gibi, yerel “p”nin kapsamı test fonksiyonunun içindedir ve global olan ise kodun geri kalanındadır.

Sabitler hakkında birkaç kelime

Diğer tüm programlama dilleri gibi JavaScript'in de sabitleri vardır. Bilmeyenler için tanımını ekleyeceğim.

Sabit, değeri değişmeden kalan bir değişken türüdür.

Js'deki sözdizimi kurallarına göre isimleri her zaman küçük (büyük) harflerle yazılır. Örneğin,

var MAIN_COLOR = “#fff”

Bir betik dilinde bir sabiti gerçekten sabit yapacak hiçbir teknik özellik yoktur. Aslında bunlar üzerine yazılabilen sıradan değişkenlerdir. Ancak kurallara göre geliştiriciler isimlerinde büyük harflerle yazılan bu unsurları sabit olarak kullanıyor ve kod yazarken anlamlarını değiştirmiyorlar.

Sabitlerin temel amacı, yeniden yazıldığında yazım hatası yapmanın kolay olduğu veya asla değiştirilmemesi gereken karmaşık dizeleri, önemli sayıları veya diğer değerleri depolamak veya kodu basitleştirmektir. Örneğin, sabitler sık ​​sık tekrarlanan istekleri depolamak için kullanılabilir.