[TypeScript] 여러가지 Type 선언

function add(a: number, b: number): number {

    return a + b;

  }

 

  const sum: number = add(1, 2); // Error

  console.log(sum);

 

  //Boolean

  let isBoolean: boolean;

  let isBooleanFalse: boolean = false;

  //Number

  let num : number;

  let nan : number =  NaN;

// string

let str : string;

let name : string = "tester";

// Array

let names : string[] = ["tester","tester2","tester3"];

let someArr : any[] = ["tester",28,NaN];

//Interface and type

interface tester {

    name : string,

    age :number,

    isExist : boolean;

}

let testerInterface: tester[] = [

    {

        name: "Neo",

        age: 10,

        isExist: true,

      },

      {

        name: "Lewis",

        age: 64,

        isExist: false,

      },

      {

        name: "Evan",

        age: 123,

        isExist: true,

      },

]

type User = {

    name: string;

    age: number;

    isValid: boolean;

};

let userArr: User[] = [

    {

        name: "Neo",

        age: 10,

        isValid: true,

    },

    {

        name: "Lewis",

        age: 64,

        isValid: false,

    },

    {

        name: "Evan",

        age: 123,

        isValid: true,

    },

];

//  interface와 type은 몇 가지 차이점을 제외하고는 거의 동일한 것으로 보임.

//Null && Undefinded

let undefin: undefined = undefined;

let nul: null = null;

let stringOrNull: string | null = null;

let numberOrUndefined: string | undefined = undefined;

//any : 어떤 타입이던지 가능 -> 자바스크립트의 특징 (예측할 수 없는 데이터, 추론이 어려운 데이터)

let any: any = 123;

any = 'play game';

any = {};

any = null;

const arr: any[] = [1, true, 'typescript'];

//void (어떠한 함수가 return값이 없을 때 사용 가능)

function coding(msg: string): void {

    console.log(`Happy ${msg}`);

  }

  // union 두가지 이상의 타입을 모두 가질 때 (string타입을 가지거나 number를 가지거나) || or 연산자 이용

  let union: (string | number);

union = 'Hello World';

union = 777;

union = false; // Error

// Intersection 두가지 이상의 타입을 모두 만족해야할 때 and 연산자 이용

interface User {

  name: string,

  age: number

}

interface Validation {

  isValid: boolean

}

const testCase2: User & Validation = {

  name: 'jisu',

  age: 30,

  isValid: true // 이걸 지우면 missing not 에러 발생

}

// 함수 타입

let myFunc: (arg1: number, arg2: number) => number;

myFunc = function(x, y) {

  return x + y;

}

myFunc(1, 2); // 3

let noneFunc: () => void;

noneFunc = function () {

  console.log('hihi');

};

// 변경 불가능한 읽기 전용 타입

let arrA: readonly number[] = [1, 2, 3, 4];

let arrB: ReadonlyArray<number> = [2, 4, 6, 8];

arrA.push('5'); //ERR 발생

// 타입이 정해져있는 튜플

let tuple: [string, number];

tuple = ['a', 1];

tuple = [1, 'a']; // Error

let userA: [number, string, boolean] = [1234, 'juyoung', true];

let usersA: [number, string, boolean][];

let usersB: Array<[number, string, boolean]>

usersA = [[1, 'chisus', true], [2, 'jisu', false]];

let tupleA: [1, number];

tupleA = [1, 2];

tupleA = [2, 3]; // Error

let a: readonly [string, number] = ['rest', 123];

a[0] = 'work'; // Error

// 열거형

enum Week {

  Sun,

  Mon,

  Tue,

  Wed,

  Thu,

  Fri,

  Sat

}

enum Color {

  Red = 'red',

  Green = 'green',

  Blue = 'blue'

}

// Object

let obj: object = {};

let arr: object = [];

let func: object = function () {};

let date: object = new Date();

interface Users {

  name: string,

  age: number

}

let userA: Users = {

  name: 'juyoung',

  age: 27

};

// Unknown 타입

let u: unknown = 123;

let test1: number = u; // Error

let test2: number = u as number;

let test3: any = u;