interface Person {
  name: string;
  age?: string;
  [propName: string]: any;
}

class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
  greet() {
    return "Hello, " + this.greeting;
  }
}
let greeter = new Greeter("world");

class Animal {
  name: string;
  constructor(theName: string) {
    this.name = theName
  }
  move(distanceInMeters: number = 0){
    console.log(`${this.name} moved ${distanceInMeters}m`)
  }
  class Snake extends Animal {
    constructor(name: string) {
      super(name)
    }
    move(distanceInMeters = 5){
      console.log("Slitering...")
      super.move(distanceInMeters)
    }
  }
class Horse extends Animal {
  constructor(name: string){
    super(name)
  }
  move(distanceInMeters = 40){
    console.log("Galloping...");
    super.move(distanceInMeters);
  }
}
let sam = new Snake('Python');
let tom: Animal = new Horse('Palo');
sam.move();
tom.move(34);

class Animal {
  private name: string;
  constructor(theName: string) {
    this.name = theName;
  }
new Animal("Cat").name //error, name是私有的.

class Animal {
  private name: string;
  constructor(theName: string) {
    this.name = theName;
  }
}
class Rhio extends Animal {
  constructor() {
    super("Rhio");
  }
}
class Employee {
  private name: string;
  cosntructor(theName: string) {
    this.name = theName;
  }
}
let animal = new Animal("Goat");
let rhio = new Rhio();
let employee = new Employee("Bob");

animal = rhio;
animal = employee; //error,Animal和Employee不兼容.

class Person {
  protected name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Employee extends Person {
  private department: string;

  constructor(name: string, department: string) {
    super(name);
    this.department = department;
  }

  public getElevatorPitch() {
    return `Hello, my name is ${this.name} and I work in ${this.department}.`;
  }
}

let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误

class Employee {
  fullName: string;
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
  console.log(employee.fullName);
}

let passcode = "secret passcode";
class Employee {
  private _fullName: string;

  get fullName(): string {
    return this._fullName();
  }
  set fullName(newName: string) {
    if (passcode && passcode == "secret passcode") {
      this._fullName = newName;
    } else {
      console.log("Error");
    }
  }
}

let empolyee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
  alert(employee.fullName);
}

abstract class Department {
  constructor(public name: string) {}

  printName(): void {
    console.log("Department name: " + this.name);
  }

  abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {
  constructor() {
    super("Accounting and Auditing"); // 在派生类的构造函数中必须调用 super()
  }

  printMeeting(): void {
    console.log("The Accounting Department meets each Monday at 10am.");
  }

  generateReports(): void {
    console.log("Generating accounting reports...");
  }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在

class Point {
  x: number;
  y: number;
}

interface Point3d extends Point {
  z: number;
}

let point3d: Point3d = { x: 1, y: 2, z: 3 };

class DellAnalyzer implements IAnalyzer {
    private static instance: DellAnalyzer
  // 使用该函数提供对外的方法入口
    static getInstance() {
        if (!DellAnalyzer.instance) {
            DellAnalyzer.instance = new DellAnalyzer()
        }
        return DellAnalyzer.instance
    }
    // 改成单例模式,私有化constructor,外部无法调用
    private constructor() { }
  ...

function testDecorator() {
  // 使用泛型规范入参为构造函数
  return function <T extends new (...args: any[]) => any>(constructor: T) {
    // 扩展constructor
    return class extends constructor {
      name = "lee";
      getName() {
        return this.name;
      }
    };
  };
}

const Test = testDecorator()(
  class {
    name: string;
    constructor(name: stirng) {
      this.name = name;
    }
  }
);
const test = new Test("dell");
console.log(test.getName);

function getNameDecorator(
  target: any,
  key: string,
  descriptor: PropertypeDecorator
) {}
class Test {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  @getNameDecorator
  getName() {
    return this.name;
  }
}

const test = new Test("dell");
consoele.log(test.getName());

function visitDecorator(
  target: any,
  key: string,
  descriptor: PropertyDecorator
) {}
class Test {
  private _name: string;
  constructor(name: string) {
    this._name = name;
  }
  get name() {
    return this._name;
  }
  @visitDecorator
  set name(name: string) {
    this._name = name;
  }
}
const test = new Test("dell");
test.name = "dell lee";
console.log(test.name);

function nameDecorator(target: any, key: string): any {
  const descriptor: PropertyDecorator = {
    writable: false,
  };
  return descriptor;
}
class Test {
  @nameDecorator
  name = "dell";
}
const test = new Test();
test.name = "dell lee";
console.log(test.name); //报错

function paramDecorator(target: any, method: string, paramIndex: number) {
  console.log(target, method, paramIndex);
}
class Test {
  getInfo(@paramDecorator name: string, age: number) {
    console.log(name, age);
  }
}
const test = new Test();
test.getInfo("Dell", 30);

// 工厂模式返回一个装饰器
function catchError(msg: string) {
  return function (target: any, key: string, discriptor: propertyDecorator) {
    const fn = discriptor.value;
    descriptor.value = function () {
      try {
        fn();
      } catch (e) {
        console.log(msg);
      }
    };
  };
}
class Test {
  @catchError("userInfo.name不存在")
  getName() {
    return userInfo.name;
  }
  @catchError("userInfo.age不存在")
  getAge() {
    return userInfo.age;
  }
}
const test = new Test();
test.getName();
test.getAge();

let myAdd: (x: number, y: number) => number = function (
  x: number,
  y: number
): number {
  return x + y;
};

// myAdd has the full function type
let myAdd = function (x: number, y: number): number {
  return x + y;
};

// The parameters `x` and `y` have the type number
let myAdd: (baseValue: number, increment: number) => number = function (x, y) {
  return x + y;
};

function buildName(firstName: string, lastName: string;) {
  return firstName + " " + lastName
}
let result1 = buildName("Bob"); //error, 少参数
let result2 = buildName("Bob",

function buildName(firstName: string, ...restOfName: string[]){
  return firstName + ' ' + restOfName.join(" ")
}
let employeeName = buildName("Jose", "Sam" ,"Lucas", "Mack"

interface Card {
  suit: string;
  card: number;
}
interface Deck {
  suits: string[];
  cards: number[];
  createCardPicker(this: Deck): () => Card;
}
let deck: Deck = {
  suits: ["hearts", "spades", "clubs", "diamonds"],
  cards: Array(52),
  // NOTE: The function now explicitly specifies that its callee must be of type Deck
  createCardPicker: function (this: Deck) {
    return () => {
      let pickedCard = Math.floor(Math.random() * 52);
      let pickedSuit = Math.floor(pickedCard / 13);

      return { suit: this.suits[pickedSuit], card: pickedCard % 13 };
    };
  },
};

let cardPicker = deck.createCardPicker();
let pickedCard = cardPicker();

alert("card: " + pickedCard.card + " of " + pickedCard.suit);

let suits = ["hearts", "spades", "clubs", "diamonds"];

function pickCard(x: { suit: string; card: number }[]): number;
function pickCard(x: number): { suit: string; card: number };
function pickCard(x): any {
  // Check to see if we're working with an object/array
  // if so, they gave us the deck and we'll pick the card
  if (typeof x == "object") {
    let pickedCard = Math.floor(Math.random() * x.length);
    return pickedCard;
  }
  // Otherwise just let them pick the card
  else if (typeof x == "number") {
    let pickedSuit = Math.floor(x / 13);
    return { suit: suits[pickedSuit], card: x % 13 };
  }
}

let myDeck = [
  { suit: "diamonds", card: 2 },
  { suit: "spades", card: 10 },
  { suit: "hearts", card: 4 },
];
let pickedCard1 = myDeck[pickCard(myDeck)];
alert("card: " + pickedCard1.card + " of " + pickedCard1.suit);

let pickedCard2 = pickCard(15);
alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);

function join<T, P>(first: T, second: P) {
  return `${first}${second}`;
}
// 声明的时候并不知道具体参数是什么类型
// 但是使用时, 通过在这里声明就限定了参数的类型
join<number, string>(1, "1");
// 当然也可以不写,这样会自己推断出
join(1, "1");

function loggingIdentity<T>(arg: T[]): T[] {
  console.log(arg.length); // Array has a .length, so no more error
  return arg;
}

class DataManager<T> {
  constructor(private data: T[]) {}
  getItem(index: number): T {
    return this.data[index];
  }
}
// 调用时指定泛型是number
const data = new DataManger<number>(["1"]);
data.getItem(0);

interface Lengthwise {
  length: number
}
function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length)
  retrun arg
}

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}
//Up初始化为1,其余成员从1开始增长
//如果不设置初始值,那么up为0,总之,各个值都是不同的

// jQuery.d.ts
// 定义全局变量
declare var $: (param: () => void) => void;
// 定义全局函数
interface JQueryInstance {
  html: (html: string) => JqueryInstance;
}

// 函数重载(也就是重复声明)
declare function $(readyFunc: () => void): void;
declare function $(selector: string): JqueryInstance;
// 使用interface定义
interface JQuery {
  (readyFunc: () => void): void;
  (selector: string): JqueryInstance;
}
declare var $: JQuery;

declare let n: number = 123; //可以全局访问
declare namespace myLib {
  function making(s: string): string;
  let numbeOfMaking: number;
}
// 可以将这些变量放在namespace的作用域内,
// 通过myLib.making()进行访问.
// 内部不用再写declare,另外内部也可以嵌套namespace

type Words = "a" | "b" | "c";
type W<T> = T extends Words ? true : false;
type WA = W<"a">; // => true
type WD = W<"d">; // => false

type Union<T> = T extends Array<infer U> ? U : never;

type ParamType<T> = T extends (param: infer P) => any ? P : T;
interface IDog {
  name: string;
  age: number;
}
type Func = (dog: IDog) => void;
type Param = ParamType<Func>; //IDog
type TypeSring = ParamType<stirng>; //string

interface IPerson {
  name: string;
  age: number;
  sex?: string;
}
type K1 = keyof IPerson; //'name' | 'age' | 'sex'
type K2 = keyof IPerson[]; //'length'|'push'|'pop'...
type K3 = typeof { [x:string]: Person }; //string | number`

interface IPerson {
  name: string;
  age: number;
  sex?: string;
}

const jack: IPerson = { name: "jack", age: 100 };
type Jack = typeof jack; // -> IPerson

function foo(x: number): Array<number> {
  return [x];
}

type F = typeof foo; // -> (x: number) => number[]
//Jack 这个类型别名实际上就是 jack 的类型 IPerson，
//而 F 的类型就是 TS 自己推导出来的 foo 的类型 (x: number) => number[]。

type Partial<T> = {
  [P in keyof T]?: T[P];
};

interface Dog {
  age: number;
  name: string;
  pirce: number;
}

type PartialDog = Partial<Dog>;
//等价于
type PartialDog = {
  age?: number;
  name?: string;
  pirce?: number;
};

/**
 * Construct a type with a set of properties K of type T
 * 构造一个具有一组属性K(类型T)的类型
 */

type Record<K extends keyof any, T> = {
  [P in K]: T;
};

type petsGroup = "dog" | "cat";
interface IPetInfo {
  name: string;
  age: number;
}

type IPets = Record<petsGroup, IPetInfo>;

const animalsInfo: IPets = {
  dog: {
    name: "wangcai",
    age: 2,
  },
  cat: {
    name: "xiaobai",
    age: 3,
  },
};

/**
 * From T, pick a set of properties whose keys are in the union K
 * 从T中，选择一组键在并集K中的属性
 */
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};

interface IDog {
  name: string;
  age: number;
  height: number;
  weight: number;
}

type PickDog = Pick<IDog, "name" | "age" | "height">;
// 等价于
type PickDog = {
  name: string;
  age: number;
  height: number;
};

let dog: PickDog = {
  name: "wangcai",
  age: 3,
  height: 70,
};

/**
 * Exclude from T those types that are assignable to U
 * 从T中排除那些可分配给U的类型
 */
type Exclude<T, U> = T extends U ? never : T;

interface IDog {
  name: string;
  age: number;
  height: number;
  weight: number;
  sex: string;
}

type keys = keyof IDog; // -> "name" | "age" | "height" | "weight" | "sex"

type ExcludeDog = Exclude<keys, "name" | "age">;
// 等价于
type ExcludeDog = "height" | "weight" | "sex";

/**
 * Extract from T those types that are assignable to U
 * 从T中提取可分配给U的类型
 */
type Extract<T, U> = T extends U ? T : never;

/**
 * Construct a type with the properties of T except for those in type K.
 * 构造一个除类型K之外的T属性的类型
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

/**
 * Exclude null and undefined from T
 * 从T中排除null和undefined
 */
type NonNullable<T> = T extends null | undefined ? never : T;

/**
 * Obtain the parameters of a function type in a tuple
 * 在元组中获取构造函数类型的参数
 */
type Parameters<T extends (...args: any) => any> = T extends (
  ...args: infer P
) => any
  ? P
  : never;

type T0 = Parameters<() => string>; // []
type T1 = Parameters<(s: string) => void>; // [string]

/**
 * Obtain the parameters of a constructor function type in a tuple
 * 在元组中获取构造函数类型的参数
 */
type ConstructorParameters<T extends new (...args: any) => any> =
  T extends new (...args: infer P) => any ? P : never;

/**
 * Obtain the return type of a function type
 * 获取函数类型的返回类型
 */
type ReturnType<T extends (...args: any) => any> = T extends (
  ...args: any
) => infer R
  ? R
  : any;

/**
 * Obtain the return type of a constructor function type
 * 获取构造函数类型的返回类型
 */

type InstanceType<T extends new (...args: any) => any> = T extends new (
  ...args: any
) => infer R
  ? R
  : any;

/**
 * Marker for contextual 'this' type
 * 上下文“this”类型的标记
 */
interface ThisType<T> {}

interface Cat {
  name: string;
  age: number;
}
const obj: ThisType<Person> = {
  mimi() {
    this.name; // string
  },
};

// 没有ThisType情况下
const dog = {
  wang() {
    console.log(this.age); // error，在dog中只有wang一个函数，不存在a
  },
};
// 使用ThisType
const dog: { wang: any } & ThisType<{ age: number }> = {
  wang() {
    console.log(this.wang); // error，因为没有在ThisType中定义
    console.log(this.age); // ok
  },
};
dog.wang; // ok 正常调用
dog.age; // error，在外面的话，就跟ThisType没有关系了,这里就是没有定义age了

///<reference path="...' />