Tôi đã tạo một đối tượng JavaScript, nhưng làm thế nào tôi có thể xác định lớp của đối tượng đó?

Tôi muốn một cái gì đó tương tự như .getClass()phương thức của Java .

Không có đối tác chính xác với Java getClass()trong JavaScript. Chủ yếu là do JavaScript là ngôn ngữ dựa trên nguyên mẫu , trái ngược với Java là ngôn ngữ dựa trên lớp .

Tùy thuộc vào những gì bạn cần getClass(), có một số tùy chọn trong JavaScript:

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

Một vài ví dụ:

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

Lưu ý: nếu bạn đang biên dịch mã của mình với Uglify, nó sẽ thay đổi tên lớp không toàn cầu. Để ngăn chặn điều này, Uglify có một thông số --manglemà bạn có thể đặt thành false là sử dụng gulp hoặc grunt .

obj.constructor.name

là một phương pháp đáng tin cậy trong các trình duyệt hiện đại. Function.nameđã chính thức được thêm vào tiêu chuẩn trong ES6, làm cho điều này trở thành một phương tiện tuân thủ tiêu chuẩn để lấy "lớp" của một đối tượng JavaScript dưới dạng một chuỗi. Nếu đối tượng được khởi tạo cùng var obj = new MyClass(), nó sẽ trả về "MyClass".

Nó sẽ trả về "Số" cho các số, "Mảng" cho các mảng và "Hàm" cho các hàm, v.v ... Nó thường hoạt động như mong đợi. Các trường hợp duy nhất thất bại là nếu một đối tượng được tạo mà không có nguyên mẫu, thông qua Object.create( null )hoặc đối tượng được khởi tạo từ một hàm được định nghĩa ẩn danh (không tên).

Cũng lưu ý rằng nếu bạn đang thu nhỏ mã của mình, sẽ không an toàn khi so sánh với các chuỗi loại được mã hóa cứng. Ví dụ thay vì kiểm tra nếu obj.constructor.name == "MyType", thay vì kiểm tra obj.constructor.name == MyType.name. Hoặc chỉ so sánh chính các hàm tạo, tuy nhiên, điều này sẽ không hoạt động trên các ranh giới DOM vì có các phiên bản khác nhau của hàm tạo trên mỗi DOM, do đó thực hiện so sánh đối tượng trên các hàm tạo của chúng sẽ không hoạt động.

Hàm này trả về "Undefined"các giá trị không xác định và "Null"cho null.
Đối với tất cả các giá trị khác, CLASSNAME-part được trích xuất từ [object CLASSNAME], đó là kết quả của việc sử dụng 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...

Để có được "lớp giả", bạn có thể lấy hàm tạo

obj.constructor

giả sử constructorđược đặt chính xác khi bạn thực hiện kế thừa - nghĩa là:

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

và hai dòng này, cùng với:

var woofie = new Dog()

sẽ làm cho woofie.constructorđiểm Dog. Lưu ý rằng đó Doglà một hàm tạo, và là một Functionđối tượng. Nhưng bạn có thể làm được if (woofie.constructor === Dog) { ... }.

Nếu bạn muốn lấy tên lớp dưới dạng chuỗi, tôi thấy các mục sau hoạt động tốt:

http://blog.magnetiq.com/post/514962277/finding-out- class-name-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;
}

Nó nhận được hàm xây dựng, chuyển đổi nó thành chuỗi và trích xuất tên của hàm xây dựng.

Lưu ý rằng obj.constructor.namecó thể đã hoạt động tốt, nhưng nó không phải là tiêu chuẩn. Nó có trên Chrome và Firefox, nhưng không có trên IE, bao gồm IE 9 hoặc IE 10 RTM.

Bạn có thể lấy tham chiếu đến hàm constructor đã tạo đối tượng bằng cách sử dụng thuộc tính constructor :

function MyObject(){
}

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

Nếu bạn cần xác nhận loại đối tượng trong thời gian chạy, bạn có thể sử dụng toán tử instanceof :

obj instanceof MyObject // true

Để giữ bản ghi không bị gián đoạn về khả năng tương thích ngược, ECMAScript 6, JavaScript vẫn không có classloại (mặc dù không phải ai cũng hiểu điều này). Nó không có một classtừ khóa như là một phần của nó classcú pháp để tạo nguyên mẫu-nhưng vẫn có những điều được gọi là lớp . JavaScript không phải bây giờ và chưa bao giờ là ngôn ngữ OOP cổ điển . Nói về JS về mặt lớp học chỉ là sai lệch hoặc là một dấu hiệu của việc thừa kế nguyên mẫu chưa được tìm kiếm (chỉ giữ cho nó thực sự).

Điều đó có nghĩa this.constructorvẫn là một cách tuyệt vời để có được một tham chiếu đến constructorhàm. Và this.constructor.prototypelà cách để truy cập vào nguyên mẫu. Vì đây không phải là Java, nên nó không phải là một lớp. Đó là đối tượng nguyên mẫu mà cá thể của bạn được khởi tạo từ. Dưới đây là một ví dụ sử dụng đường cú pháp ES6 để tạo chuỗi nguyên mẫu:

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)

Đây là những gì đầu ra sử dụng 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'

Có bạn có nó! Trong năm 2016, có một classtừ khóa trong JavaScript, nhưng vẫn không có loại lớp. this.constructorlà cách tốt nhất để có được hàm xây dựng, this.constructor.prototypecách tốt nhất để có quyền truy cập vào chính nguyên mẫu.

tôi đã có một tình huống để làm việc chung bây giờ và sử dụng điều này:

class Test {
  // your class definition
}

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

console.log(nameByType(Test));

đó là cách duy nhất tôi tìm thấy để lấy tên lớp theo kiểu nhập nếu bạn không có thể hiện của một đối tượng.

(viết bằng ES2017)

ký hiệu chấm cũng hoạt động tốt

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

Đối với các lớp Javascript trong ES6, bạn có thể sử dụng object.constructor. Trong lớp ví dụ bên dưới, getClass()phương thức trả về lớp ES6 như bạn mong đợi:

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!"

Nếu bạn khởi tạo lớp từ getClassphương thức, hãy đảm bảo bạn bọc nó trong ngoặc, vdruffles = new ( fluffy.getClass() )( args... );

Tôi tìm thấy sự object.constructor.toString()trở lại [object objectClass]trong IE, thay vì function objectClass () {}trở lại trong chome. Vì vậy, tôi nghĩ rằng mã trong http://blog.magnetiq.com/post/514962277/finding-out-group-names-of-javascript-objects có thể không hoạt động tốt trong IE. Và tôi đã sửa mã như sau:

mã:

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; 
    };

Trong javascript, không có lớp, nhưng tôi nghĩ rằng bạn muốn tên của hàm tạo và obj.constructor.toString()sẽ cho bạn biết những gì bạn cần.

Đồng ý với dfa, đó là lý do tại sao tôi coi prototye là lớp khi không tìm thấy lớp có tên

Đây là một chức năng được nâng cấp của cái được đăng bởi Eli Gray, để phù hợp với suy nghĩ của tôi

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;
}

Nếu bạn không chỉ NHẬN lớp mà còn TUYỆT ĐỐI không chỉ có một thể hiện, hãy viết:

hãy có

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

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

vì vậy để mở rộng A có thể hiện chỉ sử dụng:

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

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

Tôi đề nghị sử dụng 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'

Đây là một thực hiện getClass()vàgetInstance()

Bạn có thể nhận được một tài liệu tham khảo cho lớp Object this.constructor.

Từ một bối cảnh ví dụ:

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

Từ bối cảnh tĩnh:

function A() {};

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

A.getInstance() {
  return new this;
}

Bạn cũng có thể làm một cái gì đó như thế này

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

Điều này sẽ cho bạn biết nếu đầu vào là lớp hay không

Javascript là ngôn ngữ không có lớp: không có lớp nào định nghĩa hành vi của lớp một cách tĩnh như trong Java. JavaScript sử dụng các nguyên mẫu thay vì các lớp để xác định các thuộc tính đối tượng, bao gồm các phương thức và kế thừa. Có thể mô phỏng nhiều tính năng dựa trên lớp với các nguyên mẫu trong JavaScript.

Câu hỏi dường như đã được trả lời nhưng OP muốn truy cập vào lớp và đối tượng, giống như chúng ta làm trong Java và câu trả lời được chọn là không đủ (imho).

Với lời giải thích sau đây, chúng ta có thể có được một lớp của một đối tượng (nó thực sự được gọi là nguyên mẫu trong javascript).

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

Bạn có thể thêm một tài sản như thế này:

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

Nhưng thuộc .lasttính sẽ chỉ khả dụng cho arrđối tượng '' được khởi tạo từ nguyên mẫu Array. Vì vậy, để có .lastsẵn thuộc tính cho tất cả các đối tượng được khởi tạo từ nguyên mẫu Array, chúng ta phải xác định thuộc .lasttính cho nguyên mẫu Array:

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

Vấn đề ở đây là, bạn phải biết loại đối tượng (nguyên mẫu) mà các biến ' arr' và ' arr2' thuộc về! Nói cách khác, nếu bạn không biết loại lớp (nguyên mẫu) của arrđối tượng '', thì bạn sẽ không thể xác định một thuộc tính cho chúng. Trong ví dụ trên, chúng ta biết mảng là đối tượng của đối tượng Array, đó là lý do tại sao chúng ta sử dụng Array.prototype để định nghĩa một thuộc tính cho Array. Nhưng nếu chúng ta không biết lớp (nguyên mẫu) của ' arr' thì sao?

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

Như bạn có thể thấy, mà không biết rằng ' arr' là một Mảng, chúng ta có thể thêm một thuộc tính mới chỉ cần tham chiếu lớp của ' arr' bằng cách sử dụng ' arr.__proto__'.

Chúng tôi đã truy cập nguyên mẫu của ' arr' mà không biết rằng đó là phiên bản của Array và tôi nghĩ đó là những gì OP yêu cầu.