JavaScript Veri Türleri. Java Script Veri Türleri Javascript Değişkenleri ve Veri Türleri

Her zamanki gibi aşina olduğumuz şeyin tanımıyla başlayalım. Veri türleri nelerdir? Bu kavram tüm programlama dilleri için geçerlidir ve JavaScript burada benzersiz değildir. Wikipedia tanımına bakarsak veri türlerinin bir değerler kümesi olduğunu ve bu değerler üzerinde yapılan işlemler olduğunu öğreniyoruz. Basitçe söylemek gerekirse, veri türü aslında bir değişkende saklayıp üzerinde çalışabileceğimiz bir değer türüdür.

JavaScript Değişkenleri makalesinde bir değişkeni içine her şeyi koyabileceğiniz bir kutuya benzettik. Aslında bu herhangi bir şeydir ve her veri türünün bir değeri vardır. Herhangi bir programlama diline aşina olmasanız bile sezgisel olarak artık JavaScript'teki en az iki veri türünü adlandırabileceğinizi düşünüyorum. Doğru, bu bir sayı ve bir dize veya bir dize ve sayısal bir veri türüdür. Bir değişkene hem dizeleri hem de sayıları yazdığımızı hatırlıyor musunuz? Tek fark, dizeyi tırnak işaretleri içine almak zorunda olmamızdı.

Yani JavaScript'te altı veri türü vardır:

JavaScript. Hızlı başlangıç

boolean veya boolean değeri

Bu türlerin her birine hızlıca bir göz atalım. Dize veri türüyle başlayalım. Dize belki de en sık kullanılan veri türlerinden biridir. Her zaman dizelerle karşılaşırız: kullanıcı girişi bir dizedir, ürün adı bir dizedir, makale başlığı bir dizedir, vb.

Hatırlayacağınız gibi dizenin tek veya çift tırnak içine alınması gerekir. Tırnak türleri arasında hiçbir fark yoktur; JavaScript'te hem tek hem de çift tırnak aynı işlevi görür ve değişken adlarının çift tırnak içinde işlendiği PHP'den farklı olarak farklı değildir. Satır örneği:

var name = "John", soyisim = "Doe";

JavaScript. Hızlı başlangıç

Web uygulaması oluşturmaya yönelik pratik bir örnekle JavaScript'in temellerini öğrenin

Dizelerle ilgili her şey açıktır, devam edelim; bir sayı veya sayısal bir veri türü. JavaScript'te tamsayılar ve kayan noktalı sayılar (kesirli sayılar) aynı türdedir; sayı. Sayıları saklamak ve yazmak için tırnak işaretleri gerekli değildir, üstelik gereksizdirler ve bazen matematiksel işlemlerde beklenmedik sonuçlara yol açabilirler. JavaScript'te sayıların yazılmasına bir örnek:

var sayi1 = 2, sayi2 = 3,4 sayi3 = -5;

Lütfen sayının kesirli kısmının virgülle değil, noktayla (ondalık nokta) ayrıldığını unutmayın. Ayrıca numara imzalanabilir: Örnekte -5.

Dize ve sayı, JavaScript'te yaygın olarak kullanılan veri türleridir. Sonraki dört tür henüz sizin için net olmayabilir, ancak biraz sonra kodla daha yakından çalışmaya başladığımızda, geri kalan veri türleriyle nasıl çalışacağınızı pratikte anlayacaksınız.

Yani, boole türü veya boolean veri türü. Yalnızca iki olası değeri vardır: doğru ve yanlış. Basitleştirmek gerekirse, "evet" ve "hayır" veya "doğru" ve "yanlış" sözcükleriyle karşılaştırılabilirler. JavaScript'te boolean değerleri yazmaya bir örnek:

var evet = doğru, hayır = yanlış;

Doğru ve yanlışın büyük/küçük harfe duyarlı olduğunu unutmayın. Örneğin PHP'de true ve false sabitleri büyük/küçük harfe duyarlı değildir.

Sonraki iki özel değer null ve tanımsızdır. Çok benzerler ve aslında aynı şeyi kastediyorlar; anlamın yokluğu. tanımsız, yeni bildirilen ancak bir değere ayarlanmayan bir değişkenin değeri olacaktır; değer tanımlanmamıştır. null genellikle değişkenin değerini geçersiz kılmak, deyim yerindeyse bilinmez hale getirmek için bir değişkene yazılır. Aşağıdaki makalelerde, bu veri türleriyle JavaScript'te çalışmanın özelliklerini daha ayrıntılı olarak göreceğiz.

Son tür ise bir nesnedir. Değişkeni bir kutuyla karşılaştırırsak, nesne bir dizi kutuyla veya daha uygun bir şekilde, örneğin bir kitaplıktaki kutulardan oluşan bir katalogla karşılaştırılabilir. Her kutu imzalıdır ve her biri kendine ait bir şeyler içerir. Nesnelere daha sonra daha yakından bakacağız ancak şimdilik bir nesneyi nasıl deklare edebileceğinizi ve ona yazılan değerlere nasıl erişebileceğinizi görelim.

// nesne girişi var user = ( isim: "John", soyadı: "Doe", yıl: 2016 ); // nesnenin özelliklerine erişim uyarısı(kullanıcı.adı); uyarı(kullanıcı.soyadı); uyarı(kullanıcı.yıl);

JavaScript'teki değişkenler bir anahtar kelimeyle bildirilir var, Örneğin:

Bundan sonra değişkenin değerini ayarlayabilirsiniz:

x = "Örnek dize";

JavaScript dili, değişkenleri bildirmeden anında değişkenler oluşturmanıza olanak tanır, örneğin:

y = "ikinci dize";

Bu, y değişkenini oluşturacak ve bellekte ona yer ayıracaktır, ancak bu uygulama, betiğin okunmasını ve hata ayıklamasını zorlaştırır.

JavaScript'te değişkenlerin sabit bir türü yoktur; değişkenin türü, depoladığı verilere göre belirlenir. Örneğin şunları yapabilirsiniz:
bir değişkeni ortaya çıkarın ve ona bir sayı atayın ve ardından bir dize atayın.

JavaScript beş temel veri türünü destekler: sayı- sayılar; Sicim- çizgiler; Boolean– Boole tipi; Tanımsız- belirsiz; Hükümsüz- boş. Bu beş veri türüne temel veri türleri denir çünkü daha karmaşık veri türleri temel alınarak oluşturulmuştur. Üçü veri depolama açısından gerçekten ilgi çekicidir: sayılar, dizeler ve boolean'lar ve tanımsız ve boş türler belirli durumlarda ilgi çekicidir.

Sayılar

JavaScript'te sayısal veri türü tam sayıları ve gerçek sayıları içerir. Tamsayılar değer alabilir –2 53 önce 2 53 , gerçek olanlar kendi içerisinde büyük değerler alabilir ±1,7976 x 10308 veya içinde doğru olun ±2,2250x10-308 .

Sayılar üstel biçimde de yazılabilir.

Tamsayı onaltılı sayı yazmak için başına sıfır, ardından bir harf konulur X, ardından da rakamları içerebilen sayının kendisi 0 önce 9 ve gelen mektuplar Aönce F.

Onaltılık sayılar, bitsel işlemleri kullanırken ve renkleri depolamak için yararlı olabilir - Web için tüm renkler onaltılık olarak saklanır.

JavaScript dili ayrıca sekizli sayı sisteminde sayıları yazma yeteneğine de sahiptir: bir sayı yazmak için başına konur 0 , ardından gelen sayılar 0 önce 7 .

Özel numaralar

Matematiksel bir işlemin sonucu aralık dışındaysa değişken değeri alır. Sonsuzluk- sonsuzluk. Böyle bir sayı üzerinde herhangi bir işlem yapıldığında sonuç sonsuz olacaktır. Karşılaştırıldığında, pozitif sonsuzluk her zaman herhangi bir gerçek sayıdan büyüktür ve bunun tersi de geçerlidir, negatif sonsuzluk her zaman herhangi bir gerçek sayıdan küçüktür.

Bir diğer önemli özel değer ise NaN- "sayı değil" (sayı değil). Geri dönen bir işlemin tipik bir örneği NaN, sıfıra bölmedir. Bir değerin değişken olup olmadığını belirlemek için NaN, fonksiyon kullanılır isNaN(), geri dönen doğru sayı gerçekse (sonsuzluk dahil) ve YANLIŞ değişkenin değeri ise NaN.

Özel sayılar bir değişkenin alabileceği maksimum ve minimum değerlerdir. Tüm özel numaralar tabloda gösterilmektedir:

Teller

Bir dize, çift veya tek tırnak işaretleri ile sınırlandırılmış bir karakter dizisidir.

Bir dize oluşturulduktan sonra bir özelliği vardır – uzunluk dizenin uzunluğunu ve çok sayıda yöntemi döndüren:

karakter(dizin: Number) : String - belirli bir konumdaki karakteri döndürür;

birleştirme([dize1:Sicim[, … [, dizeN: String]]]]) : String - dizeleri bağlar ("+" operatörüne benzer);

indeksi(alt dize:Sicim[, Dizini başlat: Sayı]) : Sayı - dizedeki alt dizenin oluşum sayısını döndürür; isteğe bağlı bir parametre, aramanın başladığı karakterin sayısıdır. Alt dize bulunamazsa döndürür -1 . Arama soldan sağa yapılır, sağdan sola arama yapmak için yöntem kullanılır lastIndexOf() benzer bir sözdizimine sahip olan;

yer değiştirmek(rgExp:regExp, Metni değiştir: String) : String - normal ifadeyi bir dizeyle değiştirir;

bölmek([ ayırıcı: ( Dize | RegExp ) [, sınır: Sayı]]) : Dizi - bir dizeyi alt dizelerden oluşan bir diziye böler. İlk parametre olarak, bölmenin gerçekleştirildiği esasa göre bir ayırıcı iletilir, ayırıcı belirtilmezse, orijinal dizeye sahip bir öğe içeren bir dizi döndürülür. İkinci parametre, döndürülen dizideki maksimum öğe sayısını belirtir;

alt dizi(başlangıç:Sayı[, uzunluk: Number]) : String - belirli bir konumda başlayan ve belirli bir uzunluğa sahip bir alt dizeyi döndürür;

alt dize(başlangıç:Sayı, son: Number) : String - parametreler tarafından belirtilen konumlarda başlayan ve biten bir alt dizeyi döndürür.

boole tipi

Boolean değişkenleri iki değerden birini alabilir: doğru- gerçek; YANLIŞ- yalan. Boole değişkenleri genellikle koşullu ifadelerde kullanılır eğer. Örnek:

var doAlert = doğru;

if (doAlert) ( alarm(“Merhaba, Dünya!”); )

Tanımsız ve Null tipindeki değişkenler

Tip Tanımsız var olmayan değişkenler veya değerleri henüz tanımlanmamış değişkenler için kullanılır. Aşağıdaki örnekte değişken Xönemli olacak Tanımsız- yani tanımlanmamıştır.

Tip Hükümsüz boş bir değer anlamına gelir. Boş bir değişken bildirme örneği:

Diziler

JavaScript'te dizi, farklı verilerin sıralı bir koleksiyonudur. Dizinin tüm elemanları numaralandırılmıştır, dizinin ilk elemanı sıfır indekslidir. Dizinin belirli bir elemanına erişim, köşeli parantezler ve bu elemanın numarası kullanılarak gerçekleştirilir. Örnek:

myArr = "Merhaba!";

Boş bir dizi ve veri içeren bir dizi bildirmek:

var emptyArr = ;

var fillArr = ["Merhaba", "Dünya"];

Diziler çok boyutlu olabilir. Çok boyutlu bir diziyi bildirmek ve ona erişmek şuna benzer:

var benimArr = [,,];

//3x2'lik bir dizi oluşturup içindeki elemanın çıktısını alıyoruz
üçüncü satırda, ikinci sütunda 6'ya eşittir.

Bir dizi aslında bir nesne olduğundan aşağıdaki gibi bildirilebilir.

JavaScript'te değerler oldukça serbestçe (açık ve örtülü olarak) bir türden diğerine dönüştürülebilir. Örneğin, eğer bir operatör belirli bir türden bir değer almayı bekliyorsa ve ona başka bir türden bir değer iletilirse, yorumlayıcı otomatik olarak istenen türe dönüşümler gerçekleştirmeye çalışacaktır:

Console.log(10 + "arabalar"); // "10 araba". Sayı dolaylı olarak bir dizeye dönüştürülür console.log("7" * "4"); // 28. Her iki dize de örtülü olarak sayılara dönüştürülür

Örtülü dönüşüm- bu, tercümanın otomatik olarak tür dönüştürmeyi gerçekleştirdiği zamandır, yani programcının katılımı olmadan. Açık Dönüşüm- bu, programcının dönüşümü kendisi gerçekleştirdiği zamandır. Açık dönüşüm aynı zamanda şu şekilde de bilinir: tip döküm:

Console.log("7" * "4"); // 28. Örtülü dönüştürme console.log(Number("7") * Number("4")); // 28. Açık dönüşüm

Aşağıdaki tabloda JavaScript'in değerleri bir türden diğerine nasıl dönüştürdüğü açıklanmaktadır. Boş hücreler dönüşümün gerekli olmadığı durumlara karşılık gelir:

Basit türlere açık dönüşüm için aşağıdaki işlevler kullanılır: Boolean(), Number(), String(). Örtük dönüştürme için yorumlayıcı, açık dönüştürme için kullanılan işlevlerin aynısını kullanır.

Açık dönüştürme için işlevler yerine operatörleri kullanabilirsiniz. Örneğin, + operatörünün işlenenlerinden biri bir dize ise, diğer işlenen de bir dizeye dönüştürülür. Tekli operatör +, işlenenini bir sayıya dönüştürür. Tekli operatör! işleneni bir boolean değerine dönüştürür ve tersine çevirir. Bütün bunlar, pratikte bulunabilen aşağıdaki tuhaf tip dönüşümlerinin ortaya çıkmasına yol açmıştır:

X + "" // String(x) ile aynı +x // Number(x) ile aynı. Ayrıca x - 0 !!x // Boolean(x) ile aynı şekilde görebilirsiniz.

Sayılara dönüştür

Number() işlevi, değerleri aşağıdaki kurallara göre dönüştürür:

• True ve false Boolean değerleri sırasıyla 1 ve 0'a dönüştürülür.
• Sayılar değişmeden döndürülür.
• Boş değer 0'a dönüştürülür.
• Tanımsız değer NaN'ye dönüştürülür.

Dizeler için özel kurallar vardır:

• Dize yalnızca önünde + veya - işareti bulunan veya işareti olmayan rakamlar içeriyorsa, her zaman ondalık tamsayıya dönüştürülür. Baştaki sıfırlar göz ardı edilir; örneğin "0011", 11'e dönüştürülür.
• Dize, başında + veya - işareti bulunan veya işareti olmayan kayan noktalı bir sayıysa, karşılık gelen kayan noktalı sayıya dönüştürülür (baştaki sıfırlar da dikkate alınmaz).
• Dize onaltılık bir sayıysa karşılık gelen ondalık tamsayıya dönüştürülür.
• Dize boşsa 0'a dönüştürülür.
• Dize önceki seçeneklerden farklı bir şey içeriyorsa NaN'ye dönüştürülür.
• Nesneler için, valueOf() yöntemi çağrılır ve döndürdüğü değer, önceki kurallara göre otomatik olarak dönüştürülür. Bu dönüştürme NaN ile sonuçlanırsa toString() yöntemi çağrılır ve dizeleri sayılara dönüştürme kuralları uygulanır.

Tekli + ve - operatörleri Number() işleviyle aynı şekilde çalışır.

Boole dönüşümü

Boolean() işlevi, bir değeri boolean eşdeğerine dönüştürür:

• Aşağıdaki değerler dönüştürüldüğünde false olarak değerlendirilir: un define , null , 0 , -0 , NaN , "" .
• False değeri değişmeden döndürülür.
• Diğer tüm değerler true değerine dönüştürülür.

Dizelere dönüştür

String() işlevi, değerleri aşağıdaki kurallara göre dönüştürür:

• Boş ve tanımsız dışındaki tüm değerler için toString() yöntemi otomatik olarak çağrılır ve değerin dize temsili döndürülür.
• Null için "null" dizesi döndürülür.
• Tanımsız için "tanımsız" dizesi döndürülür.

Basit türleri nesnelere dönüştürme

Basit değerleri nesnelere dönüştürmek için Boolean() , Number() , String() yapıcıları kullanılır:

oNum = yeni Sayı(3); var oStr = new String("1.2"); var oBool = new Boolean(true); uyarı(typeof oNum); // "nesne" uyarısı(oStr tipi); // "nesne" uyarısı(typeof oBool); // "nesne"

Nesneleri Basit Değerlere Dönüştürme

Tüm nesneler iki dönüştürme yöntemini miras alır: toString() ve valueOf() .

toString() yöntemi, nesnenin dize temsilini döndürür. Varsayılan olarak ilginç bir şey döndürmez:

Alert((x: 1).toString()); // ""

Bazı türlerde toString() yönteminin daha özel sürümleri bulunur. Örneğin, bir dizideki toString() yöntemi, dizinin tüm öğelerini dizelere dönüştürür ve ardından bunları aralarına virgül ekleyerek tek bir dizede birleştirir:

Alert(.toString()); // "1,2,3"

valueOf() yönteminin amacı çok açık bir şekilde tanımlanmamıştır: bir nesneyi, eğer böyle bir değer mevcutsa, onu temsil eden basit bir değere dönüştürmesi beklenir. Nesneler doğası gereği bileşik değerlerdir ve çoğu nesne tek bir basit değer olarak temsil edilemez; bu nedenle, varsayılan olarak valueOf() yöntemi basit bir değer döndürmez, ancak ona bir referans döndürür:

Alert(typeof(x:2).valueOf()); // "nesne"

Bir nesneyi dizeye dönüştürürken JavaScript yorumlayıcısı aşağıdakileri yapar:

• Nesnenin bir toString() yöntemi varsa yorumlayıcı onu çağırır. Basit bir değer döndürürse yorumlayıcı, değeri bir dizeye dönüştürür (eğer dize değilse) ve dönüşümün sonucunu döndürür.
• Nesnenin toString() yöntemi yoksa veya bu yöntem basit bir değer döndürmüyorsa yorumlayıcı, valueOf() yönteminin varlığını kontrol eder. Bu yöntem tanımlanmışsa yorumlayıcı onu çağırır. Basit bir değer döndürürse, yorumlayıcı bu değeri bir dizeye dönüştürür (eğer dize değilse) ve dönüşümün sonucunu döndürür.

Bir nesneyi sayıya dönüştürürken yorumlayıcı aynı eylemleri gerçekleştirir ancak önce valueOf() yöntemini uygulamaya çalışır:

• Nesnenin basit bir değer döndüren bir valueOf() yöntemi varsa, yorumlayıcı (gerekirse) bu değeri bir sayıya dönüştürecek ve sonucu döndürecektir.
• Nesnenin bir valueOf() yöntemi yoksa veya bu yöntem basit bir değer döndürmüyorsa yorumlayıcı toString() yönteminin varlığını kontrol eder. Nesnenin basit bir değer döndüren bir toString() yöntemi varsa yorumlayıcı dönüşümü gerçekleştirir ve elde edilen değeri döndürür.
• Aksi halde yorumlayıcı, ne toString() ne de valueOf() işlevinin basit bir değer vermediğini ve TypeError değerini yükseltmediğini anlar.

toString() ve valueOf() yöntemleri okuma/yazma yöntemidir, dolayısıyla bunları geçersiz kılabilir ve dönüştürüldüğünde neyin döndürüleceğini açıkça belirtebilirsiniz:

var nesne = (); obj.toString = function() ( return "nesne"; ); warning("Bu " + obj); // "Bu bir nesnedir"

"Basitten zor" adlı bir dizi makale yazmaya karar verdim. Bu döngü JavaScript diline ayrılacaktır. Neden "basitten zor"? Çünkü anlatacağım her şeyi veri türlerinden başlayarak yorumlayıcının özelliklerini dikkate alarak anlatacağım. Bütün bunlar, daha sonra karmaşık hakkında, örneğin JavaScript'teki kalıtım yöntemleri ve diğer kalıplar hakkında konuşmak mümkün olacak şekilde yapılacaktır.

JavaScript, prototip organizasyonuna sahip, nesne yönelimli bir programlama dilidir.
“Prototip organizasyonla” ne anlama geliyor, bir sonraki makalede konuşacağız (kesinlikle öyle olacak), ama neden “nesne odaklı” olduğunu ve JS'deki her şeyin bir nesne olup olmadığını bugün öğreneceğiz.
JS'nin amacını gerçekleştirmek için yalnızca 9 türe ihtiyacı vardır. Üstelik bunlardan sadece 6 tanesi programda mevcuttur, geri kalan 3 tanesi ise sadece uygulama düzeyinde mevcuttur ve spesifikasyon tarafından kullanılır. İlk bakışta (ve bu ilk yanılgıdır) JS'deki her şey bir nesnedir. Dolayısıyla, programın kullanabileceği altı türden beşi, ilkel olarak adlandırılan türlerdir ve nesne değildir (aşağıda bunların neden ve nasıl nesnelerle karıştırıldığını açıklayacağım). Bu beş ilkel şunlardır:

- Dize (s='str')
- Sayı (n=10)
- Boolean (b=doğru)
Ben onlara "felsefi tipler" diyorum:
- boş (v = boş)
- tanımsız (u=tanımsız)

Bu null'daki felsefi, değişkene hiçbir şeyin atanmadığı anlamına gelir ve tanımsız, değişkene boşluğun atandığı anlamına gelir. Bu durumda "hiçbir şey" ile "boşluk" arasındaki fark nedir - boş zamanınızda düşünün. Şimdi bunu yapmayacağız.

Programın kullanabileceği altıncı tür (nesne):
-Nesne(Object yapıcısıyla karıştırmayın, artık yalnızca soyut türlerden bahsediyoruz!), JavaScript'teki nesneleri temsil eden tek türdür.
Bir nesne, bir dizi anahtar/değer çifti olarak temsil edilen bir veri yapısıdır (bunlardan oluşan bir küme). Değer veri türlerinden herhangi biri olabilir - o zaman nesnenin bir özelliği, hatta bir işlevi olacaktır - o zaman nesnenin bir yöntemi olacaktır.

İlkellerle çalışmanın pek çok yolu vardır. Değişkenlere değişmez değerler veya yapıcılar aracılığıyla atanabilecekleri gerçeğiyle başlayıp, ilkellerin doğrudan onlarla çalışarak değişkenlere bildirilemeyeceği gerçeğiyle sona erer. İlkeller ayrıca global değişkenlerde ve yerel değişkenlerde olabilir.

İşte bazı örnekler:

varv1; //tanımsız (boş) yerel değişken var v2='2'; //dize yerel değişmez değişken var v3 = new String(2); //yapıcı aracılığıyla bildirilen yerel değişken dizesi. Türünde yeni bir nesne oluşturur String v4 = String(2); //string global değişken yapıcı aracılığıyla çağrıldı. window.v4 "2".length değişkenini oluşturun; // dize bir değişken haline gelmeyecek, 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, ilkelin bir nesneyle nasıl karıştırıldığını açıkça görebilirsiniz - sonuçta, tıpkı bir nesne gibi, bir nokta aracılığıyla yöntem diyoruz. Aslında bu ilkellerin nesneler olduğu görülüyor.

Bir değişkenin tipini kontrol ettiğimizde kavram yanılgısı daha da şiddetlenir; örneğin

varv = boş; typeofv;

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

Ve eğer yazarsak:
var v = boş; v nesne örneği;

O zaman kafa karışacak çünkü son satırın sonucu “yanlış” olacak. Yani v değişkeni object türündedir ancak Object türünden miras alınmamıştır. Bu da ne?!

Öncelikle typeof null ile yakalamayı açıklayacağım. Bu operatör nesnenin türünü döndürür. Ancak gerçek şu ki typeof operatörü, sabit kodlanmış bir tablodan alınan bir dize değeri döndürür ve burada şöyle yazılır: "boş değer için," nesneyi döndür ". Instanceof operatörü bir şeyin belirtilen veri tipine ait olup olmadığını kontrol eder. Bir sonraki makalede bunu nasıl yaptığını size anlatacağım, ancak sizi temin ederim ki, bu durumda doğru çalıştı, boş ilkel hiçbir şekilde Object türünden miras alınmamıştır - kendi içindedir, ilkel, nesnenin en alt aşamasıdır. gelişim.

Tamam, typeof ve exampleof'u bulduk, ancak yöntemler tıpkı nesnelerde olduğu gibi ilkellerde de çağrılır! Peki ya bu bir nesne değilse?

İşte olay şu. Sarmalayıcı işlevler (yapıcılar) diye bir şey var (ve yine ikinci makalede her şey netleşecek). Bunlar tüm temel öğeler (Number(), Boolean(), String()) ve diğerleri için mevcuttur. Bunların özü, belirli bir ilkel türüyle çalışmak için yardımcı yöntemlere sahip olacak bir ilkelden bir nesne yaratmaktır.
Örneğin şöyle bir değişken oluşturabilirsiniz:

Varnum = yeniSayı(23.456);

Bu durumda ilkel 23.456'dan bir nesne alacağız.
Sayı türü için Number() yapıcısı, sayının anlamlı basamaklarının sayısını belirleyen bir toPrecision() yardımcı yöntemine sahiptir. Örneğin 23.456 sayısı 4 anlamlı basamağa ayarlanırsa 23.45 sayısını elde ederiz.
İşte o zaman ilkel olanı bir nesne olarak adlandırmaya çalışıyoruz:

(23.456). Hassasiyet(4);

Yorumlayıcı, new Number(23.456) öğesini çağırarak ilkel öğeyi geçici olarak bir nesneye sarar ve ardından bu nesne üzerinde ş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ğuna inanır.

Bir de yanıltıcı, olup bitenin yanlış anlaşılmasına neden olan bir örnek daha var. İşte kod:

var dizi = 'str'; str.test = 'test'; //hata olmayacak program çalışmaya devam edecek ama console.log(str.test); //Tanımsız

Daha önce olduğu gibi str'nin bir nesne olduğunu düşünseydik, neden yeni test özelliğini hatırlamadığını merak ederdik. Ancak artık biliyoruz ki, bir ilkel nesne olarak adlandırıldığında 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 test özelliği kaybolur. İşte bu, sihir yok.

Aslında ileriye baktığımızda, ilkel bir nesneye sarılırken, bütün bir miras zinciri inşa edilir (bunun nasıl organize edildiğinden daha sonra bahsedeceğiz), ancak özünde 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önene kadar tüm bu “matryoshka” üzerinden geçer veya bir yöntem aranmışsa bir istisna atar. Böylece Object nesnesinin özellikleri ilkel için de mevcuttur. İkinci yazımızda prototip kalıtımın nasıl işlediğinden ve inceliklerinden bahsedeceğiz.

Yayınlamak istediğim ikinci makaleyle ilgili merak uyandırmak için size yapıcıların işlevleriyle ilgili bir noktadan daha bahsedeceğim - bu tür dönüşümüdür. JS kesin olarak yazılan bir dil değildir. Bu, bir değişken bildirirken onun tipini belirtmemize gerek olmadığı ve ayrıca programın çalışması sırasında herhangi bir mutlak tipteki verinin bu değişkene yerleştirilebileceği anlamına gelir. Ayrıca, örneğin matematiksel işlemlerde dize değişkenlerini veya birleştirme işleminde sayıları da kullanabiliriz. Örnek:

var dizi = "abc"; dizi+1; // "abc1"

Burada, number - 1 türünde bir ilkel, bir dize temeline dönüştürülecektir. Nesnelerde bu özellik, toString() yöntemine yapılan bir çağrı yoluyla kullanılabilir; tür numarasına sahip nesnelerde, tür numarasının ilkel değerini döndürecek bir valueOf() yöntemi vardır. Ancak sadece nesnelerin yöntemleri olabileceğini söylemiştik. Yani bir ilkel türü bir türden diğerine dönüştürme sürecinde, aynı zamanda bir nesneye sarma da var mı? Sizi temin ederim ki öyle değil. Bu yöntem, yapıcı işlevi yorumlayıcı tarafından new operatörü olmadan çağrıldığında dolaylı olarak çağrılır. New nasıl bir sihirli operatördür ve yapıcı işlevi onsuz çağrıldığında ne olur ve sonuçta bu yapıcı işlevi nedir, bir sonraki makalede konuşacağız. Şimdilik sözüme güvenin - ilkelden ilkel'e tip dönüşümü hemen gerçekleşir.

Şimdiye kadar elbette cevaplardan çok soru var ama inanın bana ikinci makaleyi okuduktan sonra her şey çok daha netleşecek. Burada temelde ilgimi çektim ve bir dizi soruyu gündeme getirdim - tabiri caizse zihinleri karıştırdım. Ancak yine de bu makaleden bir şeyler öğrenilebilir:
1. "JS'deki her şey bir nesnedir" şeklindeki yaygın görüşe rağmen, bir programcının kullanabileceği 6 veri türünden 5'inin ilkel olduğunu ve yalnızca birinin 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) olduğunda.
3. Ancak ilkeller nesne değildir. Her ne kadar onlarla bir nesneyle çalışır gibi çalışabilseniz de (ve bu, ilkelin bir nesne olduğu yanılgısına neden olur), ama ...
4. Değişkenler hem basit (tam anlamıyla) (var a = 'str') hem de bir yapıcı işlevi (sarmalayıcı) (var a = new String('str')) aracılığıyla bildirilebilir. İkinci durumda, artık bir ilkel değil, String() sarmalayıcı işlevi tarafından oluşturulan bir nesne elde edeceğiz. (yeni sihirli operatör nedir ve yapıcı işlevi nedir, daha fazlasını öğreneceğiz).
5. İlkel (new String ('str')) üzerinde bir sarmalayıcı oluşturarak onunla bir nesneyle çalışır gibi çalışabileceğinizi öğrendik. Yorumlayıcının, onunla bir nesne olarak çalışmaya çalıştığımızda ilkelin etrafında oluşturduğu bu sarmalayıcıdır, ancak işlem tamamlandıktan sonra yok edilir (bu nedenle, ilkel, kendisine atadığımız özelliği asla hatırlayamayacak) a.test = 'test' - test özelliği sarmalayıcıyla birlikte kaybolacaktır).
6. Nesnelerin, 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ürecektir).
7. Birleştirme veya matematiksel işlemler gerçekleştirirken ilkellerin kendi türlerini istedikleri gibi yeniden tanımlayabileceklerini anladı. Bunu yapmak için kendi türlerindeki sarmalayıcı işlevleri kullanırlar, ancak new operatörü olmadan (str = String(str)) (fark nedir ve nasıl çalışır, daha sonra konuşacağız)
8. Ve son olarak typeof'un sabit kodlanmış bir tablodan değer aldığını öğrendik (typeof null //object'e dayalı bir başka yanılgı da buradan geliyor).

JavaScript veya JS(kısacası) kolay bir dil değil ve acemi geliştiriciler bunu hemen öğrenemeyecekler. İlk başta temelleri öğreniyorlar ve her şey renkli ve güzel görünüyor. Biraz daha derine inersek, çoğu zaman beyni şaşırtan JavaScript dizileri, nesneler, geri aramalar ve benzeri şeyler var.

JavaScript'te değişkenin tipini doğru şekilde kontrol etmek önemlidir. Diyelim ki bir değişkenin dizi mi yoksa nesne mi olduğunu bilmek istiyorsunuz? Doğru şekilde nasıl kontrol edilir? Bu özel durumda, doğrulama sırasında püf noktaları vardır ve bu yazının konusu da budur. Hemen başlayalım.

Bir değişkenin türünü kontrol etme

Örneğin bir değişkenin bir nesne mi, dizi mi, dize mi yoksa sayı mı olduğunu kontrol etmeniz gerekir. Bunun için typeof kullanabilirsiniz, ancak bu size her zaman gerçeği söylemez ve bunun nedenini aşağıdaki örnekte size göstereceğim.

Bu örneği neden typeof'un her zaman doğru seçim olmadığını göstermek için yazdım.

Var _comparison = ( string: "string", int: 99, float: 13.555, object: (merhaba: "merhaba"), dizi: new Array(1, 2, 3) ); // Nesnenin anahtarlarını içeren bir dizi döndürür var _objKeys = Object.keys(_comparison); for(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Kod yürütmenin sonucu:

Dize numarası nesnesi nesnesi

Sağ? - Tabii ki değil. İki sorun var. Bunların her biri ayrıntılı olarak açıklanacak ve bir çözüm önerilecektir.

İlk sorun: kayan sayı, sayı olarak çıktı

Comparison.float bir sayı değildir ve sayı yerine kayan nokta olmalıdır.Bunu düzeltmek için aşağıdaki koddaki gibi kontrol içeren bir fonksiyon oluşturabilirsiniz.

Var_floatNumber = 9,22; var_notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); function isFloat(n)( return Number(n) === n && n % 1 !== 0; )

isFloat() işlevi, kayan nokta sayılarına ilişkin tüm değerleri kontrol eder. İlk önce değişkenin eşit olup olmadığını kontrol edin N sayı (Sayı(n) === n) ve evet ise kalanla bölme işlemi için bir kontrol daha yapılır ve kalan varsa boole değeri döndürülür ( doğru veya YANLIŞ) sonuç (n % 1 !== 0).

Yukarıdaki örnekte şunu döndürür: doğru, YANLIŞ Ve YANLIŞ. İlk anlamı batmadan yüzmek yazın, ikincisi değil - bu normal bir sayıdır ve sonuncusu yalnızca kurallara uymayan boş bir dizedir.

İkinci sorun: Dizi bir nesne olarak tanımlandı

İlk örnekte, dizi bir nesne olarak işleniyor ve bu pek iyi değil çünkü bazen bu türü kullanmanız gerekir, başka hiçbir şeyi kullanmanız gerekmez.

Bir dizi türü için bir değişkeni test etmenin birkaç yolu vardır.

İlk seçenek (iyi seçenek). Instanceof() işlevini kullanarak verilerin bir diziye ait olup olmadığını kontrol edin.

Var veri = new Array("merhaba", "dünya"); var isArr = Dizinin veri örneği;

İkinci seçenek (iyi seçenek). Array.isArray() yöntemi, değişkenin bir dizi olup olmamasına () bağlı olacak bir boolean değeri döndürür.

Var veri = new Array("merhaba", "dünya"); var isArr = Array.isArray(veri);

Üçüncü seçenek (en iyisi ama uzun). Kolaylık sağlamak için bu yöntemi bir işlev haline getirebilirsiniz. Yaptığımız Nesneyi kullanarak. Object.prototype.toString.call(data) sonucu eşit değilse, değişken bir dizi () değildir.

Var veri = new Array("merhaba", "dünya"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Kolaylık fonksiyonu olarak son sonuç:

İşlev isArray(data) ( return Object.prototype.toString.call(data) == "" )

Artık isArray() işlevlerini çağırabilir ve bir diziyi veya başka bir şeyi argüman olarak ayarlayabilir ve sonucu görebilirsiniz.

Sonsöz

Rekorun başlangıçta amaçlandığından oldukça büyük olduğu ortaya çıktı. Ancak bundan memnunum çünkü JavaScript'te değişkenleri doğrulamanın zorluklarını ve bunların üstesinden nasıl gelineceğini açıklayacak kadar kısa ve net.

Sorularınız varsa lütfen bu gönderinin altına yazın. Yardım etmekten memnuniyet duyarım.