Saya membuat objek JavaScript, tetapi bagaimana saya bisa menentukan kelas objek itu?

Saya ingin sesuatu yang mirip dengan .getClass()metode Java .

Tidak ada padanan pasti untuk Java getClass()di JavaScript. Sebagian besar itu karena JavaScript menjadi bahasa berbasis prototipe , sebagai lawan dari Jawa menjadi bahasa berbasis kelas .

Bergantung pada apa yang Anda butuhkan getClass(), ada beberapa opsi dalam JavaScript:

• typeof
• instanceof
• obj.constructor
• func.prototype, proto.isPrototypeOf

Beberapa contoh:

function Foo() {}
var foo = new Foo();

typeof Foo;             // == "function"
typeof foo;             // == "object"

foo instanceof Foo;     // == true
foo.constructor.name;   // == "Foo"
Foo.name                // == "Foo"    

Foo.prototype.isPrototypeOf(foo);   // == true

Foo.prototype.bar = function (x) {return x+x;};
foo.bar(21);            // == 42

Catatan: jika Anda mengkompilasi kode Anda dengan Uglify akan mengubah nama kelas non-global. Untuk mencegah hal ini, Uglify memiliki --mangleparam yang dapat Anda setel ke false menggunakan tegukan atau dengusan .

obj.constructor.name

adalah metode yang dapat diandalkan di peramban modern. Function.namesecara resmi ditambahkan ke standar dalam ES6, menjadikannya cara yang sesuai standar untuk mendapatkan "kelas" objek JavaScript sebagai string. Jika objek dipakai var obj = new MyClass(), itu akan mengembalikan "MyClass".

Ini akan mengembalikan "Nomor" untuk angka, "Array" untuk array dan "Fungsi" untuk fungsi, dll. Umumnya berperilaku seperti yang diharapkan. Satu-satunya kasus di mana ia gagal adalah jika suatu objek dibuat tanpa prototipe, melalui Object.create( null ), atau objek itu instantiated dari fungsi (tanpa nama) yang didefinisikan secara anonim.

Perhatikan juga bahwa jika Anda mengecilkan kode Anda, tidak aman untuk membandingkannya dengan string tipe hard-coded. Misalnya bukannya memeriksa jika obj.constructor.name == "MyType", bukannya memeriksa obj.constructor.name == MyType.name. Atau hanya membandingkan konstruktor sendiri, namun ini tidak akan bekerja melintasi batas DOM karena ada contoh berbeda dari fungsi konstruktor pada setiap DOM, sehingga melakukan perbandingan objek pada konstruktor mereka tidak akan berfungsi.

Fungsi ini mengembalikan "Undefined"nilai yang tidak ditentukan dan "Null"untuk null.
Untuk semua nilai lainnya, CLASSNAME-part diekstrak dari [object CLASSNAME], yang merupakan hasil dari menggunakan Object.prototype.toString.call(value).

function getClass(obj) {
  if (typeof obj === "undefined") return "Undefined";
  if (obj === null) return "Null";
  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
}

getClass("")   === "String";
getClass(true) === "Boolean";
getClass(0)    === "Number";
getClass([])   === "Array";
getClass({})   === "Object";
getClass(null) === "Null";
// etc...

Untuk mendapatkan "pseudo class", Anda bisa mendapatkan fungsi konstruktor, oleh

obj.constructor

dengan asumsi constructordiatur dengan benar ketika Anda melakukan warisan - yang oleh sesuatu seperti:

Dog.prototype = new Animal();
Dog.prototype.constructor = Dog;

dan dua baris ini, bersama dengan:

var woofie = new Dog()

akan woofie.constructormenunjukkan Dog. Catatan itu Dogadalah fungsi konstruktor, dan merupakan Functionobjek. Tapi kamu bisa melakukannya if (woofie.constructor === Dog) { ... }.

Jika Anda ingin mendapatkan nama kelas sebagai string, saya menemukan berikut ini berfungsi dengan baik:

http://blog.magnetiq.com/post/514962277/finding-out-class-names-of-javascript-objects

function getObjectClass(obj) {
    if (obj && obj.constructor && obj.constructor.toString) {
        var arr = obj.constructor.toString().match(
            /function\s*(\w+)/);

        if (arr && arr.length == 2) {
            return arr[1];
        }
    }

    return undefined;
}

Ia sampai ke fungsi konstruktor, mengubahnya menjadi string, dan mengekstrak nama fungsi konstruktor.

Catatan yang obj.constructor.namebisa bekerja dengan baik, tetapi itu bukan standar. Ada di Chrome dan Firefox, tetapi tidak di IE, termasuk IE 9 atau IE 10 RTM.

Anda bisa mendapatkan referensi ke fungsi konstruktor yang membuat objek dengan menggunakan properti konstruktor :

function MyObject(){
}

var obj = new MyObject();
obj.constructor; // MyObject

Jika Anda perlu mengonfirmasi jenis objek saat runtime Anda dapat menggunakan instanceof operator:

obj instanceof MyObject // true

Sesuai dengan catatan kompatibilitas ke belakang yang tidak terputus, ECMAScript 6, JavaScript masih tidak memiliki classtipe (walaupun tidak semua orang mengerti ini). Itu memang memiliki classkata kunci sebagai bagian dari classsintaks untuk membuat prototipe — tetapi masih tidak ada yang disebut kelas . JavaScript tidak sekarang dan tidak pernah menjadi bahasa OOP klasik . Berbicara tentang JS dalam hal kelas hanya menyesatkan atau pertanda belum mendapatkan warisan prototipikal (hanya membuatnya nyata).

Itu berarti this.constructormasih cara yang bagus untuk mendapatkan referensi ke constructorfungsi. Dan this.constructor.prototypeadalah cara untuk mengakses prototipe itu sendiri. Karena ini bukan Java, ini bukan kelas. Ini adalah objek prototipe tempat instantiasi Anda berasal. Berikut ini adalah contoh menggunakan gula sintaksis ES6 untuk membuat rantai prototipe:

class Foo {
  get foo () {
    console.info(this.constructor, this.constructor.name)
    return 'foo'
  }
}

class Bar extends Foo {
  get foo () {
    console.info('[THIS]', this.constructor, this.constructor.name, Object.getOwnPropertyNames(this.constructor.prototype))
    console.info('[SUPER]', super.constructor, super.constructor.name, Object.getOwnPropertyNames(super.constructor.prototype))

    return `${super.foo} + bar`
  }
}

const bar = new Bar()
console.dir(bar.foo)

Inilah yang dihasilkan oleh keluaran babel-node:

> $ babel-node ./foo.js                                                                                                                   ⬡ 6.2.0 [±master ●]
[THIS] [Function: Bar] 'Bar' [ 'constructor', 'foo' ]
[SUPER] [Function: Foo] 'Foo' [ 'constructor', 'foo' ]
[Function: Bar] 'Bar'
'foo + bar'

Itu dia! Pada 2016, ada classkata kunci dalam JavaScript, tetapi masih tidak ada tipe kelas. this.constructoradalah cara terbaik untuk mendapatkan fungsi konstruktor, this.constructor.prototypecara terbaik untuk mendapatkan akses ke prototipe itu sendiri.

Saya punya situasi untuk bekerja generik sekarang dan menggunakan ini:

class Test {
  // your class definition
}

nameByType = function(type){
  return type.prototype["constructor"]["name"];
};

console.log(nameByType(Test));

Itulah satu-satunya cara yang saya temukan untuk mendapatkan nama kelas berdasarkan jenis input jika Anda tidak memiliki turunan objek.

(ditulis dalam ES2017)

notasi titik juga berfungsi dengan baik

console.log(Test.prototype.constructor.name); // returns "Test" 

Untuk Javascript Classes di ES6 bisa Anda gunakan object.constructor. Pada kelas contoh di bawah ini getClass()metode mengembalikan kelas ES6 seperti yang Anda harapkan:

var Cat = class {

    meow() {

        console.log("meow!");

    }

    getClass() {

        return this.constructor;

    }

}

var fluffy = new Cat();

...

var AlsoCat = fluffy.getClass();
var ruffles = new AlsoCat();

ruffles.meow();    // "meow!"

Jika Anda instantiate kelas dari getClassmetode pastikan Anda membungkusnya dalam tanda kurung misalnyaruffles = new ( fluffy.getClass() )( args... );

Saya menemukan object.constructor.toString()kembali [object objectClass]di IE, daripada function objectClass () {}kembali di chome. Jadi, saya pikir kode di http://blog.magnetiq.com/post/514962277/finding-out-class-names-of-javascript-objects mungkin tidak berfungsi dengan baik di IE. Dan saya memperbaiki kodenya sebagai berikut:

kode:

var getObjectClass = function (obj) {
        if (obj && obj.constructor && obj.constructor.toString()) {

                /*
                 *  for browsers which have name property in the constructor
                 *  of the object,such as chrome 
                 */
                if(obj.constructor.name) {
                    return obj.constructor.name;
                }
                var str = obj.constructor.toString();
                /*
                 * executed if the return of object.constructor.toString() is 
                 * "[object objectClass]"
                 */

                if(str.charAt(0) == '[')
                {
                        var arr = str.match(/\[\w+\s*(\w+)\]/);
                } else {
                        /*
                         * executed if the return of object.constructor.toString() is 
                         * "function objectClass () {}"
                         * for IE Firefox
                         */
                        var arr = str.match(/function\s*(\w+)/);
                }
                if (arr && arr.length == 2) {
                            return arr[1];
                        }
          }
          return undefined; 
    };

Dalam javascript, tidak ada kelas, tapi saya pikir Anda menginginkan nama konstruktor dan obj.constructor.toString()akan memberi tahu Anda apa yang Anda butuhkan.

Setuju dengan dfa, itu sebabnya saya menganggap prototye sebagai kelas ketika tidak ada kelas bernama yang ditemukan

Ini adalah fungsi yang ditingkatkan dari yang diposting oleh Eli Gray, agar sesuai dengan cara pikiranku

function what(obj){
    if(typeof(obj)==="undefined")return "undefined";
    if(obj===null)return "Null";
    var res = Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
    if(res==="Object"){
        res = obj.constructor.name;
        if(typeof(res)!='string' || res.length==0){
            if(obj instanceof jQuery)return "jQuery";// jQuery build stranges Objects
            if(obj instanceof Array)return "Array";// Array prototype is very sneaky
            return "Object";
        }
    }
    return res;
}

Jika Anda tidak hanya perlu MENDAPATKAN kelas tetapi juga MEMPERPANJANG dari hanya memiliki sebuah instance, tulis:

mari kita miliki

 class A{ 
   constructor(name){ 
     this.name = name
   }
 };

 const a1 = new A('hello a1');

jadi untuk memperpanjang A memiliki instance hanya gunakan:

const a2 = new ((Object.getPrototypeOf(a)).constructor())('hello a2')
// the analog of const a2 = new A()

console.log(a2.name)//'hello a2'

Saya sarankan menggunakan Object.prototype.constructor.name:

Object.defineProperty(Object.prototype, "getClass", {
    value: function() {
      return this.constructor.name;
    }
});

var x = new DOMParser();
console.log(x.getClass()); // `DOMParser'

var y = new Error("");
console.log(y.getClass()); // `Error'

Berikut ini adalah implementasi dari getClass()dangetInstance()

Anda bisa mendapatkan referensi untuk menggunakan kelas Object this.constructor.

Dari konteks contoh:

function A() {
  this.getClass = function() {
    return this.constructor;
  }

  this.getNewInstance = function() {
    return new this.constructor;
  }
}

var a = new A();
console.log(a.getClass());  //  function A { // etc... }

// you can even:
var b = new (a.getClass());
console.log(b instanceof A); // true
var c = a.getNewInstance();
console.log(c instanceof A); // true

Dari konteks statis:

function A() {};

A.getClass = function() {
  return this;
}

A.getInstance() {
  return new this;
}

Anda juga dapat melakukan hal seperti ini

 class Hello {
     constructor(){
     }
    }
    
      function isClass (func) {
        return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func))
    }
    
   console.log(isClass(Hello))

Ini akan memberi tahu Anda apakah inputnya kelas atau tidak

Javascript adalah bahasa tanpa kelas: tidak ada kelas yang mendefinisikan perilaku kelas secara statis seperti di Jawa. JavaScript menggunakan prototipe sebagai ganti kelas untuk mendefinisikan properti objek, termasuk metode, dan pewarisan. Dimungkinkan untuk mensimulasikan banyak fitur berbasis kelas dengan prototipe dalam JavaScript.

Pertanyaan sepertinya sudah dijawab tetapi OP ingin mengakses kelas dan objek, seperti yang kita lakukan di Jawa dan jawaban yang dipilih tidak cukup (imho).

Dengan penjelasan berikut, kita bisa mendapatkan kelas objek (sebenarnya disebut prototipe dalam javascript).

var arr = new Array('red', 'green', 'blue');
var arr2 = new Array('white', 'black', 'orange');

Anda dapat menambahkan properti seperti ini:

Object.defineProperty(arr,'last', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue

Tetapi .lastproperti hanya akan tersedia untuk arrobjek yang dibuat dari prototipe Array. Jadi, agar .lastproperti tersedia untuk semua objek yang dibuat dari prototipe Array, kita harus mendefinisikan .lastproperti untuk prototipe Array:

Object.defineProperty(Array.prototype,'last', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue
console.log(arr2.last) // orange

Masalahnya di sini adalah, Anda harus tahu jenis objek (prototipe) mana variabel ' arr' dan ' arr2' milik! Dengan kata lain, jika Anda tidak tahu tipe kelas (prototipe) dari objek ' arr', maka Anda tidak akan dapat mendefinisikan properti untuk mereka. Dalam contoh di atas, kita tahu arr adalah turunan dari objek Array, itu sebabnya kami menggunakan Array.prototype untuk mendefinisikan properti untuk Array. Tetapi bagaimana jika kita tidak tahu kelas (prototipe) dari ' arr'?

Object.defineProperty(arr.__proto__,'last2', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue
console.log(arr2.last) // orange

Seperti yang Anda lihat, tanpa mengetahui bahwa ' arr' adalah Array, kita dapat menambahkan properti baru hanya dengan merujuk kelas ' arr' dengan menggunakan ' arr.__proto__'.

Kami mengakses prototipe ' arr' tanpa mengetahui bahwa itu adalah contoh dari Array dan saya pikir itulah yang ditanyakan OP.