function hello(message: any) : any {
  return message
}
console.log(hello('mark')) // any로 추론되기 때문에 .length 같은 property를 사용하지 못한다
console.log(hello(39))

function helloGeneric<T> (message:T) :T { // 함수의 안에서 T의 타입을 기억하게 된다
  return message
}
console.log(helloGeneric('Mark'))

function helloGeneric<T> (message:T) :T { // 함수의 안에서 T의 타입을 기억하게 된다
  return message
}
console.log(helloGeneric(39))

function helloGeneric<T> (message:T) :T { // 함수의 안에서 T의 타입을 기억하게 된다
  return message
}
console.log(helloGeneric(true))

function helloBasic<T>(message: T): T {
  return message
}

helloBasic<string>('hello') // 타입이 string으로 된다
helloBasic(36) // T의 타입을 넣지 않으면 추론된다 36이 number이지만 number가 아닌 가장 좁은 범위인 36으로 추론된다

function helloArray<T>(message: T[]): T {
  return message[0]
}

helloArray(['Hello', 'World'])
helloArray(['hello', 5])

function helloTuple<T, K>(message: [T, K]): T {
  return message[0]
}
helloTuple(['Hello', 'World'])
helloTuple(['Hello', 5])

// type alias
type HelloFunctionGeneric1 = <T>(message: T) => T

const hellofunction1: HelloFunctionGeneric1 = <T>(message: T): T => {
  return message
}

// interface
interface HelloFunctionGeneric2 {
  <T>(message: T): T
}

const helloFunction2: HelloFunctionGeneric2 = <T>(message: T): T => {
  return message
}

class Person<T> {
  private _name: T

  constructor(name: T) {
    this._name = name
  }
}
const p1 = new Person('Mark')
new Person<string>('123')

class Person<T, K> {
  private _name: T
  private _age: K

  constructor(name: T, age: K) {
    this._name = name
    this._age = age
  }
}

const p1 = new Person(123, 'Mark')
new Person<string, number>('Hello', 123)

class PersonExtends<T extends string | number> {
  // T 는 string 과 number만 가능하다
  // class 상속과는 조금 다른 개념
  private _name: T

  constructor(name: T) {
    this._name = name
  }
}

new PersonExtends('Mark')
new PersonExtends(39)
new PersonExtends(true) // error

interface IPerson {
  name: string
  age: number
}

const person: IPerson = {
  name: 'Mark',
  age: 39,
}

type Keys = keyof IPerson

const keys: Keys = 'name'

// IPerson[keyof IPerson]
// => IPerson["name" | "age"]
// => IPerson['name] | IPerson['age']
// => string | number
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key]
}

getProp(person, 'name')

function setProp<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value
}

setProp(person, 'name', 'anna')

class Person {
  name
  constructor(name: string) {
    this.name = name
  }
}
const p1 = new Person('Mark')

console.log(p1.name)

class Person {
  name: string
  age: number
}
const p1 = new Person()

console.log(p1)

class Person {
  name: string = "Mark"
  age: number
}
const p1 = new Person()
p1.age = 39 // 초기값 없이 이후에 값을 설정 하고 싶을때
console.log(p1)

class Person {
  name: string = "Mark"
  age!: number // age 뒤에 ! 를 붙여준다
}
const p1 = new Person()
// p1.age = 39 // age 뒤에 ! 가 붙어있는데 값을 설정 하지 않은 경우
console.log(p1.age)
// undefined가 뜬다

class Person {
  name: string = 'Mark'
  age: number

  private constructor(age: number) {
    this.age = age
  }

  async init() {}
}
const p1 = new Person(39) // error
// p1.age = 39
console.log(p1.age)

class Person {
  name: string = 'Mark'
  private age: number

  constructor(age: number) {
    this.age = age
  }

  async init() {}
}
const p1 = new Person(39) 
// p1.age = 39
console.log(p1.age) // error

// 기존
class Person {
  name: string
  age: number

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}
const p1 = new Person('Mark', 39)
console.log(p1)


// 수정

class Person {
  constructor(public name: string, public age: number) {
  }
}
const p1 = new Person('Mark', 39)
console.log(p1)

class Person {
  constructor(public name: string, public age: number) {}
}
const p1 = new Person('Mark', 39)
console.log(p1.name) // get
p1.name = 'John' // set

class Person {
  constructor(public _name: string, public age: number) {}

  get name() {
    console.log('get')
    return this._name
  }

  set name(n: string) {
    // return 해줄 필요 없다
    // 인자를 받아 넣어 준다
    console.log('set')
    this._name = n
  }
}
const p1 = new Person('Mark', 39)
console.log(p1.name) // get
p1.name = 'John' // set

// sub1 타입은 sup1 타입의 서브 타입이다.
let sub1: 1 = 1;
let sup1: number = sub1;
sub1 = sup1 //error! Type 'number' is not assignable to type '1'

// sub2 타입은 sup2 타입의 서브 타입이다
let sub2: number[] = [1]
let sup2: object = sub2; // sup2에는 sub2를 할당 할 수 있다
sub2 = sup2 
// error! Type '{}' is missing the following properties from type 'number[]':length, pop, push, concat, and 16 more.

// sub3 타입은 sup3 타입의 서브 타입이다.
let sub3: [number, number] = [1,2]
let sup3: number[] = sub3; // sup3에 sub3 을 할당 할 수 있다
sub3 = sup3
// error! Type 'number[]' is not assignable to type '[number, number]'. Target requires 2 element(s) but source may have fewer.

// sub4 타입은 sup4 타입의 서브 타입이다.
let sub4: number = 1;
let sup4: any = sub4; // any는 어떤것도 들어갈 수 있다
sub4 = sup4; // 반대의 경우도 마찬가지

// sub5 타입은 sup5 타입의 서브 타입이다.
let sub5: never = 0 as never;
let sup5: number = sub5; // number에 포함 될 수 있지만 반대의 경우 문제가 된다
sub5 = sup5; // error! Type 'number' is not assignable to type 'never'

class Animal {}
class Dog extends Animal {
  eat() {}
}

// sub6 타입은 sup6 타입의 서브 타입이다.
let sub6: Dog = new Dog()
let sup6: Animal = sub6;
sub6 = sup6; // error! Property 'eat' is missing in type 'SubAnimal' but required in type 'SubDog'

// primitive type
let sub7: string = '';
let sup7: string | number = sub7;

// object - 각각의 프로퍼티가 대응하는 프로퍼티와 같거나 서브타입이어야 한다.
let sub8: { a: string; b: number} ={a: '', b: 1}
let sup8: { a: string | number; b: number} = sub8;

// array - object 와 마찬가지
let sub9: Array<{ a: string; b:number}> =[{a: '', b: 1}]
let sup9: Array<{ a: string | number; b: number}> = sub8;

interface Person1 {
  // 컴파일 됐을때는 사라지게 된다
  // 컴파일 타임에만 필요하다
  // 컴파일 타임에 인터페이스를 이용해 관계를 규명해 체크해주는 역할
  name: string
  age: number
}

function hello1(person: Person1): void {
  console.log(`안녕하세요 ${person.name}입니다`)
}

const p1: Person1 = {
  name: 'Mark',
  age: 39,
}
hello1(p1)

interface Person2 {
  name: string
  age?: number
  // 객체에 있을수도 있고 없을수도 있을때 ? 를 뒤에 붙인다
}

function hello2(person: Person2): void {
  console.log(`안녕하세요 ${person.name}입니다 `)
}

hello2({ name: 'Mark', age: 39 })
hello2({ name: 'Anna' })

interface Person3 {
  name: string
  age?: number
  [index: string]: any
}

function hello3(person: Person3): void {
  console.log(
    `안녕하세요 ${person.name} ${person.systers} ${person.father}입니다`
  )
}

const p31: Person3 = {
  name: 'Mark',
  age: 39,
}

const p32: Person3 = {
  name: 'Anna',
  systers: ['sung', 'chan'], // any 이기 때문에 들어 올 수 있다
}

const p33: Person3 = {
  name: 'Bokdan',
  father: p31, // any 이기 때문에 들어 올 수 있다
  mother: p32, // any 이기 때문에 들어 올 수 있다
}

hello3(p31)
hello3(p32)
hello3(p33)

interface Person4 {
  name: string
  age: number
  hello(): void
}

const p41: Person4 = {
  name: 'Mark',
  age: 39,
  hello: function (): void {
    console.log(`안녕하세요! ${this.name} 입니다`)
  },
}

const p42: Person4 = {
  name: 'mark',
  age: 39,
  hello(this: Person4): void {
    console.log(`안녕하세요! ${this.name}입니다`)
  },
}

const p43: Person4 = {
  name: 'Mark',
  age: 39,
  hello: (this: Person4): void => {
    console.log(`안녕하세요! ${this.name}입니다`) // this는 글로벌을 가르킨다
  },
}