Che cosa si intende per espressioni di classi con nome o senza nome in ES6?

Question

Nel codice sto usando una classe chiamata "Car". Ora se provo a usare come var carNew = new Car("ferrari");, allora mi sta dando un errore. Quindi, qual è l'uso dell'espressione di classe con nome in ES6?

'use strict'; 
var car = class Car{ 
    constructor(model){ 
     this.model = model; 
    } 
} 
var carNew = new car("ferrari"); 

console.log(carNew); //car {model: "ferrari"} 
console.log(carNew.constructor == car); //true 

Answer 1

In caso di espressioni classe è possibile utilizzare il nome della classe internamente, ma non al di fuori della classe:

const Foo = class Self { 
    static greetingPrefix() { 
    return 'Hello, '; 
    } 

    greeting() { 
    return Self.greetingPrefix() + 'World'; 
    } 
}; 

const foo = new Foo(); 
console.log(foo.greeting()); // "Hello, World" 


console.log(Self); // throws "Uncaught ReferenceError: Self is not defined" 

Answer 2

Con questo codice

var car = class Car{ /* ... */ } 

var carNew = new Car("ferrari"); throws an error, why?

Car non è entrato nel campo di applicazione perché hai scritto un classe di espressione, simile ad usare function in un'espressione funzione di

var foo = function Bar() {}; 
foo; // defined 
Bar; // undefined 

var carNew = new car("ferrari"); works, why?

Per lo stesso ragionamento di cui sopra, l'identificatore car è definito nella vostra portata e punti per l'espressione classe

---

What is use of named or unnamed class expression [...]?

consente di guardare indietro a function di nuovo. Quindi ora pensi che se lo Bar non fosse definito nell'ambito che stavamo lavorando, dov'era definito?

Beh, ovviamente abbiamo foo.name === 'Bar', ma potremmo anche fare

var foo = function Bar() {console.log(Bar)}; 
foo(); // Bar logged, we see Bar === foo here 

Grande, in modo che possiamo fare riferimento Bar all'interno della funzione.

E 'esattamente lo stesso con class, siamo in grado di fare riferimento Car dall'interno della espressione classe sé, facendoci fare comportamenti ricorsive o copiare i riferimenti statici alle istanze ecc

Ho una tale riferimento alla Rendilo facile vedere nel codice sottostante

var car = class Car { 
    constructor(model) { 
     this.model = model; 
     this.foo = Car; // the big C Car that was ReferenceErroring outside 
    } 
}; 
var bar = new car(); 
console.log(bar.foo); // logs class Car (=== car) 

Answer 3

Lo stesso uso delle funzioni con nome/non nome. Guarda il comportamento delle funzioni:

var a = function b() { console.log('b') } 
>> undefined 
a() 
>> b 
b() 
>> Uncaught ReferenceError: b is not defined(…) 

Questo è molto simile al tuo caso.

Dove e perché è necessario utilizzarlo? Di solito l'unico caso d'uso per le funzioni è quello di nominare i funzioni chiamate una volta che vi dà tipo di abilità auto-documentazione:

(function bootstrap() { 
    // 
})(); 

Qui il nome della funzione dice che la funzione del bootstrap vostra applicazione.

Quindi posso immaginare un altro caso per la classe ora: è possibile utilizzarlo per singleton classi che vengono utilizzati per creare un solo oggetto:

var a = new (class Car{ 
    constructor(model){ 
     this.model = model; 
    } 
})('ferrari'); 

console.log(a.model); 

Qui solo il nome della classe di sapere quello che sta facendo , tuttavia il nome non sarà accessibile altrove.

Answer 4

E 'generato un errore perché Car variabile non è dichiarata.

Da JavaScript | MDN documentazione:

An important difference between function declarations and class declarations is that function declarations are hoisted and class declarations are not. You first need to declare your class and then access it, otherwise code like the following will throw a ReferenceError

Quindi, per usare:

var newCar = Car('ferrari'); 

È necessario definire la variabile Car:

var Car = class Car{ 
    constructor(model){ 
     this.model = model; 
    } 
} 

Avviso qui che usiamo Car e no t car

Per quanto riguarda l'espressione della classe con nome e senza nome, ecco un esempio da JavaScript | MDN documentazione:

A class expression is another way to define a class. Class expressions can be named or unnamed. The name given to a named class expression is local to the class's body.

// unnamed 
var Polygon = class { 
    constructor(height, width) { 
    this.height = height; 
    this.width = width; 
    } 
}; 

// named 
var Polygon = class Polygon { 
    constructor(height, width) { 
    this.height = height; 
    this.width = width; 
    } 
}; 

ES6 classes - JavaScript | MDN Leggi per ulteriori informazioni

Answer 5

espressioni Classe

Analogamente alle funzioni, ci sono due tipi di definizioni di classi, due modi per definire una classe: dichiarazioni di classe ed espressioni di classe.

anche in modo simile alle funzioni, l'identificatore di un'espressione di classe è visibile solo all'interno dell'espressione:

const MyClass = class Me { 
    getClassName() { 
     return Me.name; 
    } 
}; 
const inst = new MyClass(); 
console.log(inst.getClassName()); // Me 
console.log(Me.name); // ReferenceError: Me is not defined