1. 웹 개발 기초 지식

[선언 키워드] [변수명]: [타입]
const var1: number = 11

interface User {
    name: string;
    age: number;
}

const user: User = {
    name: 'Dexter',
    age: 21,
}

class User {
    constructor(name: string, age: number) { }
}

const user: User = new User('Dexter', 21);

// MyUser 타입은 기존 User 타입을 그대로 사용하지만
// 본인이 사용하는 서비스에 맞는 이름으로 바꾼 것
type MyUser = User;

// parameter를 다양하게 받을 수 있음
function getLength(obj: string | string[]) {
    return obj.length;
}

// 변수가 가질 수 있는 값을 제한할 수 있음
type Status = 'Ready' | 'Waiting';

enum Status {
    READY = 'Ready',
    WAITING = 'Waiting',
}

function identity(arg: any): any {
    return arg;
}

function identity<T>(arg: T): T {
    return arg;
}

function deco(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('데커레이터가 평가됨');
}

class TestClass {
    @deco
    test() {
        console.log('함수 호출됨');
    }
}

const t = new TestClass();
t.test();

// 데커레이터가 평가됨
// 함수 호출됨

function deco(value: string) {
    console.log('데커레이터가 평가됨');
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        console.log(value);
    }
}

class TestClass {
    @deco('HELLO')
    test() {
        console.log('함수 호출됨');
    }
}

const t = new TestClass();
t.test();

// 데커레이터가 평가됨
// HELLO
// 함수 호출됨

@f
@g
test
// f(g(x)) 와 비슷한 형태로 결과를 낸다.

function first() {
    console.log("first(): factory evaluated");
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        console.log("first(): called");
    }
}

function second() {
    console.log("second(): factory evaluated");
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        console.log("second(): called");
    }
}

class ExampleClass {
    @first()
    @second()
    method() {
        console.log('method is called');
    }
}

const example = new ExampleClass();
example.method();

// first(): factory evaluate
// second(): factory evaluate
// second(): called
// first(): called
// method is called

// 클래스 데커레이터 팩터리
// 생성자 타입에 의해 new 키워드와 함께 어떠한 형식의 인수들도 받아들일 수 있는 타입
// 상속받는 제네릭 타입 T를 가지는 생성자를 팩터리 메서드의 인수로 전달하고 있다.
function reportableClassDecorator<T extends {new (...args: any[]): {} }>(constructor: T) {
    // 생성자를 리턴하는 함수여야한다.
    return class extends constructor {
        // reportingURL이라는 속성을 추가한다.
        reportingURL = "http://www.example.com";
    };
}

@reportableClassDecorator
class BugReport {
    type = 'report';
    title: string;
    constructor(t: string) {
        this.title = t;
    }
}

const bug = new BugReport("Needs dark mode");
console.log(bug);

// {type:'report', title:'Needs dark mode', reportingURL:'http://www.example.com'}

function HandleError() {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        console.log(target);
        console.log(propertyKey);
        console.log(descriptor);

        const method = descriptor.value;

        descriptor.value = function() {
            try {
                method();
            } catch (e) {
                console.log(e);
            }
        }
    };
}

class Greeter {
    @HandleError()
    hello() {
        throw new Error('테스트 에러');
    }
}

const t = new Greeter();
t.hello();

interface PropertyDescriptor {
    configurable?: boolean; // 속성의 정의를 수정할 수 있는지 여부
    enumerable?: boolean;   // 열거형인지 여부
    value?: any;            // 속성 값
    writable?: boolean;     // 수정 가능 여부
    get?(): any;            // getter
    set?(v: any): void;     // setter
}

function Enumerable(enumerable: boolean) {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        descriptor.enumerable = enumerable
    };
}

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

    @Enumerable(true)
    get getName() {
        return this.name;
    }

    // set은 열거할 수 없다.
    @Enumerable(false)
    set setName(name: string) {
        this.name = name;
    }
}

const person = new Person('Dexter');
for (let key in person) {
    console.log(`${key}: ${person[key]}`);
}

// name: Dexter
// getName: Dexter

function format(formatString: string) {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        let value = target[propertyKey];
        function getter() {
            return `${formatString} ${value}`;
        }

        function setter(newVal: string) {
            value = newVal;
        }

        return {
            get: getter,
            set: setter,
            enumerable: true,
            configurable: true,
        };
    };
}

class Greeter {
    @format('Hello')
    greeting: string;
}

const t = new Greeter();
t.greeting = 'World';
console.log(t.greeting);

import { BadRequestException } from '@nestjs/common'

function MinLength(min: number) {
    return function (target: any, propertyKey: string, parameterIndex: number) {
        target.validators = {
            minLength: function (args: string[]) {
                return args[parameterIndex].length >= min;
            }
        };
    };
}

function Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const method = descriptor.value;

    descriptor.value = function(...args) {
        Object.keys(target.validators).forEach(key => {
            if (!target.validators[key](args)) {
                throw new BadRequestException();
            }
        });
        method.apply(this, args);
    };
}

class User {
    private name: string;

    @Validate
    setName(@MinLength(3) name: string) {
        this.name = name;
    }
}

const t = new User();
t.setName('Dexter');
console.log('-----------------');
t.setName('De'); // 3 보다 길이가 작기 때문에 예외 발생