타입스크립트는 변수나 파라미터 등에 데이터 타입을 명시하여 코드 작성 단계에서 오류를 확인할 수 있고 미리 타입을 결정하여 실행 속도가 빠르다는 장점이 있습니다.
그러나 매번 타입을 지정하는 것은 분명 번거로운 일이므로 타입스크립트의 단점으로 꼽힙니다.
더욱이 똑같은 기능을 하는 함수지만 상황에 따라 다른 데이터 타입을 전달받는 함수는 매번 타입에 맞는 함수를 생성해야 합니다.
그렇다면 데이터를 전달할 때 데이터 타입 정보도 함께 전달해서 함수에게 알려주면 어떨까요?
전달하는 데이터의 타입 정보를 함께 전달하여 선언 시점이 아닌 생성 시점에 타입 정보도 변수처럼 변경할 수 있도록 하는 기능이 바로 제네릭입니다.
제네릭은 오래 전 C++부터 사용되어 왔는데요.
제네릭 함수의 모양새는 다음과 같습니다.
//함수형
const thisGeneric = <T>(value: T):T => {
return value;
}
//클래스형
function thisGeneric2<T>(value: T) : T {
return value;
}
const myVariable = thisGeneric<string>('my generic');
const myVariable2 = thisGeneric2('my generic2'); //< >생략 시 타입 추론
< >를 사용해 제네릭을 표현하고 안의 T는 정해진 것이 아니므로 다른 글자를 사용해도 되지만 관습적으로 T(type의 t)를 많이 사용합니다. 만약 두 개의 제네릭 정보를 받는 경우에는 <T, U>와 같이 표기합니다.
많이 사용되는 알파벳의 의미는 다음과 같습니다.
T : type E : element K : key V : value
어떤 타입을 전달해도 사용이 가능한 any도 제네릭으로 볼 수 있지만 any는 타입을 체크하지 않으므로 전달받은 데이터의 타입을 알 수 없고 리턴 시에도 타입 정보를 반환하지 않습니다. 그러나 제네릭은 전달받은 타입을 확인하고 정보를 함께 반환할 수 있으며 세부적인 제한을 둘 수도 있습니다.
제네릭 인터페이스도 사용 방법은 제네릭 함수와 동일합니다.
interface ValueInterface<T> {
value : T
}
let myValue : ValueInterface<string> {
value : 'data'
}
그렇다면 or의 연산자 | 를 사용하여 여러 타입을 지정할 수 있는 유니온 타입과는 어떤 차이가 있을까?
유니온은 | 로 지정한 여러 타입의 공통 메서드만 사용할 수 있으며 리턴 데이터의 타입도 하나가 아닌 유니온 타입이 반환됩니다.
function myUnion(val:number|string){
return val;
}
const test = myUnion('string');
console.log(test.length); //에러 (length는 number와 string의 공통 메서드가 아니므로)
유사한 기능이 존재하지만 제네릭이 갖는 장점이 명확합니다.
제네릭을 사용하면 깔끔하게 코드를 줄이면서도 코드의 재활용이 가능해 매우 유용합니다.
제네릭을 사용한 오픈 소스들이 매우 많으므로 제네릭을 익혀두면 다른 고급 개발자들의 코드를 살펴볼 때도 큰 도움이 될 것 같습니다.
배열 관련하여 각 요소별로 순회하는 반복문 작업을 할 때 가장 익숙한 방법을 사용하거나 때로는 가장 먼저 떠오르는 방법을 사용하기도 합니다.
배열의 크기가 작으면 상관이 없지만 배열의 크기가 커지면 작은 차이가 큰 차이를 만들어낼 수 있습니다.
문득 연산 속도가 가장 빠른 반복문이 무엇일까라는 궁금증이 생겨 간단하게 하나의 배열 데이터를 다른 배열로 옮기는 연산을 통해 속도를 테스트해보고자 합니다.
크기에 상관없이 반복문 별로 같은 효율을 보여주리라 생각했지만 배열의 크기에 따라 각각 다른 속도를 보여주는 점이 흥미로웠습니다.
1. 테스트 방법
먼저 일정 크기를 갖는 배열 array을 생성합니다.
console.time 메서드를 사용해 이 배열의 데이터를 다른 배열로 복사하는 작업을 진행하고 이 작업 시간을 측정합니다.
테스트는 map, for, while, for…in, for…of의 다섯 가지 반복문을 사용합니다.
// 배열 데이터 생성
const array = [];
for(let i=0;i<10000;i++){
array.push(i);
}
// 데이터가 복사될 배열
let arraymap = [];
console.time('map'); //타이머 시작
arraymap = array.map(list=>list);
console.timeEnd('map'); //타이머 종료
위와 같은 방식으로 3회씩 테스트를 진행하며 배열의 크기를 조절하여 반복문 별로 상대적인 작업 속도의 변화를 확인합니다.
2. 테스트
먼저 배열의 크기가 아주 작을 때는 모두 큰 차이를 보이지 않습니다.
다음은 배열의 크기가 100일 때 결과입니다.
작업을 세 번 진행한 결과 map과 for…of가 엎치락뒤치락하지만 항상 가장 빠른 속도를 보여줍니다.
for, while, for…in도 세번 모두 결과가 엎치락뒤치락하지만 위의 두 반복문보단 느린 속도를 보여줍니다.
그럼 배열의 크기를 1000으로 올려보겠습니다.
크기가 1000일 때는 대체적으로 비슷한 속도를 보여줍니다.
for…in만 다른 반복문보다 느린 것이 확인됩니다.
이제 확연하게 유의미한 차이를 느낄 수 있는 크기인 10000으로 올려보겠습니다.
10000에서는 map이 가장 우수한 속도를 보여줍니다.
눈에 띄는 부분은 작은 사이즈에서는 map과 대등한 속도를 보이던 for…of가 여기서는 가장 느린 속도를 기록합니다.
또한 for…in은 오히려 for…of보다 빠른 속도를 보여줍니다.
그럼 1000000으로 확인해 보겠습니다.
배열이 매우 커지니 작업 속도는 for문이 가장 준수합니다.
map, while도 큰 차이를 보이지 않고 준수한 성능을 보여줍니다.
for…of는 확연하게 조금 느린 속도를 보여주고 for…in은 이제 인사를 해야할 것 같습니다.
그럼 마지막으로 10000000(천만)으로 테스트를 해보겠습니다.
세 번 테스트한 결과 모두 for 문이 가장 빠른 속도를 보여주었으며, map, while도 의미있는 속도를 보여줍니다.
확실히 for…of는 위의 세 반복문보다 느린 속도를 보여주었으며 for…in은 10배가 넘는 느린 속도의 차이를 보여줍니다.
3. 결과 정리
배열 테이터의 크기가 작을 때는 의미있는 차이가 없지만 배열이 커질수록 map, for, while의 속도가 우수하고 for…in, for…of는 속도 저하를 보이는 결과를 나타냅니다.
어디까지나 단순한 작업인 배열 데이터 복사 기능만을 사용한 테스트이므로 작업 내용에 따라 다른 결과를 보일 가능성이 있어 단순 참고용으로 삼으면 좋을 것 같습니다.
다음은 테스트에 사용한 코드 전체입니다.
console.log('-------------start----------------')
const array = [];
for(let i=0;i<10000;i++){ //크기 변경
array.push(i);
}
console.log("arraysize:"+array.length);
console.log('--------------------------------');
let arraymap = [];
console.log('arraymap start:'+arraymap.length);
console.time('map');
arraymap = array.map(list=>list);
console.log('arraymap end:'+arraymap.length);
console.timeEnd('map');
console.log('--------------------------------');
let arrayfor = [];
console.log('arrayfor start:'+arrayfor.length);
console.time('for');
for(let i=0; i<array.length;i++){
arrayfor.push(array[i]);
};
console.log('arrayfor end:'+arrayfor.length);
console.timeEnd('for');
console.log('--------------------------------');
let arraywhile = [];
let whilenum = 0;
console.log('arraywhile start:'+arraywhile.length);
console.time('while');
while(whilenum<array.length){
arraywhile.push(array[whilenum]);
whilenum++;
};
console.log('arraywhile end:'+arraywhile.length);
console.timeEnd('while');
console.log('--------------------------------');
const arrayforof = [];
console.log('arrayforof start:'+arrayforof.length);
console.time('forof');
for(const num of array){
arrayforof.push(num)
};
console.log('arrayfor end:'+arrayforof.length);
console.timeEnd('forof');
console.log('--------------------------------');
let arrayforin = [];
console.log('arrayforin start:'+arrayforin.length);
console.time('forin');
for(const num in array){
arrayforin.push(array[num]);
};
console.log('arrayforin end:'+arrayforin.length);
console.timeEnd('forin');
console.log('---------------end-----------------');