JavaScript. Veri türleri ve operatörler

JavaScript'te değişken adları oluşturmak için sözdizimi kuralları vardır:

• Değişken adları için aşağıdaki simgeler kullanılır: a-z, A-Z, sayılar, $, alt çizgi (_).
• Değişken isimleri rakamla başlayamaz.
• JavaScript büyük/küçük harf duyarlıdır, bu nedenle programlama yaparken bunu aklınızda bulundurun. itcounter ve o C dış değişkenler farklı değişkenlerdir.
• JavaScript'te bir değişken adının uzunluğu konusunda herhangi bir sınırlama yoktur.

Geçerli değişken adlarına örnekler:

• itcounter
• $ _itcounter
• it_counter

Yanlış değişken isimleri:

• 9 oda
• it-sayaç
• #itcounter
• & sayaç

Değişkenler var komutu ile tanımlanır.

Değişkenler dizileri ve sayıları saklayabilir. Aslında, diğer veri türlerini de saklayabilirsiniz, ancak bunlardan daha sonra bahsedeceğiz.

dize değişkenleri

Bir değişkene dize yazmak için, değerini çift veya tek tırnak içine almanız gerekir.

Var $ stroka_1 = "Merhaba!"; var $ stroka_2 = "Dikkat!";

Oluşturulan dizeye tek alıntı, bir çift alıntı ekleyebilirsiniz ve bunun tersi de geçerlidir.

Var $ stroka_1 = "" Merhaba! "Bir selamlamadır."; var $ stroka_2 = "" Dikkat! "bir uyarıdır."; belge.write ($ stroka_1); belge.yaz ("

Aynı türde bir tırnak işareti yazdırmak için, ters eğik çizgi karakteriyle öncelenmesi gerekir. Basit:

"); document.write ($ stroka_2);

Değişken değerleri diğer değişkenlere atanabilir:

Var $ stroka_1 = "\" Merhaba! \ "Bir selamlamadır."; var $ stroka_2 = "\" Dikkat! \ "bir uyarıdır."; belge.write ($ stroka_1); belge.yaz ("
"); document.write ($ stroka_2); $ stroka_2 = $ stroka_1; document.write ("
"); document.write ($ stroka_2);

Bu örnekte, önce $ stroka_2 değişkenine bir string değeri atadık, ancak daha sonra buna $ stroka_1 değişkeninin değerini atadık.

Birleştirme dizeleri

Birden çok satırı tek bir satırda birleştirmek çok yaygındır. Örneğin, son örneğimiz çok hantal.

JavaScript'te dizelerin birleştirilmesi (birleştirilmesi) işareti kullanılarak yapılır. + .

Bir etiketle ayrılmış 2 dize değişkenini görüntülemek için
değişkenler, bir komut kullanabilirsiniz document.write ().

Var $ stroka_1 = "" Merhaba! "Bir selamlamadır."; var $ stroka_2 = "" Dikkat! "bir uyarıdır."; belge.write ($ stroka_1 + "
"+ $ stroka_2);

birleştirme operatörü + değişkenlerde de kullanılabilir:

Var $ stroka_1 = "" Merhaba! "Bir selamlamadır."; var $ stroka_2 = "" Dikkat! "bir uyarıdır."; var $ stroka_3 = $ stroka_1 + "
"+ $ stroka_2; belge.write ($ stroka_3);

Sayısal Değişkenler

Sayısal bir değişken oluşturmak için ona sayısal bir değer atamanız yeterlidir.

Var $ sayı_1 = 23; var $ say_2 = 10.34; belge.write ($ sayı_1 - $ sayı_2);

Şimdi başka bir örnek:

Var $ sayı_1 = 23; // Sayısal değişken. var $ stroka_1 = "57"; // Dize değişkeni. belge.write ($ stroka_1 + $ count_1);

Görüyorsunuz, $ stroka_1 değişkeninin değeri tırnak içine alınmış, yani bir metin değişkenidir. Sonra metni ve sayısal değişkeni ekliyoruz ve "5723" dizesini alıyoruz, bu gibi durumlarda JavaScript böyle çalışır - sayıyı bir dizeye çevirir ve toplanan dizeye ekler.

Boole değişkenleri

Böyle bir değişken türü var - boole. Çok basit, sadece iki değer var: true ve false, yani true ve false.

Bu veri türü karşılaştırma işlemlerinde kullanılır. İşte bazı basit örnekler:

• 9> 1 doğrudur.
• 2> 5 yalandır.

var $ sayı = 2

Şimdi aritmetik işlemlerde boole değerlerini değiştirmeye çalışalım. İki karşılaştırma işlemini özetleyelim:

Var $ sayı = (3> 2) + (4> 2); belge.write ($ sayısı);

Bu garip bir kayıt, biliyorum. Ancak $ count değişkeni 2 olacaktır. Matematik bağlamında, true = 1 ve false = 0.

Karşılaştırma operatörleri, JavaScript'te yaygın olarak kullanılan if ifadesinde kullanılır. İngilizce if kelimesi - if anlamına gelir.

Var $ sayı = 100; if ($ sayım == 100) document.write ("$ sayım değişkeni 100'dür.");

Bu örnekte, if ifadesinin ($ sayım == 100) koşulu doğru olduğu için mesaj görüntülenecektir. $ count değişkeninin değerini 99 olarak değiştirirseniz, koşul ($ count == 100) yanlış olur ve ekranda hiçbir şey görüntülenmez.

Basit değişken türleri

JavaScript'te değişkenler birkaç türe ayrılır. Dize, sayısal ve boolean (mantıksal) türlerini zaten ele aldık. İşte basit türlerin daha geniş bir listesi:

• string bir string değişkendir.
• sayı sayısal bir değişkendir.
• boolean bir boole değişkenidir.
• null "hiçbir şey" özel değeridir.
• tanımsız - "değer atanmadı" yazın.

null değişkeninin değeri, olası tek boş değerden oluşan kendi farklı türünü, null'u oluşturur. null, "hiçbir şey" veya "bilinmeyen değer" anlamına gelen özel bir değerdir.

Var $ fiyat = boş; // bu, fiyatın bilinmediği anlamına gelir.

JavaScript'te typeof deyimini kullanarak değişkenlerin türünü öğrenebilirsiniz.

Var $ sayısı; belge.write (typeof $ sayı + "
"); var $ count = true; document.write (typeof $ count +"
"); var $ count =" true "; document.write (typeof $ sayım +"
"); var $ sayım = 100; document.write (typeof $ sayım +"
"); var $ sayı = null; document.write (typeof $ sayım +"
");

typeof ifadesinin sözdizimi şöyle olabilir:

• typeof $ sayısı
• typeof ($ sayısı)

Bu nedenle, son örnekteki kodu çalıştırın ve sonucu görün. Boş değişken türü nesne olacaktır. Bu, dilde bir hatadır ve önceden yazılmış JavaScript komut dosyalarının dilin yeni sürümleriyle uyumluluğunu koruma ihtiyacı nedeniyle muhtemelen hiçbir zaman düzeltilmeyecektir.

Nesne türü artık ilkel bir tür değil, bundan başka derslerde bahsedeceğiz.

Dize, Sayı, Boole, Dizi, Nesne.

JavaScript veri türleri

JavaScript değişkenleri birçok içerebilir veri tipleri: sayılar, diziler, diziler, nesneler ve daha fazlası:

var uzunluk = 16; // Numara
var lastName = "Johnson"; // Sicim
var arabalar = ["Saab", "Volvo", "BMW"]; // Sıralamak
var x = (ad: "John", soyadı: "Doe"); // Nesne

Veri türü kavramı

Programlamada veri türleri önemli bir kavramdır.

Değişkenlerle çalışabilmek için tür hakkında bir şeyler bilmek önemlidir.

Veri türleri olmadan bilgisayar bu sorunu güvenli bir şekilde çözemez:

Var x = 16 + "Volvo";

On altıya "Volvo" eklemek mantıklı mı? Hata mı verecek yoksa sonuç mu üretecek?

JavaScript, yukarıdaki örneği şu şekilde ele alır:

Var x = "16" + "Volvo";

Bir sayı ve bir dize eklerken JavaScript, sayıyı bir dize olarak değerlendirir.

JavaScript, ifadeleri soldan sağa doğru değerlendirir. Farklı diziler farklı sonuçlara yol açabilir:

İlk örnekte JavaScript, "Volvo"ya ulaşana kadar 16 ve 4'ü sayı olarak ele alır.

İkinci örnekte, ilk işlenen bir dize olduğundan, tüm işlenenler dize olarak kabul edilir.

JavaScript'in dinamik türleri vardır

JavaScript'in dinamik türleri vardır. Bu, aynı değişkenin farklı türler olarak kullanılabileceği anlamına gelir:

örnek

var x; // Şimdi x tanımsız
var x = 5; // Şimdi x bir Sayıdır
var x = "John"; // Şimdi x bir String

JavaScript Dizeleri

Bir dize (veya metin dizesi), "John Doe" gibi bir dizi karakterdir.

Satırlar tırnak içinde yazılmıştır. Tek veya kullanabilirsiniz ikili alıntı:

örnek

var carName = "Volvo XC60"; // çift tırnak kullanma
var carName = "Volvo XC60"; // Tek tırnak kullanma

Dize etrafındaki tırnak işaretleri ile eşleşmedikleri sürece, bir dize içinde tırnak işaretleri kullanabilirsiniz:

örnek

var answer = "Tamam"; // Çift tırnak içinde tek tırnak
var cevap = "Onun adı" Johnny ""; // Çift tırnak içinde tek tırnak
var cevap = "Onun adı" Johnny ""; // Tek tırnak içinde çift tırnak

Kendin dene "

Bu öğreticide daha sonra dizeler hakkında daha fazla bilgi edineceksiniz.

JavaScript Numaraları

JavaScript'te yalnızca bir tür sayı vardır.

Sayılar yazılabilir veya ondalık basamaklar olmadan yazılabilir:

örnek

var x1 = 34.00; // Ondalık sayılarla yazılır
var x2 = 34; // Ondalıksız yazılır

Çok büyük veya çok küçük sayılar bilimsel (üstel) gösterimle yazılabilir:

Bu kılavuzda daha sonra sayılar hakkında daha fazla bilgi edineceksiniz.

JavaScript Booleanları

Boolean yalnızca iki değere sahip olabilir: true veya false.

örnek

var x = doğru;
var y = yanlış;

Boole değerleri genellikle koşullu testlerde kullanılır.

Bu öğreticide daha sonra koşullu test hakkında daha fazla bilgi edineceksiniz.

JavaScript dizileri

JavaScript dizileri köşeli parantezler kullanılarak yazılır.

dizi öğeleri virgülle ayrılır.

Aşağıdaki kod, üç öğe (araba adları) içeren arabalar adlı bir dizi bildirir (oluşturur):

Dizi indeksleri sıfırdan başlar; bu, ilk öğe, ikinci vb. anlamına gelir.

Bu öğreticide daha sonra diziler hakkında daha fazla bilgi edineceksiniz.

JavaScript nesneleri

JavaScript nesneleri küme parantezleri içine alınır.

Nesne özellikleri ad olarak yazılır: virgülle ayrılmış değer çiftleri.

Yukarıdaki örnekteki nesnenin (kişi) 4 özelliği vardır: firstName, lastName, age ve eyeColor.

Bu öğreticide daha sonra nesneler hakkında daha fazla bilgi edineceksiniz.

Operatör Tipi

JavaScript kodunu kullanabilirsiniz bir çeşit JavaScript değişkeninin türünü bulmak için operatör:

örnek

typeof "John" // Dizeyi döndürür
typeof 3.14 // Sayıyı döndürür
typeof false // Boole değerini döndürür
typeof // Nesneyi döndürür
typeof (isim: "John", yaş: 34) // Nesneyi döndürür

Değişken, bir değer atanmış bir tanımlayıcıdır. Bir programda bir değişkene, kendisine atanan değer ile bu şekilde çalışarak erişilebilir.

Kendi başına bir JavaScript değişkeni, içinde depolanacak değerlerin türü hakkında bilgi içermez. Bu, örneğin bir dize gibi bir değişkene yazarak daha sonra ona bir sayı yazabileceğiniz anlamına gelir. Böyle bir işlem programda hataya neden olmaz. Bu nedenle JavaScript'e bazen "türlenmemiş" dil denir.

Bir değişkeni kullanmadan önce, kullanılarak bildirilmelidir. anahtar kelime var veya izin ver. Bir sabit söz konusu olduğunda, const anahtar sözcüğü kullanılır. Bu anahtar kelimeleri kullanmadan bir değişken tanımlayabilir ve ona bir değer atayabilirsiniz, ancak bu önerilmez.

▍ var anahtar sözcüğü

ES2015'ten önce, değişkenleri bildirmenin tek yolu var anahtar sözcüğünü kullanmaktı.

Var a = 0
Bu yapıda var belirtilmemişse, değer bildirilmemiş bir değişkene atanacaktır. Bu işlemin sonucu, programın yürütülmekte olduğu moda bağlıdır.

Bu nedenle, sözde katı mod etkinleştirilirse, bu bir hataya neden olur. Katı mod etkinleştirilmezse, değişken dolaylı olarak bildirilecek ve global nesneye atanacaktır. Özellikle bu, bir fonksiyonda örtük olarak bu şekilde bildirilen bir değişkenin, fonksiyon işini tamamladıktan sonra kullanılabilir olacağı anlamına gelir. Genellikle, fonksiyonlarda bildirilen değişkenlerin sınırlarının dışına "çıkmaması" beklenir. Şuna benziyor:

notVar () işlevi (bNotVar = 1 // bunu yapmamak daha iyi) notVar () console.log (bNotVar)
Konsol 1 alacak, kimse genellikle programdan böyle bir davranış beklemiyor, bNotVar = 1 ifadesi bir değişkeni bildirme ve başlatma girişimi gibi değil, işlevin kapsamı dışındaki bir değişkene erişme girişimi gibi görünüyor ( bu oldukça normaldir). Sonuç olarak, örtük değişken bildirimleri okuyucunun kafasını karıştırır ve beklenmeyen program davranışına yol açabilir. Fonksiyonlar ve kapsamlar hakkında daha sonra konuşacağız, ancak şimdilik bir ifadenin anlamı bir değişken bildirmek olduğunda özel anahtar kelimeler kullanmaya çalışın. Bu örnekte işlevin gövdesi var bNotVar = 1 olarak yeniden yazılırsa, yukarıdaki kod parçacığını çalıştırma denemesi bir hata mesajıyla sonuçlanacaktır (bunu tarayıcı konsolunda görebilirsiniz).

Örneğin, şöyle görünebilir: Yakalanmayan ReferenceError: bNotVar tanımlı değil. Anlamı, programın var olmayan bir değişkenle çalışamayacağı gerçeğine dayanır. Bir programı ilk çalıştırdığınızda böyle bir hata mesajı görmek, beklenmedik şekilde davranabilen anlaşılmaz bir kod yazmaktan çok daha iyidir.

Bir değişken bildirirken, başlatılmamışsa veya herhangi bir değer atanmamışsa, otomatik olarak tanımsız değeri atanacaktır.

Var a // typeof a === "tanımsız"
var anahtar kelimesi ile tanımlanan değişkenler defalarca yeniden bildirilebilir, onlara yeni değerler atanabilir (ancak bu okuyucu için kafa karıştırıcı olabilir).

Var a = 1 var a = 2
Bir ifadede birkaç değişken bildirilebilir:

Var a = 1, b = 2
Bir değişkenin kapsamı, bu değişkenin mevcut olduğu (görünür) programın alanıdır.

Bir fonksiyonun dışında var anahtar sözcüğü ile başlatılan bir değişken, global nesneye atanır. Küresel bir kapsamı vardır ve programın herhangi bir yerinden erişilebilir. Bir değişken, bir işlev içinde var anahtar sözcüğü kullanılarak bildirilirse, yalnızca bu işlevin içinde görünür, onun için yerel bir değişkendir.

Bir fonksiyonda, var kullanılarak, adı global kapsamdaki bir değişkenin adıyla çakışan bir değişken bildirilirse, global değişkenle "örtüşecektir". Yani, bir fonksiyon içinde böyle bir değişkene erişirken, onun yerel versiyonu kullanılacaktır.

Blokların (kıvrımlı parantezler içine alınmış kod alanları) yeni kapsamlar oluşturmadığını anlamak önemlidir. İşlev çağrıldığında yeni bir kapsam oluşturulur. var anahtar sözcüğü, blok kapsamı değil, işlevsel kapsam olarak adlandırılan şeye sahiptir.

İşlev kodunda bir değişken bildirilmişse, işlev kodunun tamamı tarafından görülebilir. Bir değişken, fonksiyon kodunun sonunda var kullanılarak bildirilmiş olsa bile, JavaScript kaldırma mekanizmasını kullandığından, buna kodun başında da başvurabilirsiniz. Bu mekanizma, değişken bildirimlerini "kaldırır", ancak başlatma işlemlerini değil. Bu bir karışıklık kaynağı olabilir, bu nedenle fonksiyonunuzun başında değişkenleri bildirmeyi bir kural haline getirin.

▍let anahtar sözcüğü

let anahtar sözcüğü ES2015'te tanıtıldı ve basitçe var'ın "blok" sürümü olarak adlandırılabilir. let anahtar sözcüğüyle bildirilen değişkenlerin kapsamı, içinde bildirildiği bloğa, ifadeye veya ifadeye ve iç içe bloklara göre belirlenir.

"İzin ver" kelimesinin kendisi kafa karıştırıcı görünüyorsa, bunun yerine "let" kelimesini kullanmayı hayal edebilirsiniz. Daha sonra let color = "red" ifadesi İngilizce'ye şu şekilde çevrilebilir: "rengi kırmızı olsun" ve Rusça'ya - şöyle: "rengi kırmızı olsun".

let anahtar sözcüğünü kullanarak, var anahtar sözcüğüyle ilişkili belirsizliklerden kurtulabilirsiniz (örneğin, aynı değişkeni let kullanarak iki kez bildiremezsiniz). Bir fonksiyonun dışına izin vermek, diyelim ki döngüleri başlatırken, global değişkenler yaratmaz.

Örneğin, bunun gibi bir kod bir hata verecektir:

için (i = 0; i< 5; i++) { console.log(i) } console.log(i)
Döngünün başlatılması sırasında i sayacı var anahtar sözcüğü kullanılarak bildirilirse, işini tamamladıktan sonra i döngü dışında kullanılabilir.

Günümüzde, modern standartlara dayalı JS programları geliştirirken, var'ı tamamen terk etmek ve sadece let ve const anahtar kelimelerini kullanmak oldukça mümkündür.

▍const anahtar sözcüğü

var veya let anahtar sözcükleri kullanılarak bildirilen değişkenlerin üzerine yazılabilir. Bu anahtar kelimelerin yerine const kullanılırsa, onun yardımıyla bildirilen ve başlatılan bir sabite yeni bir değer atanamaz.

Const a = "test"
Bu örnekte, a sabitine yeni bir değer atanamaz. Ancak şunu belirtmek gerekir ki a sayı gibi ilkel bir değer değil de bir nesne ise const anahtar sözcüğünü kullanmak o nesneyi değişikliklerden korumaz.

Bir nesnenin bir değişkene yazıldığını söylediklerinde, asıl kastettikleri şey, değişkenin nesneye bir referans depolamasıdır. Bu bağlantı değiştirilemez ve bağlantının yönlendirildiği nesnenin kendisi değiştirilebilir.

const anahtar sözcüğü nesneleri değişmez yapmaz. Karşılık gelen sabitlerde yazılan referansları değişikliklerden korur. İşte böyle görünüyor:

Const obj = () console.log (obj.a) obj.a = 1 // console.log (obj.a) çalıştırılıyor // obj = 5 // hata veriyor
Başlatma sırasında, sabit nesneye yeni bir boş nesne yazılır. Var olmayan a özelliğine erişme girişimi bir hataya neden olmaz. Konsol tanımsız hale geliyor. Bundan sonra nesneye yeni bir özellik ekliyoruz ve tekrar erişmeye çalışıyoruz. Bu sefer bu özelliğin değeri konsola gönderilir - 1. Örneğin son satırının yorumunu kaldırırsanız, bu kodu çalıştırma girişimi bir hatayla sonuçlanacaktır.

const anahtar sözcüğü let'e çok benzer, özellikle blok kapsamlıdır.

Modern koşullarda, değerlerinin değiştirilmesi planlanmayan tüm varlıkları bildirmek için const anahtar sözcüğünü kullanmak, yalnızca özel durumlarda izin vermek oldukça kabul edilebilir. Niye ya? Mesele şu ki, programları karmaşıklaştırmamak ve hatalardan kaçınmak için mevcut en basit yapıları kullanmaya çalışmak en iyisidir.

Veri tipleri

JavaScript'e bazen "yazılmamış" dil denir, ancak durum böyle değildir. Değişkenlere farklı türlerde değerler yazabileceğiniz doğrudur ama sonuçta JavaScript'te veri türleri vardır. Özellikle ilkel ve nesne veri türlerinden bahsediyoruz.

Bir değerin veri tipini belirlemek için typeof operatörünü kullanabilirsiniz. İşlenenin türünü gösteren bir dize döndürür.

▍İlkel veri türleri

İşte bir liste ilkel türler JavaScript verileri:

• sayı (sayı)
• dize (dize)
• boole (boole değeri)
• null (özel değer null)
• tanımsız (tanımsız özel değer)
• sembol (özel durumlarda kullanılan, ES6'da tanıtılan sembol)

Burada, veri türlerinin adları, typeof operatörü tarafından döndürüldükleri biçimde gösterilir.

Bu listeden en sık kullanılan veri türlerinden bahsedelim.

Sayı türü

JavaScript sayı değerleri, 64 bit çift duyarlıklı kayan noktalı sayılar olarak temsil edilir.

Sayısal değişmezler kodda tamsayılar olarak temsil edilir ve kesirli sayılar ondalık gösterimde. Sayı yazmak için diğer yöntemleri kullanabilirsiniz. Örneğin, sayısal bir hazır bilginin başında 0x öneki varsa, onaltılık gösterimde yazılmış bir sayı olarak yorumlanır. Sayılar üstel gösterimle de yazılabilir (bu tür sayılarda e harfini bulabilirsiniz).

İşte tamsayı yazma örnekleri:

10 5354576767321 0xCC // onaltılık sayı
İşte kesirli sayılar.

3.14 .1234 5.2e4 //5.2 * 10 ^ 4
Sayısal değişmezler (bu davranış diğer bazı ilkel türler için de tipiktir), bunlara nesne olarak atıfta bulunmaya çalıştığınızda, işlem gerçekleştirilirken otomatik olarak "nesne sarmalayıcıları" olarak adlandırılan ilgili nesnelere dönüştürülür. Bu durumda, nesne sarmalayıcı Numarasından bahsediyoruz.

Örneğin, Google Chrome konsolunda sayısal bir değişmezin yazıldığı a değişkenine bir nesne olarak erişme girişiminin nasıl göründüğü aşağıda açıklanmıştır.

Sayı Nesne Sarma İpucu

Örneğin, Number türünde bir nesnenin toString () yöntemini kullanırsanız, sayının dize gösterimini döndürür. Tarayıcı konsolunda (ve normal kodda) yürütülebilen ilgili komut şuna benzer:

A.toString ()
Yöntem adından sonraki çift parantezlere dikkat edin. Sağlanmazlarsa, sistem bir hata oluşturmaz, ancak beklenen çıktı yerine konsol, 5 sayısının dize temsiline hiç benzemeyen bir şey görüntüler.

Global Number nesnesi bir kurucu olarak kullanılabilir, onun yardımıyla yeni sayılar yaratır (bu formda neredeyse hiç kullanılmamasına rağmen), aynı zamanda örneklerini oluşturmadan bağımsız bir varlık olarak da kullanılabilir (yani, bazı sayılar ile temsil edilir). yardımcı olur). Örneğin, Number.MAX_VALUE özelliği, JavaScript'te gösterilebilen maksimum sayısal değeri içerir.

dize türü

Dize değerleri karakter dizileridir. Bu tür değerler, tek veya çift tırnak içine alınmış dize değişmezleri olarak belirtilir.

"Bir dize" "Başka bir dize"
Dize değerleri ters eğik çizgi karakteri kullanılarak birden çok parçaya bölünebilir.

"Dizi"
Dize, dizi konsola yazdırıldığında yorumlanan sözde kaçış dizileri içerebilir. Örneğin, \ n dizisi bir satır besleme karakteri anlamına gelir. Ters eğik çizgi karakteri, tırnak içine alınmış dizelere tırnak işaretleri eklemek için de kullanılabilir. Alıntı karakterinden \ ile çıkmak, sistemin onu şu şekilde yorumlamamasına neden olur: özel karakter.

"Ben bir geliştiriciyim"
Dizeler + operatörü kullanılarak birleştirilebilir.

"A" + "dize"

Şablon değişmezleri

ES2015, sözde şablon değişmezlerini veya şablon dizelerini tanıttı. Geri tepmeler (`) içine alınmış dizelerdir ve bazı ilginç özelliklere sahiptirler.

'bir dize'
Örneğin, JavaScript ifadelerini değerlendirmenin sonucu olan şablon değişmezlerindeki bazı değerleri değiştirebilirsiniz.

`$ (bir şey) içeren bir dize` `$ (bir şey + bir şey) içeren bir dize` `$ (nesne.bir şey ()) içeren bir dize`
Backticks kullanmak, çok satırlı dize değişmezlerini yazmayı kolaylaştırır:

`$ (bir şey) içeren bir dize`

Boole türü

JavaScript, booleanlerle çalışırken kullanılan birkaç ayrılmış kelimeye sahiptir - true ve false. ==, === gibi karşılaştırma işlemleri,< , >, true veya false döndürün.

Boolean ifadeleri, bir programın akışını kontrol etmeye yardımcı olmak için if ve while gibi yapılarda kullanılır.

Doğru veya yanlış bir değerin beklendiği yerde, dil tarafından otomatik olarak true (truthy) veya false (falsy) olarak yorumlanan diğer değerleri kullanabileceğiniz belirtilmelidir.

Özellikle, aşağıdakiler yanlış değerlerdir:

0 -0 NaN tanımsız null "" // boş dize
Diğer tüm değerler doğrudur.

boş tip

JavaScript'in, değer olmadığını gösteren özel bir değeri vardır, null. Diğer dillerde de benzer anlamlar kullanılmaktadır.

tanımsız tip

Bir değişkene yazılan tanımsız değer, bu değişkenin başlatılmadığını ve onun için bir değerin olmadığını gösterir.

Bu değer, return anahtar sözcüğünü kullanarak sonucu açıkça döndürmeyen işlevlerden otomatik olarak döndürülür. İşlev, çağrıldığında belirtilmeyen bir parametre alırsa, tanımsız olarak da ayarlanır.

undefined için bir değeri kontrol etmek için aşağıdaki yapıyı kullanabilirsiniz.

Typeof değişkeni === "tanımsız"

▍Nesneler

İlkel olmayan tüm değerler nesne türündedir. Fonksiyonlardan, dizilerden, "nesneler" dediğimiz şeylerden ve diğer birçok varlıktan bahsediyoruz. Bu veri türlerinin tümü nesne türüne dayalıdır ve birçok yönden farklılık gösterseler de birçok ortak noktaları vardır.

İfade

İfadeler, yapılan hesaplamalara dayalı olarak belirli bir değerde işlenebilen ve elde edilebilen kod parçalarıdır. JavaScript'te birkaç ifade kategorisi vardır.

aritmetik ifadeler

Sayıları değerlendiren ifadeler bu kategoriye girer.

1/2 ben ++ ben - = 2 ben * 2

dize ifadeleri

Bu tür ifadelerin değerlendirilmesinin sonucu dizelerdir.

"A" + "dize" "A" + = "dize"

Birincil ifadeler

Değişmezler, sabitler, tanımlayıcı referanslar bu kategoriye girer.

2 0.02 "bir şey" doğru yanlış bu // yürütme bağlamı, geçerli nesneye başvuru tanımsız i // burada i bir değişken veya sabittir
Bu aynı zamanda bazı JavaScript anahtar kelimeleri ve yapılarını da içerir.

İşlev sınıfı işlevi * // verim üreteci // verim üretecinin çalışmasını duraklatma / devam ettirme komutu * // başka bir yineleyiciye veya oluşturucuya delege etme zaman uyumsuz işlev * // eşzamansız işlevsel ifade bekliyor // eşzamansız işlevin yürütülmesini bekle / kalıp / ben // Düzenli ifade() // gruplama

Dizi ve Nesne Başlatma İfadeleri

// dizi değişmezi () // nesne değişmezi (a: 1, b: 2) (a: (b: 1))

Boole ifadeleri

Boole ifadeleri Boole operatörlerini kullanır, değerlendirmelerinin sonucu Boole değerleridir.

A && b bir || b! bir

Mülk Erişim İfadeleri

Bu ifadeler, nesnelerin özelliklerine ve yöntemlerine erişmenizi sağlar.

Object.property // nesne nesne nesnesinin ["özellik"] özelliğine (veya yöntemine) erişim

Nesne Oluşturma İfadeleri

yeni nesne () yeni bir (1) yeni MyRectangle ("ad", 2, (a: 4))

İşlev bildirimi ifadeleri

fonksiyon () () fonksiyon (a, b) (dönüş a * b) (a, b) => a * b a => a * 2 () => (dönüş 2)

Meydan okuma ifadeleri

Bu tür ifadeler, nesnelerin işlevlerini veya yöntemlerini çağırmak için kullanılır.

A.x (2) pencere.yeniden boyutlandırma ()

nesnelerle çalışma

Yukarıda, nesne değişmezlerinden, yöntemlerini çağırmaktan, özelliklerine erişmekten bahseden nesnelerle zaten karşılaştık. Burada nesneler hakkında daha detaylı konuşacağız, özellikle prototip kalıtım mekanizmasına ve class anahtar kelimesinin kullanımına bakacağız.

▍ Prototip kalıtım

JavaScript, prototip kalıtımı desteklemesiyle modern programlama dilleri arasında öne çıkıyor. Çoğu nesne yönelimli dil, sınıf tabanlı bir kalıtım modeli kullanır.

Her JavaScript nesnesinin, prototipi olan başka bir nesneye işaret eden özel bir özelliği (__proto__) vardır. Nesne, prototipin özelliklerini ve yöntemlerini devralır.

Bir nesne değişmezi kullanılarak oluşturulmuş bir nesnemiz olduğunu varsayalım.

Sabit araba = ()
Veya Object yapıcısını kullanarak bir nesne yarattık.

Const araba = yeni Nesne ()
Her iki durumda da, arabanın prototipi Object.prototype olacaktır.

Aynı zamanda nesne olan bir dizi oluşturursanız, prototipi Array.prototype nesnesi olacaktır.

Const list = // ya da const list = yeni Dizi ()
Bunu aşağıdaki gibi kontrol edebilirsiniz.

Araba .__ proto__ == Nesne.prototip // gerçek araba .__ proto__ == yeni Nesne () .__ proto__ // doğru liste .__ proto__ == Nesne.prototip // yanlış liste .__ proto__ == Dizi.prototip / / doğru liste .__ proto__ == yeni Dizi () .__ proto__ // doğru
Burada __proto__ özelliğini kullandık, geliştirici tarafından kullanılabilir olması gerekmez, ancak genellikle buna başvurabilirsiniz. Bir nesnenin prototipini elde etmenin daha güvenilir bir yolunun, global nesnenin getPrototypeOf() yöntemini kullanmak olduğuna dikkat edilmelidir. nesne nesnesi.

Object.getPrototypeOf (yeni Nesne ())
Bir prototipin tüm özellikleri ve yöntemleri, bu prototipe sahip bir nesne tarafından kullanılabilir. Örneğin, bir dizi için listeleri şöyle görünür.

dizi ipucu

Tüm nesneler için temel prototip, Object.prototype'dir.

Array.prototype .__ proto__ == Object.prototype
Object.prototype'ın prototipi yok.

Yukarıda gördüğümüz, bir prototip zinciri örneğidir.

Bir nesnenin bir özelliğine veya yöntemine erişmeye çalıştığınızda, nesnenin kendisinde böyle bir özellik veya yöntem yoksa, bunlar önce prototipinde, sonra prototip prototipinde vb. aranan nesne bulunana kadar aranır veya prototip zinciri sona erene kadar.

new işlecini ve nesne değişmez değerlerini veya dizi değişmezlerini kullanmanın yanı sıra, Object.create () yöntemini kullanarak bir nesnenin örneğini oluşturabilirsiniz. Bu yönteme iletilen ilk argüman, oluşturduğu nesnenin prototipi olacak bir nesnedir.

Const araba = Object.create (Object.prototype)
isPrototypeOf() yöntemini kullanarak bir nesnenin başka bir nesnenin prototip zincirinin parçası olup olmadığını kontrol edebilirsiniz.

Const list = Array.prototype.isPrototypeOf (liste)

Yapıcı işlevleri

Yukarıda, dilde zaten mevcut olan kurucu fonksiyonları kullanarak yeni nesneler yarattık (onları çağırırken, new anahtar kelimesi kullanılır). Bu tür işlevleri kendiniz oluşturabilirsiniz. Bir örneğe bakalım.

Fonksiyon Kişi (isim) (this.name = isim) Kişi.prototype.hello = fonksiyon () (console.log (this.name)) let person = new Person ("Flavio") person.hello () console.log ( Kişi.prototype.isPrototypeOf (kişi))
Burada bir yapıcı fonksiyon oluşturuyoruz. Onu çağırdığınızda, yapıcının gövdesindeki this anahtar sözcüğüyle gösterilen yeni bir nesne oluşturulur. Bu nesneye bir name özelliği ekliyoruz ve yapıcıya iletilenleri ona yazıyoruz. Bu nesne yapıcıdan otomatik olarak döndürülür. Bir kurucu işlevi kullanarak, oluşturulduğunda kurucuya aktarılanları isim özellikleri içerecek olan birçok nesne oluşturabilirsiniz.

Yapıcıyı oluşturduktan sonra, prototipine, bu fonksiyon kullanılarak oluşturulan nesnenin name özelliğinin değerini konsola yazdıracak bir fonksiyon ekliyoruz. Bu kurucu kullanılarak oluşturulan tüm nesneler aynı prototipe sahip olacak ve bu nedenle aynı merhaba () işlevini kullanacak. Bu, Person türünde başka bir nesne oluşturarak ve merhaba () işlevini örnekte zaten bulunan nesnenin işleviyle karşılaştırarak kontrol etmek kolaydır (bu durumda, işlevin adı parantez olmadan yazılır).

▍Sınıflar

ES6 standardında JavaScript, "sınıf" olarak bilinir hale geldi.

Bundan önce, JavaScript yalnızca yukarıda açıklanan prototip kalıtım mekanizmasını kullanabilirdi. Bu mekanizma, JS'ye diğer dillerden gelen programcılar için alışılmadık görünüyordu. Bu nedenle, prototip kalıtım mekanizması için aslında "sözdizimsel şeker" olan dilde sınıflar ortaya çıktı. Yani hem geleneksel yöntem kullanılarak oluşturulan nesnelerin hem de sınıflar kullanılarak oluşturulan nesnelerin prototipleri vardır.

sınıf beyanı

Sınıf bildirimi böyle görünüyor.

Sınıf Kişisi (kurucu (isim) (this.name = name) merhaba () (dönüş "Merhaba, ben" + this.name + "."))
Sınıfın, yeni ClassIdentifier () yapısını kullanarak yeni nesneler oluşturmak için kullanılabilecek bir tanımlayıcısı vardır.

Yeni bir nesne oluştururken, yapıcı yöntemi çağrılır, ona parametreler iletilir.

Yöntemler sınıfta bildirilebilir. Bizim durumumuzda merhaba (), sınıftan oluşturulan tüm nesneler tarafından çağrılabilen bir yöntemdir. Bu, Person sınıfını kullanarak yeni bir nesne oluşturmaya benziyor.

Const flavio = yeni Kişi ("Flavio") flavio.hello ()

Sınıfa Dayalı Kalıtım

Sınıflar diğer sınıfları genişletebilir. Bu tür sınıflardan oluşturulan nesneler, hem orijinal sınıfın yöntemlerini hem de genişletilmiş sınıfta tanımlanan yöntemleri devralır.

Başka bir sınıfı genişleten (bu sınıftan miras alan) bir sınıf, adı üst sınıfla aynı olan bir yönteme sahipse, bu yöntem orijinal yönteme göre önceliklidir.

Sınıf Programcısı Kişiyi genişletir (merhaba () (dönüş super.hello () + "Ben bir programcıyım.")) Const flavio = yeni Programcı ("Flavio") flavio.hello ()
Yukarıdaki örnekte merhaba () yöntemini çağırmak Hello, I am Flavio dizesini döndürür. Programcıyım.

Sınıflar, değişkenlerin (özellikler) varlığını sağlamaz, sınıflar kullanılarak oluşturulan nesnelerin özellikleri yapıcıda yapılandırılmalıdır.

Bir sınıf içinde, super anahtar sözcüğünü kullanarak üst sınıfa başvurabilirsiniz.

Statik Yöntemler

Bir sınıfta açıklanan yöntemler, sınıfın kendisine değil, bu sınıf temelinde oluşturulan nesnelere atıfta bulunularak çağrılabilir. Statik yöntemler, doğrudan sınıfa atıfta bulunularak çağrılabilir.

Özel Yöntemler

JavaScript, özel (özel, özel) yöntemleri bildirmenize izin veren yerleşik bir mekanizmaya sahip değildir. Bu sınırlama, örneğin kapaklar kullanılarak aşılabilir.

Alıcılar ve Ayarlayıcılar

Bir sınıfta, yöntemlerin önüne get veya set anahtar sözcükleri koyarak açıklayabilirsiniz. Bu, bir sınıftan oluşturulan nesnelerin özelliklerine erişimi kontrol etmek için kullanılan işlevler olan alıcılar ve ayarlayıcılar oluşturmanıza olanak tanır. Bir sözde özelliğin değerini okumak için bir girişimde bulunulduğunda bir alıcı çağrılır ve ona yeni bir değer yazılmaya çalışıldığında bir ayarlayıcı çağrılır.

Sınıf Kişisi (kurucu (isim) (bu.kullanıcıAdı = isim) isim (değer) ayarla (bu.kullanıcıAdı = değer) isim al () (bu.kullanıcıAdı döndür))

sonuçlar

Bu yazıda JavaScript'te değişkenler, veri türleri, ifadeler ve nesnelerle çalışma hakkında konuştuk. Fonksiyonlar bir sonraki yazımızın konusu olacak.

Sevgili okuyucular! Uzun süredir JS'de yazıyorsanız, lütfen bize class anahtar kelimesinin dilde görünümü hakkında ne düşündüğünüzü söyleyin.

"Basit hakkında zor" adlı bir dizi makale yazmaya karar verdim. Bu seri JavaScript diline odaklanacaktır. Neden "basit hakkında zor"? Çünkü anlatacağım her şeyi, veri türlerinden başlayarak tercümanın çalışmasının özelliklerini dikkate alarak anlatacağım. Bütün bunlar, daha sonra, örneğin, JavaScript'teki kalıtım yöntemleri ve diğer kalıplar hakkında, karmaşık olanı anlatabilmek için yapılacaktır.

JavaScript, prototipik bir organizasyona sahip nesne yönelimli bir programlama dilidir.
"Prototip organizasyon ile" ne anlama geliyor, bir sonraki makalede konuşacağız (kesinlikle olacak), ama neden "nesne yönelimli" olduğunu ve JS'deki her şeyin bir nesne olup olmadığını bugün öğreneceğiz.
JS, hedeflerini gerçekleştirmek için yalnızca 9 türe ihtiyaç duyar. Ayrıca, bunlardan sadece 6 tanesi programda mevcuttur, kalan 3 tanesi ise sadece uygulama seviyesinde mevcuttur ve spesifikasyon tarafından kullanılmaktadır. İlk bakışta (ve bu ilk yanlış anlamadır), JS'deki her şey nesnelerdir. Dolayısıyla, program için mevcut altı türden beşi sözde ilkeldir ve nesne değildir (aşağıda bunların nesnelerle neden ve nasıl karıştırıldığını açıklayacağım). Bu beş ilkel şunlardır:

- Dize (s = 'str')
- Sayı (n = 10)
- Boole (b = doğru)
Ve onlara "felsefi tipler" dediğim gibi:
- boş (v = boş)
- tanımsız (u = tanımsız)

Bu boştaki felsefi, değişkene hiçbir şey atanmadığı ve tanımsız, değişkene boş atandığı anlamına gelir. Bu durumda "hiçbir şey" ve "boşluk" arasındaki fark nedir - boş zamanlarınızda düşünün. Bunu şimdi yapmayacağız.

Programın kullanabileceği altıncı tip (nesne):
-Nesne(Object yapıcısıyla karıştırılmaması için, şu anda yalnızca soyut türlerden bahsediyoruz!) JavaScript'te nesneleri temsil eden tek türdür.
Bir nesne, bir dizi anahtar/değer çifti olarak temsil edilen bir veri yapısıdır (bunların tamamı). Değer, veri türlerinden herhangi biri olabilir - o zaman nesnenin bir özelliği, hatta bir işlev olacaktır - o zaman nesnenin bir yöntemi olacaktır.

İlkellerle çalışmanın sayısız yolu vardır. Değişkenlere değişmezler veya yapıcılar aracılığıyla atanabilecekleri gerçeğiyle başlayıp, ilkellerin değişkenlerde hiç bildirilemeyeceği gerçeğiyle, doğrudan onlarla çalışarak. Aynı ilkeller global değişkenlerde ve yerel değişkenlerde olabilir.

İşte bazı örnekler:

Var v1; // tanımsız (boş) yerel değişken var v2 = "2"; // string yerel değişmez değişken var v3 = new String (2); // yapıcı aracılığıyla bildirilen yerel değişken dizesi. String v4 = String (2) türünde yeni bir nesne yaratacaktır; // yapıcı aracılığıyla çağrılan dizge global değişkeni. Window.v4 "2" .length değişkenini oluşturacak; // dize bir değişken olmayacak, ancak zaten bir Object 34..toString () olarak kullanılabilir; // sayı bir değişken olmayacak, ancak zaten bir nesne olarak kullanılabilir 12. toString (); // sayı bir değişken olmayacak, ancak zaten bir nesne olarak kullanılabilir (22) .toString (); // sayı bir değişken olmayacak, ancak zaten bir nesne olarak kullanılabilir

Son 4 komutta, bir ilkel ile bir nesnenin nasıl karıştırıldığını açıkça görebilirsiniz - sonuçta, bir nokta aracılığıyla bir yöntem diyoruz - tıpkı bir nesne gibi. Görünüşe göre bu ilkeller gerçekten nesnelermiş.

Örneğin, bir değişkenin türünü kontrol ettiğimizde yanlış anlama daha da artar.

Var v = boş; typeof v;

Ve yanıt olarak "nesne" alıyoruz.

Ve yazarsak:
var v = boş; v Object örneği;

Sonra kafamda bir karışıklık belirecek, çünkü son satırın sonucu "yanlış" olacak. Yani, v değişkeni nesne türündedir, ancak Object türünden miras alınmaz. Ne halt?!

İlk olarak, hileyi typeof null ile açıklayacağım. Bu operatör, nesnenin türünü döndürür. Ve gerçek şu ki, typeof operatörü, sabit kodlanmış bir tablodan alınan bir dize değeri döndürür, burada şöyle yazılır: "null, return" nesnesi "". instanceof operatörü - bir şeyin belirtilen veri tipine ait olup olmadığını kontrol eder. Bunu nasıl yaptığını bir sonraki makalede anlatacağım, ancak sizi temin ederim ki bu durumda doğru çalıştı, ilkel boş değer hiçbir şekilde Object türünden miras alınmaz - kendisi, bir ilkel, geliştirmenin en düşük aşamasıdır. .

Tamam, typeof ve instanceof ile çözdük, ancak yöntemler ilkeller için çağrılır - tıpkı nesnelerin düz olması gibi! Nasıl bir nesne değilse?

Sorun şu. Sarıcı işlevler (yapıcılar) diye bir şey var (ve ikinci makalede tekrar açıklanacak). Tüm temel öğeler (Sayı (), Boolean (), Dize ()) ve diğerleri için kullanılabilirler. Özleri, bu tür ilkellerle çalışmak için yardımcı yöntemlere sahip olacak bir ilkelden bir nesne yaratmaktır.
Örneğin, şöyle bir değişken oluşturulabilir:

Var num = yeni Sayı (23.456);

Bu durumda, ilkel 23.456'dan bir nesne alırız.
Sayı türü için Number() yapıcısının toPrecision() yardımcı yöntemi vardır - sayı için anlamlı basamak sayısını belirler. Örneğin, anlamlı basamak sayısı 23.456 olarak ayarlanmışsa, 23.45 sayısını alırız.
Ve işte ilkelden bir nesne olarak bahsetmeye çalıştığımız zaman:

(23.456). içinHassas (4);

Yorumlayıcı, yeni Number (23.456) öğesini çağırarak ilkel öğeyi geçici olarak bir nesneye sarar ve ardından bu nesnenin şu anda sahip olduğu toPrecision () yöntemini çağırır. Bu nedenle, birçok kişi yanlışlıkla JS'deki her şeyin bir nesne olduğunu düşünür.

Olanların yanıltıcı ve yanlış anlaşılmasına dair başka bir örnek daha var. İşte kod:

Var str = 'str'; str.test = 'test'; // hata olmayacak, program çalışmaya devam edecek ancak konsol.log (str.test); // Tanımsız

Daha önce olduğu gibi, str'nin bir nesne olduğunu varsayarsak, yeni özellik testini neden hatırlamadığına şaşırırdık. Ama şimdi biliyoruz ki bir ilkelden bir nesne olarak bahsederken, geçici olarak String türünde bir nesneye sarılır. Ancak işlem tamamlandıktan sonra bu sarmalayıcı ve onunla birlikte yeni özellik testi kaybolur. İşte bu, sihir yok.

Aslında, ileriye bakıldığında, bir ilkel bir nesneye sarılırken, bütün bir kalıtım zinciri inşa edilir (daha sonra konuşacağımız gibi), ama aslında böyle bir "matryoshka" ortaya çıkıyor:

Nesne (Sayı (<примитив>)). JS'deki herhangi bir nesnenin ebeveyni, öyle ya da böyle, Object olacaktır. Bir nesnede bir özellik çağrıldığında, arama, nesnelerden birinde bu özelliği bulana veya tanımsız döndürene kadar veya arama bir yöntem içinse, bir istisna atar. Böylece, ilkel, mevcut Object nesnesinin özelliklerine de sahiptir. Prototip kalıtımın nasıl çalıştığından ve inceliklerinden ikinci yazıda bahsedeceğiz.

Yayınlamak istediğim ikinci makalenin entrikası için, yapıcı işlevlerle ilgili bir şeyden daha bahsedeceğim - bu tür dönüştürme. JS, kesin olarak yazılan bir dil değildir. Bu, bir değişken bildirirken onun ne tür olduğunu belirtmek zorunda olmadığımız ve ayrıca programın çalışması sırasında bu değişkene herhangi bir mutlak türdeki verinin eklenebileceği anlamına gelir. Ayrıca, örneğin matematiksel işlemlerde dize değişkenlerini veya bunun tersini, birleştirme işlemlerinde sayıları kullanabiliriz. Örnek:

Var str = "abc"; str + 1; // "abc1"

Burada, sayı - 1 türünde bir ilkel, bir dize ilkeline dönüştürülecektir. Nesnelerde, bu özellik toString () yöntemine yapılan çağrı yoluyla kullanılabilir, sayı türündeki nesnelerde, sayı türünden bir ilkel döndürecek bir valueOf () yöntemi vardır. Ama sadece nesnelerin metotları olabileceğini söyledik. Yani, bir ilkel bir türden diğerine dönüştürme sürecinde, bir nesnede de sarma var mı? Seni temin ederim. Bu yöntem, yapıcı işlevi yorumlayıcı tarafından new operatörü olmadan çağrıldığında örtük olarak çağrılır. Ne tür bir sihirli operatör yenidir ve onsuz bir yapıcı işlevi çağrıldığında ne olur ve böyle bir yapıcı işlevin ne olduğunu bir sonraki makalede konuşacağız. Şimdilik, benim sözüme güvenin - tür dönüşümü hemen gerçekleşir - ilkelden ilkel.

Buraya kadar elbette cevaplardan çok sorular var ama inanın ikinci makaleyi okuduktan sonra her şey çok daha şeffaf hale gelecek. Burada esas olarak merak uyandırdım ve bir takım soruları gündeme getirdim - tabiri caizse, zihinleri heyecanlandırdı. Ancak yine de bu makaleden bir şeyler öğrenilebilir:
1. “JS'deki her şey nesnedir” şeklindeki geleneksel inanışa rağmen, programcının kullanabileceği 6 veri türünden 5'inin ilkel olduğunu ve yalnızca birinin bir nesne türünü temsil ettiğini öğrendik.
2. Nesneler hakkında, bunun anahtar/değer çiftlerini içeren bir veri yapısı olduğunu öğrendik. Değer, veri türlerinden herhangi biri (ve bu, nesnenin bir özelliği olacaktır) veya bir işlev (ve bu, nesnenin bir yöntemi olacaktır) olabileceği zaman.
3. Ama ilkeller nesne değildir. Onlarla bir nesne gibi çalışabilseniz de (ve bu, ilkel bir nesne olduğu yanılgısına neden olur), ancak ...
4. Değişkenler hem basit (literal) bir yolla (var a = 'str') hem de yapıcı bir fonksiyonda (sarmalayıcı) (var a = new String ('str')) bildirilebilir. İkinci durumda, artık bir ilkel değil, String () sarmalayıcı işlevi tarafından oluşturulan bir nesne alacağız. (ne tür bir sihir operatörü yeni ve bir yapıcı işlevin ne olduğunu daha sonra öğreneceğiz).
5. Bir ilkel (yeni String ('str')) üzerinde bir sarmalayıcı oluşturarak onunla bir nesne olarak çalışabileceğinizi öğrendik. Yorumlayıcının ilkel ile bir nesne gibi çalışmaya çalıştığımızda etrafında oluşturduğu bu sarıcıdır, ancak işlem tamamlandıktan sonra yok edilir (bu nedenle, ilkel, atadığımız özelliği asla hatırlayamayacaktır. it a.test = 'test' - test özelliği sarıcı ile birlikte kaybolacaktır).
6. Nesnelerin, bir nesnenin dize temsilini döndüren bir toString () yöntemine sahip olduğunu öğrendik (sayı değeriOf() türü için sayısal bir değer döndürür).
7. Birleştirme veya matematiksel işlemler gerçekleştirirken, ilkellerin türlerini istenen türe göre yeniden tanımlayabildiğini fark ettik. Bunu yapmak için kendi türlerinin sarmalayıcı fonksiyonlarını kullanırlar, ancak new operatörü olmadan (str = String (str)) (Fark nedir ve nasıl çalışır, biraz daha konuşalım)
8. Son olarak typeof'un sabit kodlanmış bir tablodan değerler aldığını öğrendik (bu, typeof null // nesnesine dayalı başka bir yanlış anlamanın geldiği yerdir).

Programlama dillerinin hepsinde yerleşik veri yapıları vardır, ancak bunlar genellikle bir dilden diğerine farklılık gösterir. Bu makale, JavaScript'te bulunan yerleşik veri yapılarını ve sahip oldukları özellikleri listelemeye çalışır; bunlar diğer veri yapılarını oluşturmak için kullanılabilir. Mümkün olan yerlerde diğer dillerle karşılaştırmalar yapılır.

Dinamik yazma

JavaScript bir gevşek yazılmış veya bir dinamik dilim. JavaScript'teki değişkenler, herhangi bir belirli değer türüyle doğrudan ilişkili değildir ve herhangi bir değişkene her türden değer atanabilir (ve yeniden atanabilir):

foo = 42 olsun; // foo artık bir sayıdır foo = "bar"; // foo artık bir dizgedir foo = true; // foo artık bir boole

Veri tipleri

En son ECMAScript standardı sekiz veri türünü tanımlar:

• Yedi veri türü:

ilkel değerler

Nesneler dışındaki tüm türler değişmez değerler tanımlar (değiştirilemeyen değerler). Örneğin ve C'den farklı olarak, Dizeler değişmezdir. Bu tür değerlere "ilkel değerler" diyoruz.

Boole türü

Boolean mantıksal bir varlığı temsil eder ve iki değere sahip olabilir: true ve false. Daha fazla ayrıntı için Boolean ve Boolean'a bakın.

boş tip

Özellikler

JavaScript'te nesneler bir özellikler koleksiyonu olarak görülebilir. Nesne değişmez sözdizimi ile sınırlı bir dizi özellik başlatılır; sonra özellikler eklenebilir ve kaldırılabilir. Özellik değerleri, karmaşık veri yapılarının oluşturulmasını sağlayan diğer nesneler de dahil olmak üzere her türden değer olabilir. Özellikler, anahtar değerler kullanılarak tanımlanır. Bir anahtar değeri, bir Dize veya bir Sembol değeridir.

Belirli özniteliklere sahip iki tür nesne özelliği vardır: data özelliği ve erişimci özelliği.

Veri özelliği

Bir anahtarı bir değerle ilişkilendirir ve aşağıdaki niteliklere sahiptir:

Bir veri özelliğinin nitelikleri

Bağlanmak	Tip	Açıklama	Varsayılan değer
[]	Herhangi bir JavaScript türü	Özelliğe erişim erişimi tarafından alınan değer.	Tanımsız
[]	Boole	Yanlış ise, "s [] özelliği değiştirilemez.	YANLIŞ
[]	Boole	için ... döngüler içinde. Ayrıca bkz. Numaralandırılabilirlik ve özelliklerin mülkiyeti	YANLIŞ
[]	Boole	false ise, özellik "silinemez", bir erişimci özelliğiyle değiştirilemez ve [] ve [] dışındaki nitelikler "değiştirilemez.	YANLIŞ

Eski öznitelikler (ECMAScript 3'ten itibaren, ECMAScript 5'te yeniden adlandırıldı)

Bağlanmak	Tip	Açıklama
Sadece oku	Boole	ES5 [] özniteliğinin tersine çevrilmiş durumu.
DontEnum	Boole	ES5 [] özniteliğinin tersine çevrilmiş durumu.
DontSilme	Boole	ES5 [] özniteliğinin tersine çevrilmiş durumu.

erişimci özelliği

Bir değeri almak veya saklamak için bir anahtarı bir veya iki erişimci işleviyle (get ve set) ilişkilendirir ve aşağıdaki özniteliklere sahiptir:

Bir erişimci özelliğinin öznitelikleri

Bağlanmak	Tip	Açıklama	Varsayılan değer
[]	İşlev nesnesi veya tanımsız	İşlev, boş bir bağımsız değişken listesiyle çağrılır ve değere erişim gerçekleştirildiğinde özellik değerini alır. Ayrıca bakınız.	Tanımsız
[]	İşlev nesnesi veya tanımsız	İşlev, atanan değeri içeren bir argümanla çağrılır ve belirtilen bir özellik değiştirilmeye çalışıldığında yürütülür. Ayrıca bkz.	Tanımsız
[]	Boole	Doğruysa, özellik döngülerde for ... içinde numaralandırılır.	YANLIŞ
[]	Boole	false ise, özellik silinemez ve bir data özelliğine değiştirilemez.	YANLIŞ

Not: Nitelik genellikle JavaScript motoru tarafından kullanılır, bu nedenle ona doğrudan erişemezsiniz (Object.defineProperty () hakkında daha fazla bilgi edinin). Bu nedenle nitelik tek değil çift köşeli parantez içine alınır.

"Normal" nesneler ve işlevler

JavaScript nesnesi, anahtarlar ve değerler arasında bir eşlemedir. Anahtarlar dizelerdir (veya Semboller) ve değerler herhangi bir şey olabilir. Bu, nesneleri hashmapler için doğal bir uyum haline getirir.

Fonksiyonlar, ek olarak çağrılabilir olma özelliğine sahip normal nesnelerdir.

Tarih

Tarihleri ​​temsil ederken, en iyi seçim JavaScript'te yerleşik Date yardımcı programını kullanmaktır.

Dizinlenmiş koleksiyonlar: Diziler ve yazılan Diziler

Diziler, tamsayı anahtarlı özellikler ile "uzunluk" özelliği arasında belirli bir ilişki bulunan normal nesnelerdir. Ek olarak, diziler, dizileri işlemek için onlara bir avuç uygun yöntem sağlayan Array.prototype'dan miras alır. Örneğin, indexOf (dizide bir değer arama) veya push (diziye eleman ekleme) vb. Bu, Dizileri listeleri veya kümeleri temsil etmek için mükemmel bir aday yapar.

Yazılan Diziler, ECMAScript 2015 ile JavaScript'te yenidir ve temeldeki ikili veri arabelleğinin dizi benzeri bir görünümünü sunar. Aşağıdaki tablo, eşdeğer C veri türlerini bulmanıza yardımcı olur:

TypedArray nesneleri

Tip	Değer aralığı	Bayt cinsinden boyut	Açıklama	Web IDL türü	Eşdeğer C tipi
Int8Array	-128 ila 127	1	8-bit iki "s tamamlayıcı işaretli tamsayı	bayt	int8_t
Uint8Array	0 - 255	1	8 bitlik işaretsiz tam sayı	sekizli	uint8_t
Uint8ClampedArray	0 - 255	1	8 bitlik işaretsiz tam sayı (kenetlenmiş)	sekizli	uint8_t
Int16Array	-32768 - 32767	2	16-bit iki "s tamamlayıcı işaretli tamsayı	kısa	int16_t
Uint16Array	0 ila 65535	2	16 bit işaretsiz tam sayı	imzasız kısa	uint16_t
Int32Array	-2147483648 ila 2147483647	4	32-bit iki "s tamamlayıcı işaretli tamsayı	uzun	int32_t
Uint32Array	0 ila 4294967295	4	32 bit işaretsiz tam sayı	imzasız uzun	uint32_t
Float32Array	1,2x10 -38 - 3.4x10 38	4	32-bit IEEE kayan noktalı sayı (7 anlamlı basamak, ör. 1.1234567)	sınırsız şamandıra	batmadan yüzmek
Float64Array	5.0x10 -324 - 1.8x10 308	8	64-bit IEEE kayan noktalı sayı (16 anlamlı basamak, ör. 1.123 ... 15)	sınırsız çift	çift
BigInt64Array	-2 63 ila 2 63 -1	8	64-bit iki "s tamamlayıcı imzalı tamsayı	büyük	int64_t (uzun uzun imzalı)
BigUint64Array	0 - 2 64 -1	8	64 bit işaretsiz tam sayı	büyük	uint64_t (işaretsiz uzun uzun)

Anahtarlı koleksiyonlar: Haritalar, Kümeler, WeakMaps, WeakSets

Bu veri yapıları, anahtar olarak nesne referanslarını alır ve ECMAScript Edition 6'da tanıtılır. Set ve WeakSet bir nesne kümesini temsil ederken, Map ve WeakMap bir değeri bir nesneyle ilişkilendirir. Haritalar ve WeakMaps arasındaki fark, öncekinde nesne anahtarlarının yeniden sıralanabilmesidir. Bu, ikinci durumda çöp toplama optimizasyonlarına izin verir.

Haritalar ve Kümeler saf ECMAScript 5'te uygulanabilir. Ancak nesneler karşılaştırılamayacağından (örneğin "küçüktür" anlamında), arama performansı mutlaka doğrusal olacaktır. Bunların yerel uygulamaları (WeakMaps dahil), sabit zamana yaklaşık logaritmik olan arama performansına sahip olabilir.

Genellikle, verileri bir DOM düğümüne bağlamak için, özellikler doğrudan nesne üzerinde ayarlanabilir veya data-* öznitelikleri kullanılabilir. Bunun dezavantajı, verilerin aynı bağlamda çalışan herhangi bir komut dosyası için kullanılabilir olmasıdır. Haritalar ve WeakMaps, verileri bir nesneye özel olarak bağlamayı kolaylaştırır.

Yapılandırılmış veri: JSON

JSON (JavaScript Object Notation), JavaScript'ten türetilen ancak birçok programlama dili tarafından kullanılan hafif bir veri değişim biçimidir. JSON, evrensel veri yapıları oluşturur. Daha fazla ayrıntı için JSON ve JSON'a bakın.

Standart kitaplıkta daha fazla nesne

JavaScript, standart bir yerleşik nesne kitaplığına sahiptir. Daha fazla nesne hakkında bilgi edinmek için lütfen referansa bakın.

typeof operatörünü kullanarak türleri belirleme

typeof operatörü, değişkeninizin türünü bulmanıza yardımcı olabilir. Daha fazla ayrıntı ve Edge vakaları için lütfen okuyun.

Özellikler

Şartname	Durum	Yorum Yap
ECMAScript 1. Baskı (ECMA-262)	Standart	İlk tanım.
ECMAScript 5.1 (ECMA-262) Bu spesifikasyondaki "Türler" tanımı.	Standart
ECMAScript 2015 (6. Baskı, ECMA-262)	Standart	Sembol Eklendi.
ECMAScript Son Taslak (ECMA-262) Bu belirtimde "ECMAScript Veri Türleri ve Değerleri" tanımı.	Taslak