TypeScript learning notes: type narrowing

let x = [0, 1, null] // number

let x = Math.random() < 0.5 ? 100 : "helloword" // number|string

let x: Animal[] = [new Rhino(), new Elephant(), new Snake()]; // Rhino | Elephant | Snake

// Union type type Types = number | string

function typeFn(type: Types, input: string): string {
  // If you write this, you need to determine the type of type}

let x:number|string = 1
x="tiedan"

function typeFn(type: number | string, input: string) {
  // Error operator + cannot be applied to string 
  return new Array(type + 1).join("") + input
}

function typeFn(type: number | string, input: string) {
  // Type guard if (typeof type === 'number') {
    return new Array(type + 1).join(" ") + input
  }
  return type + input
}

"string"
"number"
"bigint" // ES10 adds "boolean"
"symbol" // ES6 adds "undefined"
"object"
"function"

function strOrName(str: string | string[] | null) {
  if (typeof str === 'object') {
    for (const s of str) {
      // Report an error because str may be null
      console.log(s)
    }
  } else if (typeof str === 'string') {
    console.log(str)
  } else {
    //......
  }
}

0
NAN
""
0n // Bigint version of 0 null
undefined

// Use true value to judge if (str && typeof strs === 'object') {
  for (const s of strs) {
    console.log(s)
  }
}

function valOrName(values: number[] | undefined, filter: number): number[] | undefined {
  if (!values) {
    return values
  } else {
    return values.filter(x => x > filter)
  }
}

function strOrNum(x: string | number, y: string | boolean) {
  if (x === y) {
    // string
  } else {
    // string|number
  }
}

function strOrName(str: string | string[] | null) {
  if (str !== null) {
    if (typeof str === 'object') {
      for (const s of str) {
        console.log(s) // []
      }
    } else if (typeof str === 'string') {
      console.log(str) // string
    } else {
      // .....
    }
  }
}

interface Types {
  value: number | null | undefined
}

function valOrType(type: Types, val: number) {
  // null and undefined are both false and can only be numbers
  if (type.value != null) {
    type.value *= val
  }
}

interface A { a: number };
interface B { b: string };

function foo(x: A | B) {
    if ("a" in x) {
        return xa;
    }
    return xb;
}

function dateInval(x: Date | string) {
  if (x instanceof Date) {
    // Date
  } else {
    // string
  }
}

function example() {
  let x: string | number | boolean
  x = Math.random() < 0.5
  if (Math.random() < 0.5) {
    x = 'hello' // string
  } else {
    x = 100 // number
  }
  return x; // string|number
}

interface Shape {
  kind: "cirle" | "square",
  redius?: number
  sideLength?: number
}

// Error function getArea(shape: Shape) {
	return Math.PI * shape.redius ** 2
}
// Narrowing or error function getArea(shape: Shape) {
  if (shape.kind === 'cirle') {
    return Math.PI * shape.redius ** 2
  }
}
// Using non-null assertion function getArea(shape: Shape) {
  if (shape.kind === 'cirle') {
    return Math.PI * shape.redius! ** 2
  }
}

interface Circle {
  kind: "cirle";
  redius: number;
}

interface Square {
  kind: "square";
  redius: number;
}

type Shape = Circle | Square

function getArea(shape: Shape) {
  if (shape.kind === 'cirle') { // narrow return Math.PI * shape.redius ** 2
  }
}

// or function getArea(shape: Shape) {
  switch (shape.kind) {
    case "cirle":
      return Math.PI * shape.redius ** 2
    case "square":
      return shape.sideLength ** 2
    default:
      const _example: never = shape
      return _example
  }
}