Apakah mungkin untuk mendapatkan nama kelas / jenis objek saat runtime menggunakan TypeScript?

class MyClass{}

var instance = new MyClass();
console.log(instance.????); // Should output "MyClass"

Jawaban sederhana:

class MyClass {}

const instance = new MyClass();

console.log(instance.constructor.name); // MyClass
console.log(MyClass.name);              // MyClass

Namun: berhati-hatilah bahwa nama itu kemungkinan akan berbeda ketika menggunakan kode yang diperkecil.

Aku tahu aku terlambat ke pesta, tapi ternyata ini juga berhasil.

var constructorString: string = this.constructor.toString();
var className: string = constructorString.match(/\w+/g)[1]; 

Kalau tidak...

var className: string = this.constructor.toString().match(/\w+/g)[1];

Kode di atas mendapatkan seluruh kode konstruktor sebagai string dan menerapkan regex untuk mendapatkan semua 'kata'. Kata pertama harus 'berfungsi' dan kata kedua harus menjadi nama kelas.

Semoga ini membantu.

Solusi saya adalah tidak bergantung pada nama kelas. object.constructor.name bekerja secara teori. Tetapi jika Anda menggunakan TypeScript dalam sesuatu seperti Ionic, segera setelah Anda pergi ke produksi itu akan terbakar karena mode produksi Ionic mengecilkan kode Javascript. Jadi kelas diberi nama hal-hal seperti "a" dan "e."

Apa yang saya akhirnya lakukan adalah memiliki kelas typeName di semua objek saya bahwa konstruktor menetapkan nama kelas. Begitu:

export class Person {
id: number;
name: string;
typeName: string;

constructor() {
typeName = "Person";
}

Ya, bukan itu yang ditanyakan, sungguh. Tetapi menggunakan constructor.name pada sesuatu yang mungkin berpotensi diperkecil di jalan hanya memohon sakit kepala.

Lihat pertanyaan ini .

Karena TypeScript dikompilasi ke JavaScript, saat runtime Anda menjalankan JavaScript, jadi aturan yang sama akan berlaku.

Anda harus terlebih dahulu melemparkan contoh ke anykarena Functiondefinisi tipe tidak memiliki nameproperti.

class MyClass {
  getName() {
    return (<any>this).constructor.name;
    // OR return (this as any).constructor.name;
  }
}

// From outside the class:
var className = (<any>new MyClass()).constructor.name;
// OR var className = (new MyClass() as any).constructor.name;
console.log(className); // Should output "MyClass"

// From inside the class:
var instance = new MyClass();
console.log(instance.getName()); // Should output "MyClass"

Memperbarui:

Dengan TypeScript 2.4 (dan berpotensi lebih awal) kode dapat lebih bersih:

class MyClass {
  getName() {
    return this.constructor.name;
  }
}

// From outside the class:
var className = (new MyClass).constructor.name;
console.log(className); // Should output "MyClass"

// From inside the class:
var instance = new MyClass();
console.log(instance.getName()); // Should output "MyClass"

Di Angular2 ini dapat membantu untuk mendapatkan nama komponen:

    getName() {
        let comp:any = this.constructor;
        return comp.name;
    }

comp: any diperlukan karena kompilasi TypeScript akan mengeluarkan kesalahan karena Fungsi pada awalnya tidak memiliki nama properti.

Kode TypeScript lengkap

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

• Harus menambahkan " prototipe. " Penggunaan: myClass.prototype.constructor.name.
• Kalau tidak, dengan kode berikut: myClass.constructor.nameSaya mengalami kesalahan TypeScript:

error TS2339: Property 'name' does not exist on type 'Function'.

Solusi ini berfungsi setelah uglifikasi minifikasi tetapi membutuhkan dekorasi kelas dengan metadata.

Kami menggunakan pembuatan kode untuk menghias kelas Entitas kami dengan metadata seperti:

@name('Customer')
export class Customer {
  public custId: string;
  public name: string;
}

Kemudian konsumsilah dengan pembantu berikut:

export const nameKey = Symbol('name');

/**
 * To perserve class name though mangling.
 * @example
 * @name('Customer')
 * class Customer {}
 * @param className
 */
export function name(className: string): ClassDecorator {
  return (Reflect as any).metadata(nameKey, className);
}

/**
 * @example
 * const type = Customer;
 * getName(type); // 'Customer'
 * @param type
 */
export function getName(type: Function): string {
  return (Reflect as any).getMetadata(nameKey, type);
}

/**
 * @example
 * const instance = new Customer();
 * getInstanceName(instance); // 'Customer'
 * @param instance
 */
export function getInstanceName(instance: Object): string {
  return (Reflect as any).getMetadata(nameKey, instance.constructor);
}

Jika Anda sudah tahu tipe apa yang diharapkan (misalnya, ketika suatu metode mengembalikan tipe gabungan ), maka Anda bisa menggunakan tipe penjaga.

Misalnya, untuk tipe primitif Anda dapat menggunakan typeof guard :

if (typeof thing === "number") {
  // Do stuff
}

Untuk tipe kompleks Anda dapat menggunakan instanceof penjaga :

if (thing instanceof Array) {
  // Do stuff
}