Wiem, że jestem spóźniona na imprezę, ale to też działa.

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

Alternatywnie...

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

Powyższy kod pobiera cały kod konstruktora jako ciąg znaków i stosuje regex, aby uzyskać wszystkie 'słowa'. Pierwszym słowem powinno być 'function', a drugim powinna być nazwa klasy.

Moim rozwiązaniem było nie polegać na nazwie klasy. object.constructor.name działa w teorii. Ale jeśli używasz maszynopisu w czymś takim jak Ionic, jak tylko przejdziesz do produkcji, to stanie w płomieniach, ponieważ tryb produkcyjny Ionic minimalizuje kod Javascript. Tak więc klasy otrzymują nazwy takie jak " a " i " e "

Skończyło się na tym, że miałem klasę typeName we wszystkich moich obiektach, którym konstruktor przypisuje nazwę klasy. Więc:

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

constructor() {
typeName = "Person";
}

Yes that wasn ' t what został poproszony, naprawdę. Ale za pomocą constructor.name na coś, co może potencjalnie dostać minified w dół drogi jest po prostu błaganie o ból głowy.

Zobacz to Pytanie .

Ponieważ TypeScript jest skompilowany do JavaScript, w czasie wykonywania jest uruchomiony JavaScript, więc te same zasady będą miały zastosowanie.

Najpierw musisz oddać instancję do any, ponieważ definicja typu Function nie ma właściwości name.

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"

Aktualizacja:

Z maszynopisem 2.4 (i potencjalnie wcześniejszym) kod może być jeszcze czystszy:

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"

W Angular2 może to pomóc w uzyskaniu nazwy komponentów:

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

Comp: Dowolna jest potrzebna, ponieważ kompilator TypeScript wyda błędy, ponieważ funkcja początkowo nie ma nazwy właściwości.

Rozwiązanie za pomocą dekoratorów , które przetrwają minifikację / uglifikację

Używamy generowania kodu, aby ozdobić nasze klasy encji metadanymi w następujący sposób:

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

Następnie skonsumuj z następującym pomocnikiem:

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

Dodatkowe informacje:

• Może być konieczne zainstalowanie reflect-metadata
• W przeciwieństwie do innych języków, które nie są używane przez inne języki, nie są używane przez inne języki.]}
• propozycja dla dekoratorów w JS może być śledzona tutaj

Pełny kod maszynopisu

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

• musiałem dodać ".prototyp." do użycia: myClass.prototype.constructor.name.
• W Przeciwnym Razie z następującym kodem : myClass.constructor.name, miałem błąd maszynopisu:

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

Jeśli już wiesz, jakich typów można się spodziewać (na przykład, gdy metoda zwraca typ union), możesz użyć strażników typu.

Na przykład dla typów prymitywnych można użyć typeof :

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

Dla typów złożonych można użyć instanceof :

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