i objektorienterad programmering är en klass en extensibel programkod-mall för att skapa objekt, som ger initiala värden för stat (medlemsvariabler) och implementeringar av beteende (medlemsfunktioner eller metoder).

i praktiken behöver vi ofta skapa många objekt av samma slag, som användare, eller varor eller vad som helst.

som vi redan vet från kapitelkonstruktören kan operatören ”ny”,new function hjälpa till med det.,

men i den moderna JavaScript, det finns en mer avancerad ”klass” konstruktion, som introducerar stora nya funktioner som är användbara för objektorienterad programmering.

”class” syntax

den grundläggande syntaxen är:

class MyClass { // class methods constructor() { ... } method1() { ... } method2() { ... } method3() { ... } ...}

använd sedan new MyClass() för att skapa ett nytt objekt med alla listade metoder.

metodenconstructor() anropas automatiskt avnew, så att vi kan initiera objektet där.,

till exempel:

class User { constructor(name) { this.name = name; } sayHi() { alert(this.name); }}// Usage:let user = new User("John");user.sayHi();

När new User("John") kallas:

1. ett nytt objekt skapas.
2. constructor körs med det angivna argumentet och tilldelar det tillthis.name.

…då kan vi anropa objektmetoder, till exempeluser.sayHi().

vad är en klass?

Så, vad exakt är enclass? Det är inte en helt ny språknivå enhet, som man kan tro.

Låt oss avslöja någon magi och se vad en klass verkligen är. Det hjälper till att förstå många komplexa aspekter.

i JavaScript är en klass en typ av funktion.,

Här, ta en titt:

class User { constructor(name) { this.name = name; } sayHi() { alert(this.name); }}// proof: User is a functionalert(typeof User); // function

vad class User {...} konstruera verkligen gör är:

1. skapar en funktion som heter User, som blir resultatet av klassdeklarationen. Funktionskoden tas från metodenconstructor (antas vara tom om vi inte skriver en sådan metod).
2. lagrar klassmetoder, såsom sayHi, I User.prototype.,

efternew User objekt skapas, när vi kallar sin metod, det är taget från prototypen, precis som beskrivs i kapitlet F. prototyp. Så objektet har tillgång till klassmetoder.,av class User deklaration som:

här är code to introspect it:

inte bara ett syntaktiskt socker

ibland säger folk att class är ett ”syntaktiskt socker” (syntax som är utformat för att göra det lättare att läsa, men introducerar inte något nytt), eftersom vi faktiskt kunde förklara detsamma utan class sökord alls:

resultatet av denna definition är ungefär detsamma., Så det finns faktiskt skäl till varför class kan betraktas som ett syntaktiskt socker för att definiera en konstruktör tillsammans med dess prototypmetoder.

det finns fortfarande viktiga skillnader.

1. först märks en funktion som skapats avclass av en speciell intern egenskap]:"classConstructor". Så det är inte helt detsamma som att skapa det manuellt.

   språket kontrollerar den egenskapen på olika platser., Till exempel, till skillnad från en vanlig funktion, måste den anropas med new:

   class User { constructor() {}}alert(typeof User); // functionUser(); // Error: Class constructor User cannot be invoked without 'new'

   även en strängrepresentation av en klasskonstruktör i de flesta JavaScript-motorer börjar med ”class…”

   class User { constructor() {}}alert(User); // class User { ... }

   det finns andra skillnader, vi ser dem snart.

2. klassmetoder är icke-uppräkningsbara.,En klassdefinition anger enumerable flagga till false för alla metoder i "prototype".

   det är bra, för om vi for..in över ett objekt vill vi vanligtvis inte ha dess klassmetoder.

3. klasser alltid use strict.All kod inuti klasskonstruktionen är automatiskt i strikt läge.

förutom,class syntax ger många andra funktioner som vi ska utforska senare.,

Klassuttryck

precis som funktioner kan klasser definieras i ett annat uttryck, skickas runt, returneras, tilldelas etc.

här är ett exempel på ett klassuttryck:

let User = class { sayHi() { alert("Hello"); }};

i likhet med namngivna funktionsuttryck kan klassuttryck ha ett namn.,

om ett klassuttryck har ett namn är det bara synligt i klassen:

vi kan till och med göra klasser dynamiskt ”on-demand”, så här:

Getters/setters

precis som bokstavliga objekt kan klasser innehålla getters/setters, beräknade egenskaper etc.

här är ett exempel föruser.name implementeras medget/set:

tekniskt sett fungerar en sådan klassdeklaration genom att skapa getters och setters iUser.prototype.,

beräknade namn

här är ett exempel med ett beräknat metodnamn med hjälp av parentes:

class User { () { alert("Hello"); }}new User().sayHi();

class User { name = "John"; sayHi() { alert(`Hello, ${this.name}!`); }}new User().sayHi(); // Hello, John!

class User { name = "John";}let user = new User();alert(user.name); // Johnalert(User.prototype.name); // undefined

Vi kan också tilldela värden med hjälp av mer komplexa uttryck och funktionssamtal:

class User { name = prompt("Name, please?", "John");}let user = new User();alert(user.name); // John