function makePerson(name: string, age: number) {}

// test.ts
let msg: string = 'hello world';
console.log(msg);

// type script
let var1: number = 1
const var2: string = 'string'
let var3: boolean = true
let var4: object = {}

// type script
let var1: number = 1
var1 = 'hello' // error TS2322: Type 'hello' is not assignable to type 'number'.

let var1: any = 1
var1 = 'string'
var1 = true
var1 = {}

let var1: undefined = undefined
var = 1 // error TS2322: Type '1' is not assignable to type 'undefined'.

interface IPerson {
    name: string // 필수속성
    age: number
    etc?: boolean // 선택속성
}

function printMe(me: { name: string, age: number, etc?: boolean }) {
    console.log(me.etc ? `${me.name} ${me.age} ${me.etc}` : `${me.name} ${me.age}`)
}
let person = { name: 'jack', age: 32 }
printMe(person); // jack 32

let person: {
    name: string
    age: number
    etc?: boolean
} = { name: 'jack', age: 32 }

class Container<T> {
    value: T
}

function g2<T, Q>(a: T, b: Q): void {}

printValue(new Valuable<number>(1))
printValue(new Valuable(1))

interface IValuable<T> {
    value: T
}

class Container<T extends IValuable<T>> {
    value: T
}

function create<T>(test: T): T {
    return new test();
    // 'unknown' 형식에 구문 시그니처가 없습니다.ts(2351)
}
let d=create(Date)
console.log(d)

function create<T>(type: new() => T): T {
    return new type();
}

let d=create(Date)
console.log(d)

function create<T>(type: new(...args) => T, ...args): T {
    return new type(args);
}

let d=create(Date, 2023,1,1)
console.log(d)

function printMe(name: string, age: number): void {
    console.log(`name: ${name}, age: ${age}`);
}

let printMe: (string, number) => void =
    function (name: string, age: number): void {
        console.log(`name: ${name}, age: ${age}`);
    }

type strNumVoid = (string, number) => void
let printMe: strNumVoid = function (name: string, age: number): void {
    console.log(`name: ${name}, age: ${age}`);
};

function arrPush(arr:readonly number[]) {
    arr.push() // 에러발생
}

class Person {
    private name: string
    age?: number // default public 
    static INT_VALUE: number = 1

    constructor(name: string, age?: number) {
        this.name = name
        this.age = age
    }
    
    printMe(): void { // 메서드 정의
        console.log(`name: ${this.name}, age: ${this.age}`)
    }
}

let jack: Person = new Person("jack", 25)
console.log(Person.INT_VALUE) // 1
console.log(jack) // Person { name: 'jack', age: 25 }
// console.log(jack.name) error
jack.printMe()

interface IPerson {
    name: string
    age: number
    printMe(): void;
}

// name age 중 하나라도 없을경우 컴파일 오류
let p1: IPerson = {
    name: "kouzie", age: 20,
    printMe: function (): void {
        throw new Error("Function not implemented.");
    }
};

// 인터페이스 구현체  
class Student implements IPerson {
    // name, age 중 하나라도 없을경우 컴파일 오류
    name: string;
    age: number;
    grade: number;
    // 구현필수
    printMe(): void {
        throw new Error("Method not implemented.");
    }
}

abstract class AbstractPerson {
    name: string
    age?: number

    constructor(age?: number) {
        this.age = age;
    }
    // 기본메서드
    sayHi(): void {
        console.log(`hi i'm ${this.age}`)
    }
    // 추상메서드
    abstract printMe(): void;
}

class Person extends AbstractPerson {
    name: string;

    constructor(name: string, age?: number) {
        super(age);
        this.name = name;
    }

    // 없으면 에러발생
    printMe(): void {
        throw new Error("Method not implemented.");
    }
}

let p1 = new Person("kouzie", 20);
p1.sayHi(); // hi i'm 20

interface INameable { name: string };
let obj: object = { name: 'Jack' };

let name1 = (obj as INameable).name;
let name2 = (<INameable>obj).name;
console.log(name1, name2) // Jack Jack

interface Array<T> {
    /**
     * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
     */
    length: number;
    /**
     * Returns a string representation of an array.
     */
    toString(): string;
    ...

let tp: [number, string, boolean] = [1, '2', false]
console.log(tp[0]) // 1
console.log(tp[1]) // 2
console.log(tp[2]) // false
let [n, s, b] = tp; // 디스트럭처링

type nsbForTuple = [number, string, boolean]
let tp: nsbForTuple = [1, '2', false]

type numOrStr = number | string
let ns_n: numOrStr = 1;
let ns_s: numOrStr = "1";

console.log(ns_n) // 1
console.log(ns_s) // 1

type INameable = { name: string }
type IAgeable = { age: number }

let obj1: INameable = { name: 'Jack' };
let obj2: IAgeable = { age: 32 };
let obj3: INameable & IAgeable = { name: 'Jack', age: 32 };