Dinamik tip tanımlama

Dinamik Tip Tanımlama (RTTI)çalışma zamanında bir nesnenin türünü belirlemenizi sağlar. Çeşitli nedenlerle yararlı olduğu ortaya çıkıyor. Özellikle, temel sınıfa atıfta bulunarak, bu bağlantıdan mevcut olan nesne türünü oldukça doğru bir şekilde belirleyebilirsiniz. Dinamik tip tanımlaması ayrıca, tip dökümünün ne kadar başarılı olacağını önceden kontrol etmenizi sağlar ve yanlış tip dönüşümünden kaynaklanan bir istisnayı önler. Ek olarak, dinamik tip tanımlaması, yansımanın önemli bir bileşenidir.

Dinamik tür tanımlamayı desteklemek için C# üç anahtar sözcük sağlar: is, as ve typeof. Bu anahtar kelimelerin her biri aşağıda sırasıyla tartışılmaktadır.

operatör

Bir nesnenin belirli türü is operatörü kullanılarak belirlenebilir. Genel formu aşağıda gösterilmiştir:

ifade türdür

burada ifade, türü kontrol edilen nesneyi açıklayan ayrı bir ifadeyi belirtir. İfade uyumlu bir türdeyse veya test edilen türle aynı türdeyse, bu işlemin sonucu doğrudur, aksi takdirde yanlıştır. Bu nedenle, ifade şu veya bu biçimde test edilebilir bir türe sahipse sonuç doğrudur. is operatörü, aynı tipteyse veya referans dönüştürme, kutulama veya kutudan çıkarma sağlanmışsa, her iki türün de uyumlu olacağını tanımlar.

Aşağıda is operatörünün kullanımına bir örnek verilmiştir:

Sistemi Kullanmak; namespace ConsoleApplication1 (class Add () class Sum: Add () class Program (static void Main()) (Add a = new Add (); Sum s = new Sum (); if (a Add ise) Console.WriteLine ("Değişken) a, Add türündedir "); if (s, Sum) Console.WriteLine (" s türü, Add sınıfından devralınmıştır "); Console.ReadLine (;)))

operatör olarak

Bazen tür dönüştürmenin çalışma zamanında yapılması gerekir, ancak dönüştürme başarısız olursa bir istisna oluşturmaz, bu tür döküm ile oldukça mümkündür. Bu amaçla, aşağıdaki genel forma sahip olan as operatörü kullanılır:

tür olarak ifade

burada ifade, belirtilen türe dönüştürülecek tek bir ifadeyi belirtir.

Bu dönüştürme başarılı olursa, türe bir başvuru, aksi takdirde boş bir başvuru döndürülür. as operatörü yalnızca referans dönüştürme, kimlik, kutulama, kutudan çıkarma için kullanılabilir. Bazı durumlarda, as operatörü is operatörüne uygun bir alternatif olarak hizmet edebilir. Örnek olarak, aşağıdaki programı düşünün:

Sistemi Kullanmak; ad alanı ConsoleApplication1 (sınıf Add () sınıfı Sum: Add () sınıfı Program (static void Main () (Add a = new Add (); Sum s = new Sum (); // Typecasting'i Add olarak gerçekleştirin a = s); if ( a! = null) Console.WriteLine ("Dönüşüm başarılı"); else Console.WriteLine ("Dönüşüm başarısız"); Console.ReadLine ();)))

Bu programın sonucu başarılı bir dönüşüm olacaktır.

JavaScript veya J'ler(kısaltılmış) kolay bir dil değildir ve acemi geliştiriciler bunu hemen öğrenmezler. İlk başta temel bilgileri öğrenirler ve her şey renkli ve güzel görünür. Biraz daha derine inildiğinde, beynin sıklıkla çıkardığı JavaScript dizileri, nesneler, geri aramalar ve benzerleri görünür.

JavaScript'te bir değişkenin türünü doğru şekilde kontrol etmek önemlidir. Bir değişkenin dizi mi yoksa nesne mi olduğunu bilmek istediğinizi varsayalım. Doğru nasıl kontrol edilir? Bu özel durumda, kontrol sırasında hileler vardır ve bu giriş bununla ilgili olacaktır. Hemen başlayalım.

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

Örneğin, bir değişkenin bir nesne, dizi, dize veya sayı olup olmadığını kontrol etmeniz gerekir. Bunun için typeof kullanabilirsiniz, ancak size her zaman gerçeği vermeyecektir ve aşağıdaki örnekte nedenini göstereceğim.

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

Var _comparison = (string: "string", int: 99, float: 13.555, nesne: (merhaba: "merhaba"), dizi: yeni Dizi (1, 2, 3)); // Nesne anahtarlarına sahip 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]]); }

Kodu çalıştırmanın sonucu:

Dize numarası numarası nesne nesnesi

Doğru? - Tabii ki değil. İki sorun var. Her biri ayrıntılı olarak anlatılacak ve bir çözüm önerilecektir.

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

Karşılaştırma.float bir sayı değildir ve sayı yerine kayan nokta olmalıdır.Bunu düzeltmek için aşağıdaki kodda olduğu gibi doğrulamalı bir fonksiyon oluşturabilirsiniz.

Var _floatNumber = 9.22; var _notFloatNumber = 9; konsol.log (isFloat (_floatNumber)); konsol.log (isFloat (_notFloatNumber)); konsol.log (isFloat ("")); isFloat (n) işlevi (dönüş Sayısı (n) === n && n% 1! == 0;)

isFloat () işlevi, kayan nokta sayıları için tüm değerleri kontrol eder. İlk olarak, değişkenin eşit olup olmadığını kontrol eder. n sayı (Sayı (n) === n) ve öyleyse, kalanla bölme için başka bir kontrol yapılır ve kalan varsa, o zaman bir boolean ( NS veya YANLIŞ) sonuç (n% 1! == 0).

Yukarıdaki örnekte, şunu döndürür: NS, YANLIŞ ve YANLIŞ... İlk anlamı batmadan yüzmek yazın, ikincisi değildir - bu sıradan bir sayıdır ve sonuncusu kurallara uymayan boş bir dizedir.

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

İlk örnekte, dizi bir nesne olarak görüntülendi ve bu pek iyi değil çünkü bazen bu belirli türü kullanmanız ve başka bir şey 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() kullanarak verinin bir diziye ait olup olmadığını kontrol ederiz.

Var data = 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 olmadığına bağlı olacak bir boole değeri döndürür ().

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

Üçüncü seçenek (en iyisi, ancak en uzun). Kolaylık sağlamak için bunu bir işlev haline getirebilirsiniz. Object kullanarak yapıyoruz. Object.prototype.toString.call (veri) sonucunun sonucu eşit değilse, değişken bir dizi () değildir.

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

Kolaylık işlevi olarak son sonuç:

isArray (veri) işlevi (dönüş Object.prototype.toString.call (veri) == "")

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

son söz

Kayıt, başlangıçta amaçlanandan oldukça büyük çıktı. Ancak bundan memnunum, çünkü JavaScript'teki değişkenleri kontrol etmenin zorluklarını ve bunların nasıl aşılacağını kısaca ve net bir şekilde açıklıyor.

Hala herhangi bir sorunuz varsa - bunları bu girişin altına yazın. Yardım etmekten mutlu olacağım.

a = (b> 0) && (c + 1! = d); bayrak =! (durum = 0);

Tablo 14.5. Mantıksal operatörler

Operatör Açıklaması

! DEĞİL (mantıksal ters çevirme)

&& VE (mantıksal çarpma)

|| VEYA (mantıksal ekleme)

Tablo 14.6. AND ve OR operatörlerini yürütmenin sonuçları

işlenen 1	işlenen 2

Tablo 14.7. DEĞİL ifadesinin sonuçları

Operatör typeof'u al

Tür Operatörünü Al typeof, işlenenin veri türünü tanımlayan bir dize döndürür. Türünü bilmek istediğiniz işlenen bu operatörün ardından gelir ve parantez içine alınır:

s = typeof ("str");

Bu ifadenin bir sonucu olarak, s değişkeni, dize türünü belirten "dize" dizesini içerecektir.

typeof operatörünün döndürebileceği tüm değerler tabloda listelenmiştir. 14.8.

	Tablo 14.8. typeof operatörü tarafından döndürülen değerler
Veri tipi		döndürülen dize
Sicim
Sayısal

			Tablo 14.8 (son)
	Veri tipi	döndürülen dize
	Mantıklı

Veri türü uyumluluğu ve dönüştürme

Şimdi iki önemli konuyu daha ele almanın zamanı geldi: veri türü uyumluluğu ve bir türden diğerine dönüştürme.

İki sayıyı birbirine eklediğinizde ne olur? Bu doğru - bir sayısal değer daha. Ve bir sayı ve bir dize eklerseniz? Söylemesi zor... Burada JavaScript, veri tiplerinin uyumsuzluğu sorunu ile karşı karşıya kalıyor ve bu tiplerden birini diğerine çevirerek uyumlu hale getirmeye çalışıyor. Önce dizeyi bir sayıya dönüştürmeye çalışır ve başarılı olursa toplama işlemini gerçekleştirir. Başarısız olursa, sayı bir dizgeye dönüştürülür ve elde edilen iki dizgi birleştirilir. Örneğin, Liste 14.6'daki Web komut dosyasını çalıştırmak, a'ya eklendiğinde b'nin değerini sayısal bir türe dönüştürür; bu nedenle, c değişkeni 23 değerini içerecektir.

Liste 14.6

var a, b, c, d, e, f; a = 11;

b = "12"; c = a + b;

d = "JavaScript"; e = 2;

Ancak d'nin değeri bir sayıya dönüştürülemediğinden, e'nin değeri bir dizgeye dönüştürülecek ve sonuç - f'nin değeri - olacaktır.

Boole değerleri, uygun olduğu şekilde sayısal veya dize değerlerine dönüştürülür. True, 1 sayısına veya "1" dizesine, false ise 0 veya "0"a dönüştürülür. Tersine, 1 sayısı doğruya dönüştürülecek ve 0 sayısı yanlışa dönüştürülecek. Ayrıca, false dönüştürülecek

değerler null ve tanımsızdır.

	Bölüm III. Web sayfalarının davranışı. Web komut dosyaları

JavaScript'in yanlış yazılmış ifadeleri bile doğru şekilde yürütmekte zorlandığı görülebilir. Bazen çalışır, ancak daha sık her şey planlandığı gibi çalışmaz ve sonunda, tamamen doğru operatörde tamamen farklı bir yerde bir hatanın bulunması nedeniyle Web komut dosyasının yürütülmesi kesintiye uğrar. Bu nedenle, bu tür olaylara izin vermemek daha iyidir.

Operatör önceliği

Burada inceleyeceğimiz son konu operatör önceliğidir. Hatırladığımız gibi, öncelik, bir ifadede ifadelerin yürütülme sırasını etkiler.

Aşağıdaki ifade olsun:

Bu durumda, önce c değeri b değişkeninin değerine eklenecek ve ardından toplamdan 10 çıkarılacaktır.Bu ifadenin operatörleri aynı önceliğe sahiptir ve bu nedenle kesinlikle soldan sağa yürütülür.

Şimdi şöyle bir ifade düşünelim:

Burada önce c değeri 10 ile çarpılacak ve ancak o zaman ortaya çıkan ürüne b değeri eklenecektir. Çarpma operatörü, toplama operatörüne göre önceliklidir, bu nedenle katı soldan sağa sıralama ihlal edilecektir.

Atama operatörleri en düşük önceliğe sahiptir. Bu nedenle önce ifadenin kendisi değerlendirilir ve ardından sonucu bir değişkene atanır.

V Genel olarak, tüm operatörlerin temel yürütme ilkesi şu şekildedir: önce daha yüksek önceliğe sahip operatörler ve ancak o zaman daha düşük önceliğe sahip operatörler yürütülür. Aynı önceliğe sahip operatörler, göründükleri sırayla (soldan sağa) yürütülür.

V sekme. 14.9, incelediğimiz tüm operatörleri önceliklerine göre azalan sırada listeler.

		Tablo 14.9. Operatör önceliği (azalan düzende)
	operatörler	Açıklama
	++ - - ~! bir çeşit	Arttırma, azaltma, işaret değişikliği, mantıksal DEĞİL, tür çıkarımı
		Çarpma, bölme, kalanı alma
		Dizelerin eklenmesi ve birleştirilmesi, çıkarılması
		Karşılaştırma Operatörleri
		mantıksal VE

	Bölüm 14. Web Programlamaya Giriş. JavaScript dili
			Tablo 14.9 (son)
	operatörler	Açıklama
		mantıksal VEYA
		Koşullu operatör (aşağıya bakın)
	= <оператор>=	Görev, basit ve karmaşık

DİKKAT!

Bu tabloyu unutmayın. Yanlış ifade yürütme sırası, kesinlikle doğru görünen bir ifadenin yanlış sonuç verdiği, tespit edilmesi zor hatalara yol açabilir.

Peki ya ifadelerin normal yürütme sırasını bozmamız gerekirse? Parantez kullanalım. Bu gösterimde, önce parantez içine alınmış ifadeler yürütülür:

a = (b + c) * 10;

Burada önce b ve c değişkenlerinin değerlerinin eklenmesi yapılacak ve ardından elde edilen toplam 10 ile çarpılacaktır.

Parantez içindeki operatörler de önceliğe tabidir. Bu nedenle, genellikle birden çok iç içe parantez kullanılır:

a = ((b + c) * 10 - d) / 2 + 9;

Burada ifadeler aşağıdaki sırayla yürütülecektir:

1. Ek b ve c.

2. Ortaya çıkan miktarı 10 ile çarpın.

3. Çarpımdan d çıkarılıyor.

4. Farkı 2'ye bölmek.

5. Bölüme 9 ekleyin.

Parantezleri kaldırırsanız:

a = b + c * 10 - d / 2 + 9;

daha sonra operatörlerin yürütme sırası aşağıdaki gibi olacaktır:

1. c ve 10'un çarpımı.

2. d'yi 2'ye bölmek.

3. Toplama b ve ürünler c ve 10.

4. Ortaya çıkan toplamdan bölmeden bölümün çıkarılması d'ye 2.

5. Ortaya çıkan farka 9 eklenir.

Sonuç tamamen farklı, değil mi?

• Tanımsız: "tanımsız"
• Boş: "nesne"
• Boole: "boole"
• Sayı: "sayı"
• Dize: "dize"
• işlev: "işlev"
• Diğer her şey: "nesne"

Bu tabloya aşağıdaki notlar eklenmelidir:

1. typeof null === "nesne".

Teorik olarak, bu ince bir nokta. Statik olarak yazılan dillerde, bir nesne türü değişkeni bir nesne (NULL, nil, null işaretçi) içermeyebilir.

Pratikte bu, JavaScript'te sakıncalıdır. Yani ES 5.1 geliştiricileri daha sezgisel bir şey yapacaklar: typeof null === "null".

Ancak şu ana kadar ES3'e sahip olduğumuz için, örneğin şu konuda hata yapmayın:

/ * Fonksiyon bir nesne arar ve onu veya hiçbir şey bulunamazsa null döndürür * / function search() () var obj = search(); if (typeof obj === "object") (// nesneyi gerçekten bulduk mu (FAIL) obj.method ();)

2. Sarıcı nesneleri unutmayın (typeof new Number (5) === "object").

3. Ve tarayıcıların ana bilgisayar nesneleri ile herhangi bir şey yapma hakkını unutmayın.

Safari'nin inatla HTMLCollection'ın bir işlev türü olduğunu düşünmesine şaşırmayın ve sürüm 9'dan önceki IE, favori uyarı () işlevini bir nesne olarak korudu. Ayrıca Chrome, RegExp'i işlev olarak düşünürdü, ancak şimdi onu algılamış ve nesne ile yanıt vermiş gibi görünüyor.

toString ()

toString() yönteminin sonucundan bir değerin türünü bulmaya çalışmak anlamsızdır. Tüm "sınıflarda" bu yöntem kendi başına geçersiz kılınır.

Yöntem, hata ayıklama bilgilerini görüntülemek için iyidir, ancak bir değişkenin türü onun tarafından belirlenemez.

Object.prototype.toString ()

toString, somut "sınıflar" içinde yeniden tanımlanmış olsa da, yine de orijinal uygulamasını Object'ten alıyoruz. Kullanmaya çalışalım:

konsol.log (Nesne .prototype .toString .call (değer));

konsol.log (Object.prototype.toString.call (değer));

Clinton bu yükü sulandırır

İşin garibi, bu yöntem şaşırtıcı derecede iyi çalışıyor.

Skaler türler için, döner,,,.

İşin komik yanı, typeof'un burada başarısız olduğu yeni Sayı (5) bile geri dönüyor.

Yöntem boş ve tanımsız olarak başarısız olur. Bazen beklenen ve bazen de genel olarak farklı tarayıcılar geri döner. Ancak bu iki değerin türünü onsuz belirlemek kolaydır.

Eğlence, nesnelere (typeof === "object" olanlar) ulaştığımızda başlar.

yerleşik nesneler, pratik olarak bir patlama ile çalışır:

• {} —
• —
• Tarih -
• Hata -
• Normalİfade -

Argümanlar listesinden düşen tek şey o zaman.
Ana bilgisayar nesneleri ile işler tekrar kötüleşiyor.

IE'de, DOM nesneleri yalnızca 8. sürümden itibaren "normal" nesneler olmaya başladı ve ardından tam olarak sona ermedi. Bu nedenle, IE 6-8'de, tüm bu nesneler (HTMLCOllection, DOMElement, TextNode ve belge ve pencere ile birlikte) basitçe dönüştürülür.

Diğer tüm tarayıcılarda (IE9 dahil), toString'in sonucuyla zaten bir şeyler yapabilirsiniz. Her şey kolay olmasa da: HTMLCollection o zaman orada. pencere - sonra, sonra. Ama zaten bundan bir şeyler çıkarmaya çalışabilirsiniz.

DOMElement ile daha zordur: her etiket için - kendi formatı olarak görüntülenir. Ama burada normal sezon bize yardımcı olacak.

Hikaye, diğer ana bilgisayar nesneleri ile hemen hemen aynıdır (konum ve gezgin testlerinde). IE dışında her yerde dize ile tanımlanabilirler.

Object.prototype.toString() kullanmanın eksilerinden:

1. Bu fırsat, standart tarafından kutsallaştırılmamıştır. Ve burada her şeyin çok iyi çalıştığına sevinmeliyiz ve bazı kusurlar için üzülmemeliyiz.

2. Türü belirlemeye hiç yaramayan ve ait olmadığı bir nesne üzerinde de çağrılan bir yöntemin döndürdüğü dizgiyi ayrıştırarak tür belirlemek, ruhta bir miktar kalıntı bırakır.

3. Eski IE'de, gördüğünüz gibi, ana bilgisayar nesneleri normalde tanımlanmaz.

Ancak diğer aletlerle birlikte kullanıldığında oldukça iş gören bir parçadır.

yapıcılar

Ve son olarak, inşaatçılar. Yapıcı değilse, JS'deki bir nesnenin "sınıfı" hakkında kim daha iyi söylenebilir?

Null ve undefined, ne sarmalayıcı nesnelere ne de oluşturuculara sahip değildir.

Skaler türlerin geri kalanı sırasıyla sarmalayıcılara sahiptir, bir kurucu alabilirsiniz:

(5) .constructor === Sayı; (Sayı .NaN) .constructor === Sayı; (doğru) .constructor === Boole; ("dize") .constructor === Dize;

(5) .constructor === Sayı; (Sayı.NaN) .constructor === Sayı; (doğru) .constructor === Boole; ("dize") yapıcı === Dize;

Ancak instanceof burada çalışmayacak:

Sayının 5 örneği; // false Number .NaN instanceof Number; // Boolean'ın yanlış gerçek örneği; // false "string" instanceof String; // YANLIŞ

Sayının 5 örneği; // false Number.NaN instanceof Number; // Boolean'ın yanlış gerçek örneği; // false "string" instanceof String; // YANLIŞ

(instanceof, uzun süredir acı çeken yeni Sayı (5) için çalışacak)

İşlevlerle (bunlar da nesnelerdir), instanceof geçer:

konsol.log ((işlev () ()) işlevin örneği); // true console.log ((işlev () ()) .constructor === İşlev); // NS

konsol.log ((işlev () ()) işlevin örneği); // true console.log ((işlev () ()) yapıcı === İşlev); // NS

Yerleşik sınıfların tüm nesneleri de yapıcıları tarafından kolayca tanımlanır: Array, Date, RegExp, Error.

Burada, yapıcısı Object olan argümanlarla ilgili bir sorun ortaya çıkar.

İkincisi, Nesnenin kendisiyle veya daha doğrusu, özel bir kurucu aracılığıyla oluşturulan bir nesneye nasıl atıfta bulunulacağı.

Yalnızca temel nesne şu şekilde tanımlanabilir:

obj nesne örneği;

Tanımın varyantlarından biri olarak - diğer tüm olası türleri (Dizi, Hata ...) yinelemek ve bunların hiçbiri eşleşmezse - "nesne".

Yapıcılar ve ana bilgisayar nesneleri

Ana bilgisayar nesneleri ile işler daha da kötüye gidiyor.

Sürüm 7'ye kadar olan IE'nin bunları normal nesneler olarak görmediği gerçeğiyle başlayalım. Sadece orada kurucuları ve prototipleri yoktur (her durumda programcı onlara ulaşamaz).

Diğer tarayıcılar daha iyisini yapar. Yapıcılar var ve bunları değer sınıfını belirlemek için kullanabilirsiniz. Yalnızca farklı tarayıcılarda farklı şekilde adlandırılırlar. Örneğin, HTMLCollection için yapıcı, HTMLCollection veya NodeList veya hatta NodeListConstructor olacaktır.

Ayrıca DOMElement için bir temel kurucu tanımlamanız gerekir. FF'de bu, örneğin HTMLDivElement ve diğerlerinin zaten devralındığı HTMLElement öğesidir.

10. sürümün altında FireFox ve 11'in altında Opera. Koleksiyon yapıcısı orada - Object.

yapıcı.name

Yapıcılar ayrıca yararlı olabilecek bir name özelliğine sahiptir.

Yapıcı işlevinin adını içerir, örneğin (5) .constructor.name === "Sayı".

Fakat:
1. IE'de 9'da bile değil.
2. Tarayıcılar her şeyi yeniden Ana Bilgisayar nesnelerine dönüştürür (ve çoğu zaman bu özelliğe sahip değildirler). Opera'da DOMElement, Function.prototype'da genel olarak bir kurucu adına sahiptir.
3. argümanlar yine "nesne"dir.

sonuçlar

Sunulan yöntemlerin hiçbiri, tüm tarayıcılarda değerin türü / sınıfının yüzde yüz tanımını sağlamaz. Ancak, birlikte bunu yapmanıza izin veriyorlar.

Yakın gelecekte tüm verileri tablolarda toplamaya çalışacağım ve bir tanımlayıcı fonksiyon örneği vereceğim.

Şebeke bir çeşit işlenenin türünü gösteren bir dize döndürür.

Sözdizimi

Operand typeof operatörünü takip eder:

Bir çeşit işlenen

Seçenekler

işlenen türü döndürülecek bir nesneyi veya ilkel öğeyi temsil eden bir ifadedir.

Açıklama

Aşağıdaki tablo typeof'un olası dönüş değerlerini listeler. Türler ve ilkeller hakkında daha fazla bilgi sayfada.

Örnekleri

// Sayılar typeof 37 === "sayı"; typeof 3.14 === "sayı"; typeof (42) === "sayı"; typeof Math.LN2 === "sayı"; typeof Infinity === "sayı"; typeof NaN === "sayı"; // "Sayı Değil" typeof Sayı olmasına rağmen (1) === "sayı"; // bu girişi asla kullanmayın! // Dizeler typeof "" === "string"; typeof "bla" === "dize"; typeof "1" === "dize"; // dize içindeki sayının hala string typeof (typeof 1) türünde olduğuna dikkat edin === "string"; // typeof bu durumda her zaman bir string döndürür typeof String ("abc") === "string"; // bu girişi asla kullanmayın! // Boolean typeof true === "boolean"; typeof false === "boolean"; typeof Boolean (true) === "boolean"; // bu girişi asla kullanmayın! // Semboller Sembol tipi () === "sembol" Sembol tipi ("foo") === "sembol" Sembol tipi.iterator === "sembol" // Tanımsız tip tanımsız === "tanımsız"; typeof bildirilenButUndefinedVariable === "tanımsız"; typeof undeclaredVariable === "tanımsız"; // Nesneler typeof (a: 1) === "nesne"; // normal nesneler ve diziler arasında ayrım yapmak için Array.isArray veya Object.prototype.toString.call kullanın // typeof === "object"; typeof new Date () === "nesne"; // Aşağıdakiler hatalara ve sorunlara yol açar. Kullanmayın! typeof new Boolean (true) === "nesne"; typeof new Number (1) === "nesne"; typeof new String ("abc") === "nesne"; // Fonksiyonlar typeof function () () === "fonksiyon"; typeof sınıf C () === "fonksiyon"; typeof Math.sin === "fonksiyon";

boş

// Bu doğumdan beri tanımlanmıştır JavaScript typeof null === "object";

İlk JavaScript uygulamasında değerler, bir etiket türü ve değer çifti ile temsil edildi. Nesneler için etiket türü 0'dı. null, bir boş gösterici olarak temsil edildi (çoğu platformda 0x00). Bu nedenle null için etiket türü sıfırdı, bu nedenle typeof'un dönüş değeri sahte. ()

ECMAScript'te (devre dışı bırakma yoluyla) bir düzeltme önerildi, ancak reddedildi. Bu, typeof null === "null" ile sonuçlanır.

Yeni operatörü kullanma

// "new" ile oluşturulan tüm yapıcı fonksiyonlar "object" türünde olacaktır var str = new String ("String"); var num = yeni Sayı (100); typeof str; // "nesne" tipini döndürür sayı; // "nesne" döndürür // Ancak Function yapıcısı için bir istisna vardır var func = new Function (); işlev türü; // "fonksiyon" döndürür

Düzenli ifadeler

Çağrılabilir normal ifadeler, bazı tarayıcılarda standart olmayan bir eklentiydi.

Typeof / s / === "fonksiyon"; // Chrome 1-12 ECMAScript 5.1 uyumlu değil typeof / s / === "object"; // Firefox 5+ ECMAScript 5.1 Uyumlu

Geçici ölü bölgelerle ilgili hatalar

ECMAScript 2015'ten önce, typeof operatörünün çağrıldığı işlenen için bir dize döndürmesi garantiliydi. Bu, blok kapsamındaki kaldırma dışı let ve const bildirimlerinin eklenmesiyle değişti. Şimdi, değişkenler let ve const ile bildirilirse ve değişken bildirim bloğunda üzerlerinde typeof çağrılırsa, ancak bildirimden önce bir ReferenceError atılır. Davranış, typeof'un "tanımsız" döndüreceği bildirilmemiş değişkenlerden farklıdır. Blok kapsamlı değişkenler, bloğun başlangıcından değişken bildirilinceye kadar süren bir "geçici ölü bölge" içindedir. Bu bölgede, değişkenlere erişme girişimi bir istisna atar.

Typeof undeclaredVariable === "tanımsız"; typeof newLetVariable; izin ver newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "merhaba"; // ReferansHatası

istisnalar

Mevcut tüm tarayıcılar, Undefined türünde standart olmayan bir document.all ana bilgisayar nesnesine sahiptir.

typeof document.all === "tanımsız";

Belirtim, standart olmayan egzotik nesneler için özel tür adlarına izin verse de, bu adların önceden tanımlanmış olanlardan farklı olması gerekir. Document.all'ın tanımsız olduğu bir durum, istisnai bir kural ihlali olarak kabul edilmelidir.

Özellikler (düzenle)

Şartname	Durum	Yorumlar (1)
ECMAScript Son Taslak (ECMA-262)	Taslak
ECMAScript 2015 (6. Baskı, ECMA-262) Bu spesifikasyondaki "Operatör tipi" tanımı.	Standart
ECMAScript 5.1 (ECMA-262) Bu spesifikasyondaki "Operatör tipi" tanımı.	Standart
ECMAScript 3. Baskı (ECMA-262) Bu spesifikasyondaki "Operatör tipi" tanımı.	Standart
ECMAScript 1. Baskı (ECMA-262) Bu spesifikasyondaki "Operatör tipi" tanımı.	Standart	Orijinal tanım. JavaScript 1.1'de uygulandı

Tarayıcı Uyumluluğu

GitHub'da uyumluluk verilerini güncelleyin

	bilgisayarlar						Mobil						sunucu
	Krom	Köşe	Firefox	Internet Explorer	Opera	Safari	Android web görünümü	Android için Chrome	Android için Firefox	Android için Opera	iOS'ta Safari	Samsung İnternet	Node.js
bir çeşit	Krom Tam destek 1	Köşe Tam destek 12	Firefox Tam destek 1	IE Tam destek 3	Opera Tam destek Evet	Safari Tam destek Evet	Web Görünümü Android Tam destek 1	Chrome Android Tam destek 18	Firefox Android Tam destek 4	Opera Android Tam destek Evet	Safari iOS Tam destek Evet	Samsung İnternet Android Tam destek 1.0	düğümler Tam destek Evet

Efsane

Tam destek Tam destek

IE'ye özel notlar

IE 6, 7 ve 8'de birçok ana bilgisayar nesnesi nesnedir, ancak işlev değildir. Örneğin.