Live Note

class Greeter {
  greeting: string

  constructor(message: string) {
    this.greeting = message
  }

  greet(): string {
    return "Hello, " + this.greeting
  }
}

class Animal {
  constructor(private name: string) {}
}

class Horse extends Animal {
  constructor() {
    super("Horse")
  }
}

class Human {
  constructor(private name: string) {}
}

let animal = new Animal("Lucy")
let horse = new Horse()
let human = new Human("Jack")
animal = horse // success
animal = human // failed

enum Direction {
  UP,
  DOWN,
  LEFT,
  RIGHT,
}

function move(length: number, direction: Direction): void {
  console.log(`move: ${direction} ${length}meters.`)
}

move(10, Direction.UP)

enum Direction {
  UP = "UP",
  DOWN = "DOWN",
  LEFT = "LEFT",
  RIGHT = "RIGHT",
}

function foo(x: number, y: string): string {
  return x + y
}

let fo = function (x: number, y: string): string {
  return x + y
}

let foo: (x: number, y: string) => string = function (
  x: number,
  y: string
): string {
  return x + y
}

let foo: (x: number, y: string) => string = function (x, y) {
  return x + y
}

function foo<T>(arg: T): T {
  return arg
}

function len<T>(arg: Array<T>): Array<T> {
  console.log(arg.length)
  return arg
}

function foo<T>(arg: T): T {
  return arg
}

interface fooInterface<T> {
  (arg: T): T
}

let myFunction: <T>(arg: T) => T = foo
let otherFunction: { <T>(arg: T): T } = foo
let interfaceFunction: fooInterface<number> = foo

interface labelValue {
  label: string
}

function printLabel(obj: labelValue): void {
  console.log(obj.label)
}

let obj = { size: 10, label: "some text" }
printLabel(obj)

interface SquareConfig {
  color?: string
  width?: number
}

function createSquare(config: SquareConfig): { color: string; area: number } {
  let defaultSquare = { color: "White", area: 200 }
  if (config.color) defaultSquare.color = config.color
  if (config.width) defaultSquare.area = config.width ** 2

  return defaultSquare
}

console.log(createSquare({ color: "Black", width: 30 }))

interface Point {
  readonly x: number
  readonly y: number
}

let readOnlyArray: ReadonlyArray<number> = [1, 2, 3, 4]
let a: number[] = readOnlyArray as number[] // readonly array assignment to ordinary array

interface SquareConfig {
  color?: string
  width?: number
  [propName: string]: any
}

let newSquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig)