[타입스크립트] 객체지향적으로 Generic Stack<T> 클래스 구현하기

프로그래밍의 꽃, 객체지향의 꽃 제네릭

제네릭은 어딜 가도 통상적으로 볼 수 있다.(재사용성이 굉장히 높기 때문)

이전포스팅 stack의 단점은 오로지 string형만 push, pop 할 수 있다는 것이다.

다양한 타입을 push, pop 하고 싶다면 제네릭을 이용해서 활용성과 재사용성을 높일 수 있다.

유연하고 타입도 보장할 수 있고, 재사용을 정말 많이 높일 수 있는 제네릭을 마스터해본다.

(오픈소스나 API 문서를 볼 때 제네릭을 알고 있다면 막힘없이 읽을 수 있다.)

 

 

 

 

각종 제네릭 자료구조들도 '클래스'이다.

가령 C#의 stack<T> 클래스는 다음 링크와 같다.

https://docs.microsoft.com/ko-kr/dotnet/api/system.collections.generic.stack-1?view=net-6.0 

Stack<T> 클래스 (System.Collections.Generic)

정의

네임스페이스:System.Collections.Generic어셈블리:System.Collections.dll

지정한 동일 형식의 인스턴스로 이루어진 가변 크기 LIFO(후입선출) 방식의 컬렉션을 나타냅니다.

C#복사

 

public class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

형식 매개 변수

T

스택에 있는 요소의 형식을 지정합니다.

상속

Object

Stack<T>

구현

IEnumerable<T>  IReadOnlyCollection<T>  ICollection  IEnumerable

 

실행

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Stack<string> numbers = new Stack<string>();
        numbers.Push("one");
        numbers.Push("two");
        numbers.Push("three");
        numbers.Push("four");
        numbers.Push("five");

        // A stack can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}",
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

        // Create a copy of the stack, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Stack<string> stack2 = new Stack<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in stack2 )
        {
            Console.WriteLine(number);
        }

        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the
        // array.
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);

        // Create a second stack, using the constructor that accepts an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in stack3 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}",
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */

 

 

1. C# 처럼 모든 타입 명시해주면서 작성해보기

string

interface Stack<T> {
  readonly size: number;
  push(value: T): void;
  pop(): T;
}

type StackNode<T> = {
  readonly value: T;
  readonly next?: StackNode<T>;
};

class StackImpl<T> implements Stack<T> {
  private _size: number = 0;
  //head는 StackNode를 바라볼 수도, 안 바라보고 있을 수도 있음(StackNode|undefined 로 쓰는 대신, optional로 지정)
  private head?: StackNode<T>;

  constructor(private capacity?: number) {}

  get size() {
    return this._size;
  }

  push(value: T): void {
    //지금 사이즈가 정해진 용량과 똑같다면(꽉 찬 상태라면 ㅠㅠ)
    if (this.capacity !== undefined) {
      if (this.size === this.capacity) {
        throw new Error("Stack is Full!!");
      }
    }
    //node는 StackNode(사용자 지정 노드)라는 데이터타입을 따라가는 노드로,
    //value라는 키에 전달받은 value를 할당받는데 이름이 똑같아서 굳이 value:value라고 쓸  필요없이 value라고만 작성
    //next는 head가 기존에 바라보고 있는 것을 가리키면 됨!!!
    const node: StackNode<T> = { value, next: this.head };
    //node는 새로 들어온 아이이고, head는 다시 새로들어온 노드를 바라보게 한다.
    this.head = node;
    this._size++;
  }
  pop(): T {
    //스택이 비어있는 경우에 node가 없을 수도 있다.
    //그러나 API 자체에서 string | undefined를 해주면 들어갈 떄 마다 null check를 하게되서 별로고,(값이 있는지 없는지 매번 유효성 검사를 하는 꼴)
    //항상 있고, 리턴할 준비가 되어있다고 지정하는 대신에 아래 if문 작성
    // null == undefined, null !== undefined
    if (this.head == null) {
      throw new Error("Stack is empty!");
    }
    //헤드가 바라보고 있던 노드의 value를 리턴해주기 위한 기초작업(1)
    const node = this.head;
    //head가 다시 이전 노드를 바라보도록 지정(사실상 여기서 연결끊김)
    this.head = node.next;
    //스택 사이즈 줄여주기
    this._size--;
    //헤드가 바라보고 있던 노드의 value를 리턴(pop되고 이제 사실상 무시됨)
    return node.value;
  }
}

const stack: StackImpl<string> = new StackImpl<string>();
console.log(stack);
stack.push("떡볶이");
console.log(stack);
stack.push("순대");
console.log(stack);
stack.push("피자");
console.log(stack);
stack.push("라면");
console.log(stack);
console.log(stack.pop());

console.log(stack);

console.log("스택을 비워봅시다!");
while (stack.size != 0) {
  console.log(stack.pop());
}
console.log(stack.pop());

 

2. 타입스크립트 감성으로 타입 주석만 달기

object

interface Stack<T> {
  readonly size: number;
  push(value: T): void;
  pop(): T;
}

type StackNode<T> = {
  readonly value: T;
  readonly next?: StackNode<T>;
};

class StackImpl<T> implements Stack<T> {
  private _size: number = 0;
  //head는 StackNode를 바라볼 수도, 안 바라보고 있을 수도 있음(StackNode|undefined 로 쓰는 대신, optional로 지정)
  private head?: StackNode<T>;

  constructor(private capacity?: number) {}

  get size() {
    return this._size;
  }

  push(value: T): void {
    //지금 사이즈가 정해진 용량과 똑같다면(꽉 찬 상태라면 ㅠㅠ)
    if (this.capacity !== undefined) {
      if (this.size === this.capacity) {
        throw new Error("Stack is Full!!");
      }
    }
    //node는 StackNode(사용자 지정 노드)라는 데이터타입을 따라가는 노드로,
    //value라는 키에 전달받은 value를 할당받는데 이름이 똑같아서 굳이 value:value라고 쓸  필요없이 value라고만 작성
    //next는 head가 기존에 바라보고 있는 것을 가리키면 됨!!!
    const node: StackNode<T> = { value, next: this.head };
    //node는 새로 들어온 아이이고, head는 다시 새로들어온 노드를 바라보게 한다.
    this.head = node;
    this._size++;
  }
  pop(): T {
    //스택이 비어있는 경우에 node가 없을 수도 있다.
    //그러나 API 자체에서 string | undefined를 해주면 들어갈 떄 마다 null check를 하게되서 별로고,(값이 있는지 없는지 매번 유효성 검사를 하는 꼴)
    //항상 있고, 리턴할 준비가 되어있다고 지정하는 대신에 아래 if문 작성
    // null == undefined, null !== undefined
    if (this.head == null) {
      throw new Error("Stack is empty!");
    }
    //헤드가 바라보고 있던 노드의 value를 리턴해주기 위한 기초작업(1)
    const node = this.head;
    //head가 다시 이전 노드를 바라보도록 지정(사실상 여기서 연결끊김)
    this.head = node.next;
    //스택 사이즈 줄여주기
    this._size--;
    //헤드가 바라보고 있던 노드의 value를 리턴(pop되고 이제 사실상 무시됨)
    return node.value;
  }
}

const stack: StackImpl<object> = new StackImpl();
stack.push({ name: "신짱구" });
console.log(stack);
stack.push({ name: "신짱아" });
console.log(stack);
stack.push({ name: "흰둥이" });
console.log(stack);
stack.push({ name: "액션가면" });
console.log(stack);
console.log(stack.pop());

console.log(stack);

console.log("스택을 비워봅시다!");
while (stack.size != 0) {
  console.log(stack.pop());
}
console.log(stack.pop());

 

 

 

3. 제네릭 타입만 한정해주기

boolean 형 테스트

interface Stack<T> {
  readonly size: number;
  push(value: T): void;
  pop(): T;
}

type StackNode<T> = {
  readonly value: T;
  readonly next?: StackNode<T>;
};

class StackImpl<T> implements Stack<T> {
  private _size: number = 0;
  //head는 StackNode를 바라볼 수도, 안 바라보고 있을 수도 있음(StackNode|undefined 로 쓰는 대신, optional로 지정)
  private head?: StackNode<T>;

  constructor(private capacity?: number) {}

  get size() {
    return this._size;
  }

  push(value: T): void {
    //지금 사이즈가 정해진 용량과 똑같다면(꽉 찬 상태라면 ㅠㅠ)
    if (this.capacity !== undefined) {
      if (this.size === this.capacity) {
        throw new Error("Stack is Full!!");
      }
    }
    //node는 StackNode(사용자 지정 노드)라는 데이터타입을 따라가는 노드로,
    //value라는 키에 전달받은 value를 할당받는데 이름이 똑같아서 굳이 value:value라고 쓸  필요없이 value라고만 작성
    //next는 head가 기존에 바라보고 있는 것을 가리키면 됨!!!
    const node: StackNode<T> = { value, next: this.head };
    //node는 새로 들어온 아이이고, head는 다시 새로들어온 노드를 바라보게 한다.
    this.head = node;
    this._size++;
  }
  pop(): T {
    //스택이 비어있는 경우에 node가 없을 수도 있다.
    //그러나 API 자체에서 string | undefined를 해주면 들어갈 떄 마다 null check를 하게되서 별로고,(값이 있는지 없는지 매번 유효성 검사를 하는 꼴)
    //항상 있고, 리턴할 준비가 되어있다고 지정하는 대신에 아래 if문 작성
    // null == undefined, null !== undefined
    if (this.head == null) {
      throw new Error("Stack is empty!");
    }
    //헤드가 바라보고 있던 노드의 value를 리턴해주기 위한 기초작업(1)
    const node = this.head;
    //head가 다시 이전 노드를 바라보도록 지정(사실상 여기서 연결끊김)
    this.head = node.next;
    //스택 사이즈 줄여주기
    this._size--;
    //헤드가 바라보고 있던 노드의 value를 리턴(pop되고 이제 사실상 무시됨)
    return node.value;
  }
}

const stack = new StackImpl<boolean>();
stack.push(true);
console.log(stack);
stack.push(false);
console.log(stack);
stack.push(true);
console.log(stack);
stack.push(false);
console.log(stack);
console.log(stack.pop());

console.log(stack);

console.log("스택을 비워봅시다!");
while (stack.size != 0) {
  console.log(stack.pop());
}
console.log(stack.pop());

 

4. 제네릭 타입, 타입 주석 생략하고 완전 추론시키기 

number로 테스트

interface Stack<T> {
  readonly size: number;
  push(value: T): void;
  pop(): T;
}

type StackNode<T> = {
  readonly value: T;
  readonly next?: StackNode<T>;
};

class StackImpl<T> implements Stack<T> {
  private _size: number = 0;
  //head는 StackNode를 바라볼 수도, 안 바라보고 있을 수도 있음(StackNode|undefined 로 쓰는 대신, optional로 지정)
  private head?: StackNode<T>;

  constructor(private capacity?: number) {}

  get size() {
    return this._size;
  }

  push(value: T): void {
    //지금 사이즈가 정해진 용량과 똑같다면(꽉 찬 상태라면 ㅠㅠ)
    if (this.capacity !== undefined) {
      if (this.size === this.capacity) {
        throw new Error("Stack is Full!!");
      }
    }
    //node는 StackNode(사용자 지정 노드)라는 데이터타입을 따라가는 노드로,
    //value라는 키에 전달받은 value를 할당받는데 이름이 똑같아서 굳이 value:value라고 쓸  필요없이 value라고만 작성
    //next는 head가 기존에 바라보고 있는 것을 가리키면 됨!!!
    const node: StackNode<T> = { value, next: this.head };
    //node는 새로 들어온 아이이고, head는 다시 새로들어온 노드를 바라보게 한다.
    this.head = node;
    this._size++;
  }
  pop(): T {
    //스택이 비어있는 경우에 node가 없을 수도 있다.
    //그러나 API 자체에서 string | undefined를 해주면 들어갈 떄 마다 null check를 하게되서 별로고,(값이 있는지 없는지 매번 유효성 검사를 하는 꼴)
    //항상 있고, 리턴할 준비가 되어있다고 지정하는 대신에 아래 if문 작성
    // null == undefined, null !== undefined
    if (this.head == null) {
      throw new Error("Stack is empty!");
    }
    //헤드가 바라보고 있던 노드의 value를 리턴해주기 위한 기초작업(1)
    const node = this.head;
    //head가 다시 이전 노드를 바라보도록 지정(사실상 여기서 연결끊김)
    this.head = node.next;
    //스택 사이즈 줄여주기
    this._size--;
    //헤드가 바라보고 있던 노드의 value를 리턴(pop되고 이제 사실상 무시됨)
    return node.value;
  }
}

const stack = new StackImpl();
stack.push(1);
console.log(stack);
stack.push(2);
console.log(stack);
stack.push(3);
console.log(stack);
stack.push(4);
console.log(stack);
console.log(stack.pop());

console.log(stack);

console.log("스택을 비워봅시다!");
while (stack.size != 0) {
  console.log(stack.pop());
}
console.log(stack.pop());