const N = 100000;
const a = Array.from({ length: N }, (_, i) => i);
const b = Array.from({ length: N }, (_, i) => i);
 
console.time('pop');
while (a.length) a.pop(); // 맨 뒤 -> 당길 것이 없다
console.timeEnd('pop'); // pop: 1.8ms
 
console.time('shift');
while (b.length) b.shift(); // 맨 앞 -> 나머지를 전부 당긴다
console.timeEnd('shift'); // shift: 952.9ms

class Node {
  constructor(value) {
    this.value = value;
    // 다음 노드를 가리킨다. 마지막 노드는 가리킬 곳이 없어 null 이다
    this.next = null;
  }
}
 
class LinkedList {
  constructor() {
    this.head = null; // 첫 노드
    this.tail = null; // 마지막 노드. 없으면 push 할 때마다 끝까지 걸어가야 한다
    this.size = 0;
  }
 
  // 맨 앞에 붙인다. 뒤쪽 노드는 아무것도 건드리지 않으므로 O(1)
  unshift(value) {
    const node = new Node(value);
 
    node.next = this.head;
    this.head = node;
 
    // 비어 있었다면 이 노드가 처음이자 마지막이다
    if (!this.tail) {
      this.tail = node;
    }
 
    this.size++;
 
    return this;
  }
 
  // 맨 뒤에 붙인다. tail 을 들고 있어서 끝까지 걸어갈 필요가 없다. O(1)
  push(value) {
    const node = new Node(value);
 
    if (!this.head) {
      this.head = node;
      this.tail = node;
    } else {
      this.tail.next = node;
      this.tail = node;
    }
 
    this.size++;
 
    return this;
  }
 
  // index 번째 노드를 찾는다. 주소를 계산할 수 없어 앞에서부터 세어 간다. O(n)
  nodeAt(index) {
    if (index < 0 || index >= this.size) {
      return null;
    }
 
    let current = this.head;
 
    for (let i = 0; i < index; i++) {
      current = current.next;
    }
 
    return current;
  }
 
  at(index) {
    return this.nodeAt(index)?.value;
  }
 
  // index 번째 노드를 끊어낸다
  removeAt(index) {
    if (index < 0 || index >= this.size) {
      return undefined;
    }
 
    let removed;
 
    if (index === 0) {
      removed = this.head;
      this.head = removed.next;
    } else {
      // 끊어낼 노드의 "앞" 노드를 잡아야 연결을 다시 이어줄 수 있다
      const prev = this.nodeAt(index - 1);
 
      removed = prev.next;
      prev.next = removed.next;
 
      // 마지막을 지웠다면 tail 을 앞으로 당긴다
      if (removed === this.tail) {
        this.tail = prev;
      }
    }
 
    if (this.size === 1) {
      this.tail = null;
    }
 
    this.size--;
    removed.next = null;
 
    return removed.value;
  }
 
  // head 부터 next 를 따라가며 전부 훑는다
  toArray() {
    const result = [];
 
    for (let current = this.head; current; current = current.next) {
      result.push(current.value);
    }
 
    return result;
  }
}
 
const list = new LinkedList();
 
list.push('b').push('c').unshift('a');
 
console.log(list.toArray()); // ['a', 'b', 'c']
console.log(list.at(1)); // 'b'
 
list.removeAt(1);
 
console.log(list.toArray()); // ['a', 'c']
console.log(list.size); // 2

const Component = ({ withFirst }) => {
  if (withFirst) {
    useState('first'); // 조건에 따라 있었다 없었다 한다
  }
 
  const [second] = useState('second');
 
  return <span>{second}</span>;
};

const modalStack = [];
 
const openModal = (id) => {
  modalStack.push(id);
};
 
const closeTopModal = () => {
  // 마지막에 넣은 것이 먼저 나온다
  return modalStack.pop();
};
 
document.addEventListener('keydown', (event) => {
  if (event.key === 'Escape') {
    closeTopModal();
  }
});
 
openModal('설정');
openModal('설정 > 알림');
openModal('알림 > 삭제 확인');
 
closeTopModal(); // '알림 > 삭제 확인'
closeTopModal(); // '설정 > 알림'

class Queue {
  constructor() {
    this.items = [];
    // 어디까지 꺼냈는지만 기록하고 실제로 지우지는 않는다
    this.head = 0;
  }
 
  get size() {
    return this.items.length - this.head;
  }
 
  enqueue(value) {
    this.items.push(value);
  }
 
  dequeue() {
    if (this.size === 0) {
      return undefined;
    }
 
    const value = this.items[this.head];
 
    // shift 대신 가리키는 위치만 한 칸 옮긴다. 뒤쪽을 당기지 않으므로 O(1)
    this.head++;
 
    // 꺼낸 자리가 절반을 넘으면 그때 한 번에 정리한다
    if (this.head * 2 >= this.items.length) {
      this.items = this.items.slice(this.head);
      this.head = 0;
    }
 
    return value;
  }
}