class.getName() Java JavaScript bir karşılığı var mıdır?

class.getName() Java JavaScript bir karşılığı var mıdır?

Hayır.

Ama burada tüm aşağı bir şekilde düşen çeşitli kesmek

İşte o ne olacak hack - Nesnenin prototip değiştirir unutmayın, bir kişi (genellikle iyi bir neden için) üzerine kaşlarını

Object.prototype.getName = function() { 
   var funcNameRegex = /function (.{1,})\(/;
   var results = (funcNameRegex).exec((this).constructor.toString());
   return (results && results.length > 1) ? results[1] : "";
};

Şimdi tüm nesneleri bir dize olarak kurucu adını veren bir işlevi, getName(), olacaktır. FF3 bu test ettik ve 7 İÇİN, diğer uygulamalar için bir şey diyemem.

Eğer bunu yapmak istemiyorsan eğer, burada JavaScript türleri belirlemenin çeşitli yolları üzerinde bir tartışma

Geçenlerde bu biraz zor olsa da biraz daha ayrıntılı olması için güncellendi. Düzeltmeler Hoşgeldiniz

constructor özelliğini kullanarak...

Her nesne constructor özelliği için bir değeri vardır, ama bu nesne de bu değer ile ne yapmak istiyorsun olarak nasıl inşa edildiği bağlı olarak, olabilir veya yararlı olmayabilir.

Genel olarak konuşursak, constructor özelliği gibi nesne türünü sınamak için kullanabilirsiniz:

var myArray = [1,2,3];
(myArray.constructor == Array); // true

Yani, en ihtiyaçları için yeterince iyi çalışıyor. Dedi ki .

Uyarılar

Olacak iş değilHİÇbirçok durumda

Bu desen kırık olsa da, oldukça yaygındır:

function Thingy() {
}
Thingy.prototype = {
    method1: function() {
    },
    method2: function() {
    }
};

Nesneleri new Thingy ile inşa Object, Thingy işaret constructor bir özelliği var. Hemen başlangıçta düşeriz yani; sadece güven *29 kontrol edemediğiniz bir kod temeli olamaz.

Çoklu Kalıtım

O kadar açık değil bir örnek, birden çok devralma kullanıyor:

function a() { this.foo = 1;}
function b() { this.bar = 2; }
b.prototype = new a(); // b inherits from a

Şimdi işler beklediğiniz gibi çalışmıyor:

var f = new b(); // instantiate a new object with the b constructor
(f.constructor == b); // false
(f.constructor == a); // true

Yani, eğer test farklı bir nesne var nesne prototipi olarak ayarlanırsa, beklenmeyen sonuçlar alabilirsiniz. Bu tartışmanın kapsamı dışında bu etrafında yolu vardır.

constructor özelliği, bazıları ilginç, bazıları da çok başka kullanım alanları da var; şu an için bu konuyla ilgili olmadığı için bunları kullanır içine girmeyeceğiz.

Çapraz çerçeve ve pencere geçmeyecek

Yazım kontrolü için .constructor kullanarak nesneleri window farklı nesnelerden gelen yazın ki bir iframe veya popup pencere bunu kontrol etmek istediğinizde kıracak. Bu her çekirdek türü her yapıcı farklı bir versiyonu daha var, çünkü `penceresi, yani'

iframe.contentWindow.Array === Array // false

instanceof operatörü kullanarak...

instanceof operatör de nesne türü testler temiz bir yoldur, ama kendi potansiyel sorunları olduğunu, sadece constructor özelliği gibi.

var myArray = [1,2,3];
(myArray instanceof Array); // true
(myArray instanceof Object); // true

Ama instanceof ilkel değerler için çalışmak başarısız olur

3 instanceof Number // false
'abc' instanceof String // false
true instanceof Boolean // false

Sarıcı örneğin instanceof için ilkel bir çözüm için gereklidir

new Number(3) instanceof Number // true

Bu .constructor Çek ilkel insanlar için iyi çalışır çünkü ironik

3..constructor === Number // true
'abc'.constructor === String // true
true.constructor === Boolean // true

Neden 3 için iki nokta? Javascript ilk ondalık nokta olarak nokta;) yorumlar için

Çapraz çerçeve ve pencere geçmeyecek

instanceof da yapıcı özellik kontrol olarak aynı sebepten dolayı farklı windows üzerinde çalışmaz.

constructor özelliği name özelliğini kullanarak...

ÇalışmıyorHİÇbirçok durumda

Yine, bakın yukarıda; constructor tamamen olmak için oldukça yaygın ve tamamen yanlış ve gereksiz.

Çalışmıyor &; 9 lt

myObjectInstance.constructor.name kullanarak bir dize yapıcı işlevi, kullanılan adını içeren verecektir, ama daha önce bahsedilen yapıcı özelliği hakkında uyarılar tabidir.

Internet Explorer 9 ve üstü için, 59**:

if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
    Object.defineProperty(Function.prototype, 'name', {
        get: function() {
            var funcNameRegex = /function\s ([^\s(] )\s*\(/;
            var results = (funcNameRegex).exec((this).toString());
            return (results && results.length > 1) ? results[1] : "";
        },
        set: function(value) {}
    });
}

Sürüm güncellendisöz konusu madde. Bu 3 ay yazı yayınlandıktan sonra eklendi, Bu makalenin yazarı Matthew Scharley tarafından kullanılması tavsiye sürümüdür. Bu değişiklik, önceki kod comments pointing out potential pitfalls esinlenilmiştir.

if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
    Object.defineProperty(Function.prototype, 'name', {
        get: function() {
            var funcNameRegex = /function\s([^(]{1,})\(/;
            var results = (funcNameRegex).exec((this).toString());
            return (results && results.length > 1) ? results[1].trim() : "";
        },
        set: function(value) {}
    });
}

Kullanarak Nesne.prototip.sağlar

this post details Nesne kullanabilirsiniz olarak ortaya çıktı.prototip.sağlar - düşük seviye ve genel uygulama sağlar - tüm yerleşik türleri için tür almak için

Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]

Kısa bir yardımcısı gibi bir işlev yazabilirsiniz

function type(obj){
    return Object.prototype.toString.call(obj).slice(8, -1);
}

bu işe yaramayan öğeleri kaldırmak ve sadece tür adı almak için

type('abc') // String

Ancak, 'Nesne' tüm tanımlı kullanıcı tipleri için. döndürür

Uyarılar için

Bunların hepsi potansiyel bir sorun tabidir ve söz konusu nesnenin nasıl inşa edildiği sorusu. Burada bina nesnelerin çeşitli şekillerde yazım kontrolü için farklı yöntemler dönecektir değerleri:

// using a named function:
function Foo() { this.a = 1; }
var obj = new Foo();
(obj instanceof Object);          // true
(obj instanceof Foo);             // true
(obj.constructor == Foo);         // true
(obj.constructor.name == "Foo");  // true

// let's add some prototypical inheritance
function Bar() { this.b = 2; }
Foo.prototype = new Bar();
obj = new Foo();
(obj instanceof Object);          // true
(obj instanceof Foo);             // true
(obj.constructor == Foo);         // false
(obj.constructor.name == "Foo");  // false


// using an anonymous function:
obj = new (function() { this.a = 1; })();
(obj instanceof Object);              // true
(obj.constructor == obj.constructor); // true
(obj.constructor.name == "");         // true


// using an anonymous function assigned to a variable
var Foo = function() { this.a = 1; };
obj = new Foo();
(obj instanceof Object);      // true
(obj instanceof Foo);         // true
(obj.constructor == Foo);     // true
(obj.constructor.name == ""); // true


// using object literal syntax
obj = { foo : 1 };
(obj instanceof Object);            // true
(obj.constructor == Object);        // true
(obj.constructor.name == "Object"); // true

Tüm permütasyon örnekler bu set varken, umarım pis bir şey ihtiyaçlarınıza göre nasıl girileceği hakkında bir fikir sunmak için yeterince vardır. Hiçbir şey düşünmeyin, sonra seni tam olarak anlamıyorsun bile, inceliklerini grokking eksikliği nedeniyle beklemediğin bir kod kırma ile sona erebilir.

NOT:

typeof operatörün tartışma bir eksiklik gibi görünebilir, ama gerçekten çok basit bir o yana, bir nesnenin belirli bir tür olup olmadığını belirlemek için yardımcı değil. typeof yararlı olduğu anlamak önemlidir, ama şu anda bu konuyla çok ilgili olduğunu düşünmüyorum. Aklım olsa değişime açık. :)