TypeScript 之 Class（下）

class MyClass {  static x = 0;  static printX() {    console.log(MyClass.x);  }}console.log(MyClass.x);MyClass.printX();

class MyClass {  private static x = 0;}console.log(MyClass.x);// Property 'x' is private and only accessible within class 'MyClass'.

class Base {  static getGreeting() {    return "Hello world";  }}class Derived extends Base {  myGreeting = Derived.getGreeting();}

class S {  static name = "S!";  // Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'S'.}

// javapublic class OuterClass {  private static String a = "1";  static class InnerClass {    private int b = 2;  }}

// Unnecessary "static" classclass MyStaticClass {  static doSomething() {}} // Preferred (alternative 1)function doSomething() {} // Preferred (alternative 2)const MyHelperObject = {  dosomething() {},};

class Foo {    static #count = 0;     get count() {        return Foo.#count;    }     static {        try {            const lastInstances = loadLastInstances();            Foo.#count += lastInstances.length;        }        catch {}    }}

class Box<Type> {  contents: Type;  constructor(value: Type) {    this.contents = value;  }} const b = new Box("hello!");// const b: Box<string>

class Box<Type> {  static defaultValue: Type;  // Static members cannot reference class type parameters.}

class MyClass {  name = "MyClass";  getName() {    return this.name;  }}const c = new MyClass();const obj = {  name: "obj",  getName: c.getName,}; // Prints "obj", not "MyClass"console.log(obj.getName());

class MyClass {  name = "MyClass";  getName = () => {    return this.name;  };}const c = new MyClass();const g = c.getName;// Prints "MyClass" instead of crashingconsole.log(g());

// TypeScript input with 'this' parameterfunction fn(this: SomeType, x: number) {  /* ... */}

// JavaScript outputfunction fn(x) {  /* ... */}

class MyClass {  name = "MyClass";  getName(this: MyClass) {    return this.name;  }}const c = new MyClass();// OKc.getName(); // Error, would crashconst g = c.getName;console.log(g());// The 'this' context of type 'void' is not assignable to method's 'this' of type 'MyClass'.

class Box {  contents: string = "";  set(value: string) {  // (method) Box.set(value: string): this    this.contents = value;    return this;  }}

class ClearableBox extends Box {  clear() {    this.contents = "";  }} const a = new ClearableBox();const b = a.set("hello");
// const b: ClearableBox

class Box {  content: string = "";  sameAs(other: this) {    return other.content === this.content;  }}

class Box {  content: string = "";  sameAs(other: this) {    return other.content === this.content;  }} class DerivedBox extends Box {  otherContent: string = "?";} const base = new Box();const derived = new DerivedBox();derived.sameAs(base);// Argument of type 'Box' is not assignable to parameter of type 'DerivedBox'.  // Property 'otherContent' is missing in type 'Box' but required in type 'DerivedBox'.

class FileSystemObject {  isFile(): this is FileRep {    return this instanceof FileRep;  }  isDirectory(): this is Directory {    return this instanceof Directory;  }  isNetworked(): this is Networked & this {    return this.networked;  }  constructor(public path: string, private networked: boolean) {}} class FileRep extends FileSystemObject {  constructor(path: string, public content: string) {    super(path, false);  }} class Directory extends FileSystemObject {  children: FileSystemObject[];} interface Networked {  host: string;} const fso: FileSystemObject = new FileRep("foo/bar.txt", "foo"); if (fso.isFile()) {  fso.content;  // const fso: FileRep} else if (fso.isDirectory()) {  fso.children;  // const fso: Directory} else if (fso.isNetworked()) {  fso.host;  // const fso: Networked & FileSystemObject}

class Box<T> {  value?: T;   hasValue(): this is { value: T } {    return this.value !== undefined;  }} const box = new Box();box.value = "Gameboy"; box.value;  // (property) Box<unknown>.value?: unknown if (box.hasValue()) {  box.value;  // (property) value: unknown}

class Params {  constructor(    public readonly x: number,    protected y: number,    private z: number  ) {    // No body necessary  }}const a = new Params(1, 2, 3);console.log(a.x);// (property) Params.x: number
console.log(a.z);// Property 'z' is private and only accessible within class 'Params'.

const someClass = class<Type> {  content: Type;  constructor(value: Type) {    this.content = value;  }}; const m = new someClass("Hello, world");  // const m: someClass<string>

abstract class Base {  abstract getName(): string;   printName() {    console.log("Hello, " + this.getName());  }} const b = new Base();// Cannot create an instance of an abstract class.

class Derived extends Base {  getName() {    return "world";  }} const d = new Derived();d.printName();

class Derived extends Base {  // Non-abstract class 'Derived' does not implement inherited abstract member 'getName' from class 'Base'.  // forgot to do anything}

function greet(ctor: typeof Base) {  const instance = new ctor();  // Cannot create an instance of an abstract class.  instance.printName();}

// Bad!greet(Base);

function greet(ctor: new () => Base) {  const instance = new ctor();  instance.printName();}greet(Derived);greet(Base);
// Argument of type 'typeof Base' is not assignable to parameter of type 'new () => Base'.// Cannot assign an abstract constructor type to a non-abstract constructor type.

class Point1 {  x = 0;  y = 0;} class Point2 {  x = 0;  y = 0;} // OKconst p: Point1 = new Point2();

class Person {  name: string;  age: number;} class Employee {  name: string;  age: number;  salary: number;} // OKconst p: Person = new Employee();

class Empty {} function fn(x: Empty) {  // can't do anything with 'x', so I won't} // All OK!fn(window);fn({});fn(fn);