CPA의 설정

• Webpack : 모듈 번들러 설정(entry, output, loader, plugin 등)
• Babel
• ESLint
• PostCSS
• Fast Refresh
• 환경 변수
• 개발 서버
• 파일 구조

단점

• 추상화된 설정값을 수정하기 번거로움(Webpack, Babel 등)
• SSR을 제공하지 않아, 추가적인 설정이 필요

SSR(Server-Side Rendering)

React 컴포넌트를 서버에서 HTML로 렌더링한 뒤 브라우저에 전달하는 방식 사용자가 서버에 접속하면, 서버에서 이미 렌더링된 HTML을 만들어서 보여준다.

⚙️ CRA에서 SSR을 구현하려면 필요한 설정

1. ReacDOM.render() → ReactDOM.hydrate() 변경 → 서버가 HTML 전달했다고 알려주는 역할
2. 서버 생성(예: Express, Node.js 기반 서버) → 사용자에게 보내줘야 함
3. Webpack 설정을 eject 해서 설정을 직접 수정 → 서버 렌더링 가능
4. 라우팅 조정(React Router 설정 주의) → 서버도 경로를 인식하고 페이지를 그려야 함
5. 데이터 불러오기 → 필요한 데이터를 서버에서 미리 가져오기 → 빈 화면 보이지 않도록

❗️ Next.js 같은 SSR 프레임워크를 사용하는 것이 더 효율적

npm run eject : CRA 내부에 있는 추상화된 Webpack, Babel 등 설정 파일들 을 프로젝트 밖으로 꺼내서 직접 수정 가능하도록 하는 작업

❗️오류 발생

npx create-react-app react-app 으로 설치 중 오류 발생하여 설치가 되지 않음 해결 방법

1. npm 캐시 클리어 npm cache clean --force
2. npx 캐시 디렉토리 삭제 rm -rf ~/.npm/_npx 후 다시 실행 시 Happy Hacking! 뜨면 설치 성공

최단 경로 알고리즘 유형

• Dijkstra 알고리즘 : 단일 최단 경로 최소 비용 산출
• A* 알고리즘 : 휴리스틱 방법 사용한 탐색
• Bellman-Ford 알고리즘 : 음수 가중치 허용한 비용 산출
• Floyd-Warshall : 동적 계획법 기반 고차원 기법

Dijkstra 알고리즘

그래프에서 출발점과 도착점 사이의 최단 거리를 구하는 알고리즘

보통 단일 정점 간 최단 경로 산출 시 사용, 도로 교통망이나 OSPF 등의 네트워크 라우팅 프로토콜에 널리 이용

구현 메서드(method)

• 정점/간선 추가 : ShortestPath.addVertex() , ShortestPath.addEdge()
• 다익스트라 알고리즘 : ShortestPath._extractMin() , ShortestPath.dijkstra()

// shortestPath() : edge object 객체 저장을 위한 생성자
// key : vertex
// value : list 형태로 연결된 vertex를 표현하여 edge 연결

function ShortestPath() {
  this.edges = {};
}

// addVertex() : 정점 추가(간성 비용 표시를 위해 object 형태로 저장)
ShortestPath.prototype.addVertex = function (vertex) {
  this.edges[vertex] = {};
};

// addEdge : 간선 추가
ShortestPath.prototype.addEdge = function (srcVertex, dstVertex, weight) {
  this.edges[srcVertex][dstVertex] = weight;
};

// _extractMin() : 최단 거리 노드 탐색
ShortestPath.prototype._extractMin = function (queue, dist) {
  let minDistance = Number.POSITIVE_INFINITY;
  let minVertex = null;

  for (let vertex in queue) {
    if (dist[vertex] <= minDistance) {
      minDistance = dist[vertex];
      minVertex = vertex;
    }
  }
  return minVertex;
};

// dijkstra() : 다익스트라 최단 경로 탐색
ShortestPath.prototype.dijkstra = function (start) {
  let queue = {};
  let dist = {};

  for (let vertex in this.edges) {
    dist[vertex] = Number.POSITIVE_INFINITY;
    queue[vertex] = this.edges[vertex]; // edge에 연결되어 있는 간선 정보까지 넣어준다
  }

  dist[start] = 0;
  while (Object.keys(queue).length != 0) {
    let u = this._extractMin(queue, dist);
    delete queue[u];
    for (let neighbor in this.edges[u]) {
      let alt = dist[u] + this.edges[u][neighbor];
      if (alt < dist[neighbor]) dist[neighbor] = alt;
    }
  }

  for (let vertex in this.edges) {
    if (dist[vertex] === Number.POSITIVE_INFINITY) delete dist[vertex];
  }

  return dist;
};

let path = new ShortestPath();
path.addVertex("A");
path.addVertex("B");
path.addVertex("C");
path.addVertex("D");
path.addVertex("E");

path.addEdge("A", "B", 10);
path.addEdge("A", "C", 3);
path.addEdge("B", "C", 1);
path.addEdge("B", "D", 2);
path.addEdge("C", "B", 4);
path.addEdge("C", "D", 8);
path.addEdge("C", "E", 2);
path.addEdge("D", "E", 7);
path.addEdge("E", "D", 9);

console.log(path);
console.log(path.dijkstra("A"));
console.log(path.dijkstra("B"));
console.log(path.dijkstra("C"));

-----------------------------------------------------------
OUTPUT
ShortestPath {
  edges: {
    A: { B: 10, C: 3 },
    B: { C: 1, D: 2 },
    C: { B: 4, D: 8, E: 2 },
    D: { E: 7 },
    E: { D: 9 }
  }
}
{ A: 0, B: 7, C: 3, D: 9, E: 5 }
{ B: 0, C: 1, D: 2, E: 3 }
{ B: 4, C: 0, D: 6, E: 2 }

Floyd-Warshall 알고리즘

동적 계획법을 활용해, 그래프에서 가능한 모든 정점 쌍에 대해 최단 거리를 구하는 알고리즘

음의 가중치가 있어도 사용 가능하며, 만은 수의 간선으로 이루어져 있는 밀집 그래프(Dense Graph)에 사용 적합

• 2차원 Object 형태로 만든다

구현 메서드(method)

• 정점/간선 추가 : ShortestPath.addVertex() , ShortestPath.addEdge()
• 다익스트라 알고리즘 : ShortestPath.floydWarshall()

// shortestPath() : edge object 객체 저장을 위한 생성자
// key : vertex
// value : list 형태로 연결된 vertex를 표현하여 edge 연결

function ShortestPath() {
  this.edges = {};
}

// addVertex() : 정점 추가(간성 비용 표시를 위해 object 형태로 저장)
ShortestPath.prototype.addVertex = function (vertex) {
  this.edges[vertex] = {};
};

// addEdge : 간선 추가
ShortestPath.prototype.addEdge = function (srcVertex, dstVertex, weight) {
  this.edges[srcVertex][dstVertex] = weight;
};

// _extractMin() : 최단 거리 노드 탐색
ShortestPath.prototype._extractMin = function (queue, dist) {
  let minDistance = Number.POSITIVE_INFINITY;
  let minVertex = null;

  for (let vertex in queue) {
    if (dist[vertex] <= minDistance) {
      minDistance = dist[vertex];
      minVertex = vertex;
    }
  }
  return minVertex;
};

// floydWarshell() : 플로이드-워셜 최단 경로 탐색
ShortestPath.prototype.floydWarshall = function () {
  let dist = {};
  for (let srcVertex in this.edges) {
    dist[srcVertex] = {};
    for (let dstVertex in this.edges) {
      if (srcVertex === dstVertex) dist[srcVertex][dstVertex] = 0;
      else dist[srcVertex][dstVertex] = Number.POSITIVE_INFINITY;
    }
  }

  for (let srcVertex in this.edges) {
    for (let dstVertex in this.edges[srcVertex]) {
      dist[srcVertex][dstVertex] = this.edges[srcVertex][dstVertex];
    }
  }

  // 업데이트 되는 부분
  for (let minVertex in this.edges) {
    for (let srcVertex in this.edges) {
      for (let dstVertex in this.edges) {
        dist[srcVertex][dstVertex] = Math.min(
          dist[srcVertex][dstVertex],
          dist[srcVertex][minVertex] + dist[minVertex][dstVertex]
        );
      }
    }
  }

  for (let srcVertex in this.edges) {
    for (let dstVertex in this.edges) {
      if (dist[srcVertex][dstVertex] === Number.POSITIVE_INFINITY)
        delete dist[srcVertex][dstVertex];
    }
  }

  return dist;
};

let path = new ShortestPath();
path.addVertex("A");
path.addVertex("B");
path.addVertex("C");
path.addVertex("D");
path.addVertex("E");

path.addEdge("A", "B", 10);
path.addEdge("A", "C", 3);
path.addEdge("B", "C", 1);
path.addEdge("B", "D", 2);
path.addEdge("C", "B", 4);
path.addEdge("C", "D", 8);
path.addEdge("C", "E", 2);
path.addEdge("D", "E", 7);
path.addEdge("E", "D", 9);

console.log(path);
console.log(path.floydWarshall());

-----------------------------------------------------------
OUTPUT
ShortestPath {
  edges: {
    A: { B: 10, C: 3 },
    B: { C: 1, D: 2 },
    C: { B: 4, D: 8, E: 2 },
    D: { E: 7 },
    E: { D: 9 }
  }
}
{
  A: { A: 0, B: 7, C: 3, D: 9, E: 5 },
  B: { B: 0, C: 1, D: 2, E: 3 },
  C: { B: 4, C: 0, D: 6, E: 2 },
  D: { D: 0, E: 7 },
  E: { D: 9, E: 0 }
}

힙 대표 속성

• 정렬 : 각 노드의 값은 자식 노드가 가진 값보다 작거나 혹은 큰 순서대로 정렬
• 형태 : 트리의 형태는 완전이진트리(complete binary tree) 모양

힙 종류

• 최소 힙(Min Heap) : 부모 노드의 값이 자식 노드의 값보다, 작거나 같은 완전 이진 트리
• 최대 힙(Max Heap) : 부모 노드의 값이 자식 노드의 값보다, 크거나 같은 완전 이진 트리

힙 구현

• 완전 이진 트리 성질을 만족하기 때문에 1차원 배열로 표현 가능
• 현재 노드 : N, 부모 노드 : (N-1)/2, 왼쪽 자식 노드 : (N2)+1, 오른쪽 자식 노드 : (N2)+2

구현 메서드(method)

• 노드 위치 계산 : Heap.parentIndex(), Heap.leftChildIndex(), Heap.rightChildIndex()
• 노드 값 확인 : Heap.parent(), Heap.leftChild(), Heap.rightChild()
• 노드 추가/삭제(추출) : Heap.insert(), Heap.bubbleUp(), Heap.extract(), Heap.bubbleDown()

최소힙

// 최소 힙(MinHeap)
// Heap() : 배열 내 요소를 저장하기 위한 생성자
function Heap() {
  this.items = [];
}

// swap() : 배열 내 두 요소 위치 변경
Heap.prototype.swap = function (index1, index2) {
  let tmp = this.items[index1];
  this.items[index1] = this.items[index2];
  this.items[index2] = tmp;
};

// parentIndex() : 부모 노드의 위치 반환
Heap.prototype.parentIndex = function (index) {
  return Math.floor((index - 1) / 2);
};

// leftChildIndex() : 왼쪽 자식 노드의 위치 반환
Heap.prototype.leftChildIndex = function (index) {
  return index * 2 + 1;
};

// rightChildIndex() : 오른쪽 자식 노드의 위치 반환
Heap.prototype.rightChildIndex = function (index) {
  return index * 2 + 2;
};

// parent() : 부모 노드의 요소값 반환
Heap.prototype.parent = function (index) {
  return this.items[this.parentIndex(index)];
};

// leftChild() : 왼쪽 자식 노드의 요소 값 반환
Heap.prototype.leftChild = function (index) {
  return this.items[this.leftChildIndex(index)];
};

// rightChild() : 오른족 자식 노드의 요소 값 반환
Heap.prototype.rightChild = function (index) {
  return this.items[this.rightChildIndex(index)];
};

// peak() : 현재 정렬된 최소/최대 요소값 반환
Heap.prototype.peak = function () {
  return this.items[0];
};

// size() : 현재 배열 내 크기 반환
Heap.prototype.size = function () {
  return this.items.length;
};

// insert() : 신규 노드 추가
Heap.prototype.insert = function (item) {
  this.items[this.size()] = item;
  this.bubbleUp();
};

// bubbleUp() : 추가된 노드 위치 정렬
Heap.prototype.bubbleUp = function () {
  let index = this.size() - 1;
  // 부모 노드와 비교하면서 정렬
  // 부모가 있는지부터 확인
  while (this.parent(index) && this.parent(index) > this.items[index]) {
    this.swap(this.parentIndex(index), index);
    index = this.parentIndex(index);
  }
};

// extract() : root 노드 반환 및 삭제
Heap.prototype.extract = function () {
  let item = this.items[0];
  this.items[0] = this.items[this.size() - 1];
  this.items.pop(); // 배열의 마지막 요소를 없애 준다.
  this.bubbleDown();
  return item;
};

// bubbleDown() : 대체된 root 노드 위치 정렬 -> 위에서 부터 수행(root 부터) -> 내려가면서 왼쪽 오른쪽 노드 둘다 확인
Heap.prototype.bubbleDown = function () {
  let index = 0;
  while (
    this.leftChild(index) &&
    (this.leftChild(index) < this.items[index] ||
      this.rightChild(index) < this.items[index])
  ) {
    let childIndex = this.leftChildIndex(index);
    if (
      this.rightChild(index) &&
      this.rightChild(index) < this.items[childIndex]
    ) {
      childIndex = this.rightChildIndex(index);
    }
    this.swap(childIndex, index);
    index = childIndex;
  }
};

let minHeap = new Heap();
minHeap.insert(90);
minHeap.insert(15);
minHeap.insert(10);
minHeap.insert(7);
minHeap.insert(12);
minHeap.insert(2);
minHeap.insert(8);
minHeap.insert(3);
// console.log(minHeap);
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
// console.log(minHeap);

----------------------------------------------------------
OUTPUT
2
3
7
8
10
12
15
90

최대값

최소값 bubbleUp(), bubbleDown() 코드에 있는 조건문의 부등호를 반대로 바꾸면 된다

// 최대 힙(MaxHeap)
// Heap() : 배열 내 요소를 저장하기 위한 생성자
function Heap() {
  this.items = [];
}

// swap() : 배열 내 두 요소 위치 변경
Heap.prototype.swap = function (index1, index2) {
  let tmp = this.items[index1];
  this.items[index1] = this.items[index2];
  this.items[index2] = tmp;
};

// parentIndex() : 부모 노드의 위치 반환
Heap.prototype.parentIndex = function (index) {
  return Math.floor((index - 1) / 2);
};

// leftChildIndex() : 왼쪽 자식 노드의 위치 반환
Heap.prototype.leftChildIndex = function (index) {
  return index * 2 + 1;
};

// rightChildIndex() : 오른쪽 자식 노드의 위치 반환
Heap.prototype.rightChildIndex = function (index) {
  return index * 2 + 2;
};

// parent() : 부모 노드의 요소값 반환
Heap.prototype.parent = function (index) {
  return this.items[this.parentIndex(index)];
};

// leftChild() : 왼쪽 자식 노드의 요소 값 반환
Heap.prototype.leftChild = function (index) {
  return this.items[this.leftChildIndex(index)];
};

// rightChild() : 오른족 자식 노드의 요소 값 반환
Heap.prototype.rightChild = function (index) {
  return this.items[this.rightChildIndex(index)];
};

// peak() : 현재 정렬된 최소/최대 요소값 반환
Heap.prototype.peak = function () {
  return this.items[0];
};

// size() : 현재 배열 내 크기 반환
Heap.prototype.size = function () {
  return this.items.length;
};

// insert() : 신규 노드 추가
Heap.prototype.insert = function (item) {
  this.items[this.size()] = item;
  this.bubbleUp();
};

// bubbleUp() : 추가된 노드 위치 정렬
Heap.prototype.bubbleUp = function () {
  let index = this.size() - 1;
  // 부모 노드와 비교하면서 정렬
  // 부모가 있는지부터 확인
  while (this.parent(index) && this.parent(index) < this.items[index]) {
    this.swap(this.parentIndex(index), index);
    index = this.parentIndex(index);
  }
};

// extract() : root 노드 반환 및 삭제
Heap.prototype.extract = function () {
  let item = this.items[0];
  this.items[0] = this.items[this.size() - 1];
  this.items.pop(); // 배열의 마지막 요소를 없애 준다.
  this.bubbleDown();
  return item;
};

// bubbleDown() : 대체된 root 노드 위치 정렬 -> 위에서 부터 수행(root 부터) -> 내려가면서 왼쪽 오른쪽 노드 둘다 확인
Heap.prototype.bubbleDown = function () {
  let index = 0;
  while (
    this.leftChild(index) &&
    (this.leftChild(index) > this.items[index] ||
      this.rightChild(index) > this.items[index])
  ) {
    let childIndex = this.leftChildIndex(index);
    if (
      this.rightChild(index) &&
      this.rightChild(index) > this.items[childIndex]
    ) {
      childIndex = this.rightChildIndex(index);
    }
    this.swap(childIndex, index);
    index = childIndex;
  }
};

let minHeap = new Heap();
minHeap.insert(90);
minHeap.insert(15);
minHeap.insert(10);
minHeap.insert(7);
minHeap.insert(12);
minHeap.insert(2);
minHeap.insert(8);
minHeap.insert(3);
// console.log(minHeap);
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
console.log(minHeap.extract());
// console.log(minHeap);

----------------------------------------------------------
OUTPUT
90
15
12
10
8
7
3
2

트리나 그래프 등에서 하나의 노드를 최대한 깊게 들어가면서 해를 찾는 탐색 기법

장점

인접한 후보 노드만 기억하면 되므로 적은 기억공간 소요

노트가 깊은 단계에 있을 경우 빠르게 정답 산출

단점

선택한 경로가 답이 아닐 경우 불필요한 탐색 가능

최단 경로 구할 시 찾은 해가 정답이 아닐 경우 발생 ⇒ BFS

구현 메서드(method)

• 재귀를 이용한 탐색 : Graph.dfsRecursiveVisit()

function Graph() {
  this.edge = {};
  this.visited = {};
}

// addVertex() : 정점(vertex) 추가
Graph.prototype.addVertex = function (v) {
  this.edge[v] = [];
  this.visited[v] = false;
};

// addEdge() : 간선(edge) 추가
Graph.prototype.addEdge = function (v1, v2) {
  this.edge[v1].push(v2); // v1 -> v2
};

// print() : 현재 Graph에 연결 상태 출력
Graph.prototype.print = function () {
  for (let vertex in this.edge) {
    let neighbors = this.edge[vertex];
    if (neighbors.length === 0) continue;
    process.stdout.write(`${vertex} -> `);

    for (let j = 0; j < neighbors.length; j++) {
      process.stdout.write(`${neighbors[j]} `);
    }
    console.log("");
  }
};

//dfs() : DFS 탐색
Graph.prototype.dfs = function (startVertex) {
  this._dfsRecursiveVisit(startVertex);
};

//_dfsRecursiveVisit() : 재귀를 이용한 DFS 탐색
Graph.prototype._dfsRecursiveVisit = function (vertex) {
  // 1. 종료 조건

  if (this.visited[vertex]) {
    return;
  }

  // 2. 재귀 호출을 하면서 수행해야할 코드
  this.visited[vertex] = true;
  console.log(`visit "${vertex}"`);

  let neighbors = this.edge[vertex];
  for (let i = 0; i < neighbors.length; i++) {
    this._dfsRecursiveVisit(neighbors[i]);
  }
};

let graph = new Graph();
let vertices = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < vertices.length; i++) {
  graph.addVertex(vertices[i]);
}

graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");
graph.print();
console.log("");

graph.dfs("A");

------------------------------------------------------------------------
OUTPUT
A -> B C D 
B -> E F 
C -> G 
D -> G H 
E -> I 

visit "A"
visit "B"
visit "E"
visit "I"
visit "F"
visit "C"
visit "G"
visit "D"
visit "H"

• 스택을 이용한 탐색 : Graph.dfsLoopVisit()

import { Stack } from "./stack3.mjs";
function Graph() {
  this.edge = {};
  this.visited = {};
}

// addVertex() : 정점(vertex) 추가
Graph.prototype.addVertex = function (v) {
  this.edge[v] = [];
  this.visited[v] = false;
};

// addEdge() : 간선(edge) 추가
Graph.prototype.addEdge = function (v1, v2) {
  this.edge[v1].push(v2); // v1 -> v2
};

// print() : 현재 Graph에 연결 상태 출력
Graph.prototype.print = function () {
  for (let vertex in this.edge) {
    let neighbors = this.edge[vertex];
    if (neighbors.length === 0) continue;
    process.stdout.write(`${vertex} -> `);

    for (let j = 0; j < neighbors.length; j++) {
      process.stdout.write(`${neighbors[j]} `);
    }
    console.log("");
  }
};

//dfs() : DFS 탐색
Graph.prototype.dfs = function (startVertex) {
  this._dfsLoopVisit(startVertex);
};

//_dfsLoopVisit() : 스택를 이용한 DFS 탐색
Graph.prototype._dfsLoopVisit = function (vertex) {
  let stack = new Stack();
  stack.push(vertex);

  // 스택이 빌때까지 반복
  while (!stack.isEmpty()) {
    let vertex = stack.pop();
    // 방문했는지 확인
    if (this.visited[vertex]) {
      continue;
    }
    this.visited[vertex] = true;
    console.log(`visit "${vertex}"`);

    let neighbors = this.edge[vertex];
    for (let i = neighbors.length - 1; i >= 0; i--) {
      stack.push(neighbors[i]);
    }
  }
};

let graph = new Graph();
let vertices = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < vertices.length; i++) {
  graph.addVertex(vertices[i]);
}

graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");
graph.print();
console.log("");

graph.dfs("A");

------------------------------------------------------------------------
OUTPUT
A -> B C D 
B -> E F 
C -> G 
D -> G H 
E -> I 

visit "A"
visit "B"
visit "E"
visit "I"
visit "F"
visit "C"
visit "G"
visit "D"
visit "H"

BFS(Breadth First Search) : 너비 우선 탐색

트리나 그래프 등에서 인접한 노드를 우선 방문하면서 넓게 움직이며 해를 찾는 탐색 기법

장점

• 최단 경로 탐색에서 구한 해가 정답임을 보장

단점

• 경로가 매우 길어질 경우, 탐색 범위가 증가하면서 DFS보다 많은 기억 공간이 필요

구현 메서드(method)

• 큐를 이용한 탐색 : Graph.bfs() , Graph._bfsLoopVisit()

import { Queue } from "./queue3.mjs";

function Graph() {
  this.edge = {};
  this.visited = {};
}

// addVertex() : 정점(vertex) 추가
Graph.prototype.addVertex = function (v) {
  this.edge[v] = [];
  this.visited[v] = false;
};

// addEdge() : 간선(edge) 추가
Graph.prototype.addEdge = function (v1, v2) {
  this.edge[v1].push(v2); // v1 -> v2
};

// print() : 현재 Graph에 연결 상태 출력
Graph.prototype.print = function () {
  for (let vertex in this.edge) {
    let neighbors = this.edge[vertex];
    if (neighbors.length === 0) continue;
    process.stdout.write(`${vertex} -> `);

    for (let j = 0; j < neighbors.length; j++) {
      process.stdout.write(`${neighbors[j]} `);
    }
    console.log("");
  }
};

// bfs() : BFS 탐색
Graph.prototype.bfs = function (startVertex) {
  this._bfsLoopVisit(startVertex);
};

// _bfsLoopVisit() : 큐를 이용한 BFS 탐색
Graph.prototype._bfsLoopVisit = function (vertex) {
  let queue = new Queue();
  queue.enqueue(vertex);

  while (!queue.isEmpty()) {
    let vertex = queue.dequeue();
    if (this.visited[vertex]) {
      continue;
    }

    this.visited[vertex] = true;
    console.log(`visit "${vertex}"`);

    let neighbors = this.edge[vertex];
    for (let i = 0; i < neighbors.length; i++) {
      queue.enqueue(neighbors[i]);
    }
  }
};

let graph = new Graph();
let vertices = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < vertices.length; i++) {
  graph.addVertex(vertices[i]);
}

graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");
graph.print();
console.log("");

graph.bfs("A");

------------------------------------------------------------------------
OUTPUT
A -> B C D 
B -> E F 
C -> G 
D -> G H 
E -> I 

visit "A"
visit "B"
visit "C"
visit "D"
visit "E"
visit "F"
visit "G"
visit "H"
visit "I"

• 최단 경로 탐색 : Graph.shortestPath() , Graph._bfsShortestPath() , Graph._from_to_path()

import { Queue } from "./queue3.mjs";
import { Stack } from "./stack3.mjs";

function Graph() {
  this.edge = {};
  this.visited = {};
}

// addVertex() : 정점(vertex) 추가
Graph.prototype.addVertex = function (v) {
  this.edge[v] = [];
  this.visited[v] = false;
};

// addEdge() : 간선(edge) 추가
Graph.prototype.addEdge = function (v1, v2) {
  this.edge[v1].push(v2); // v1 -> v2
};

// print() : 현재 Graph에 연결 상태 출력
Graph.prototype.print = function () {
  for (let vertex in this.edge) {
    let neighbors = this.edge[vertex];
    if (neighbors.length === 0) continue;
    process.stdout.write(`${vertex} -> `);

    for (let j = 0; j < neighbors.length; j++) {
      process.stdout.write(`${neighbors[j]} `);
    }
    console.log("");
  }
};

// bfs() : BFS 탐색
Graph.prototype.bfs = function (startVertex) {
  this._bfsLoopVisit(startVertex);
};

// _bfsLoopVisit() : 큐를 이용한 BFS 탐색
Graph.prototype._bfsLoopVisit = function (vertex) {
  let queue = new Queue();
  queue.enqueue(vertex);

  while (!queue.isEmpty()) {
    let vertex = queue.dequeue();
    if (this.visited[vertex]) {
      continue;
    }

    this.visited[vertex] = true;
    console.log(`visit "${vertex}"`);

    let neighbors = this.edge[vertex];
    for (let i = 0; i < neighbors.length; i++) {
      queue.enqueue(neighbors[i]);
    }
  }
};

// _bfsShortestPath() : 다른 정점 간 최단 경로 비용 산출
Graph.prototype._bfsShortestPath = function (vertex) {
  let queue = new Queue();
  queue.enqueue(vertex);

  let distance = {};
  let pre_visit = {};
  for (let vertex in this.edge) {
    distance[vertex] = 0;
    pre_visit[vertex] = null;
  }

  while (!queue.isEmpty()) {
    let vertex = queue.dequeue();

    this.visited[vertex] = true;
    console.log(`visit "${vertex}"`);

    let neighbors = this.edge[vertex];
    for (let i = 0; i < neighbors.length; i++) {
      if (!this.visited[neighbors[i]]) {
        distance[neighbors[i]] = distance[vertex] + 1;
        pre_visit[neighbors[i]] = vertex;
        queue.enqueue(neighbors[i]);
      }
    }
  }

  return { distance, pre_visit };
};

// _from_to_path() : from 정점에서 to 정점으로 최단 경로 출력
Graph.prototype._from_to_path = function (pre_visit, from, to) {
  let stack = new Stack();

  for (let v = to; v !== from; v = pre_visit[v]) {
    stack.push(v);
  }
  stack.push(from);

  while (!stack.isEmpty()) {
    let v = stack.pop();
    process.stdout.write(`${v} => `);
  }
  console.log("end");
};

// shortestPath() : 다른 정점 간 최단 경로 탐색
Graph.prototype.shortestPath = function (startVertex) {
  let result = this._bfsShortestPath(startVertex);

  console.log(result.distance);
  console.log(result.pre_visit);

  for (let vertex in this.edge) {
    if (vertex === startVertex) continue;
    this._from_to_path(result.pre_visit, startVertex, vertex);
  }
};

let graph = new Graph();
let vertices = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < vertices.length; i++) {
  graph.addVertex(vertices[i]);
}

graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");
graph.print();
console.log("");

graph.shortestPath("A");

------------------------------------------------------------------------
OUTPUT
A -> B C D 
B -> E F 
C -> G 
D -> G H 
E -> I 

visit "A"
visit "B"
visit "C"
visit "D"
visit "E"
visit "F"
visit "G"
visit "G"
visit "H"
visit "I"
{ A: 0, B: 1, C: 1, D: 1, E: 2, F: 2, G: 2, H: 2, I: 3 }
{
  A: null,
  B: 'A',
  C: 'A',
  D: 'A',
  E: 'B',
  F: 'B',
  G: 'D',
  H: 'D',
  I: 'E'
}
A => B => end
A => C => end
A => D => end
A => B => E => end
A => B => F => end
A => D => G => end
A => D => H => end
A => B => E => I => end

트리의 구조 및 용어

• 노드 (node) : 하나 이상의 값을 갖는 객체 단위

• 간선(Edge) : 두 노드를 연결하는 선

• 루트 노드(Root Node) : 부모가 없는 최상위 노트 → 시작 위치

• 단말 노드(Leaf Node) : 자식이 없는 노드

• 부모 노트(Parent node) : 특정 Sub-Tree 내에서 상위 노드

• 자식 노트(Child node) : 특정 Sub-Tree 내에서의 하위 노트

  • Sub-Tree : Parent node - Child node 를 묶음(표에서 5, 3, 6의 묶음을 말한다)

• 형제(Sibling) : 부모가 없는 최상위 노드

트리 특징

주요 특징

‘최소 연결 트리’로 불림, 계층 모델, 방향 비순환 그래프(DAG: Directed Acyclic Graph) 한 종류

트리 종류

• 이진 트리
• 이진 탐색 트리
• AVL 트리
• 힙(Heap)
• 노트 크기(Size) : 자신을 포함한 모든 자손 노드의 개수
• 노드 깊이(Depth) : 루트에서 특정 노드에 도달하기 위한 간선의 개수
• 노드 레벨(level) : 트리의 특정 깊이를 가지는 노드의 집합 → 루트 기준으로 Level 0인 경우도 있다.
• 노드 차수(degree) : 노드가 지닌 가지의 수
• 트리 차수(tree degree) : 트리의 최대 차수
• 트리 높이(height) : 루트 노드에서 가장 깊숙이 있는 노드의 깊이

트리 순회

트리 구조에서 각각의 노드를 정확히 한 번씩 체계적인 방법으로 방문하는 과정

필요 용어

• N(Node) : 해당 노드를 방문
• L(Left) : 왼쪽 서브 트리로 이동
• R(Right) : 오른쪽 서브 트리로 이동

순회 방식

• 전위 순회 (Pre-order) : N - L - R
• 중위 순회 (In-order) : L - N - R
• 후위 순회 (Post-order) : L - R - N
• 층별 순회 (Level-order) : 낮은 Level부터 순차적으로 순회(Level 0 → Level N)

전위 순회(Pre-order)

• 전위 순회 방법 : N - L - R
  1. 노드를 방문
  2. 왼쪽 서브 트리를 전위 순회
  3. 오른쪽 서브 트리를 전위 순회
• 방문 순서 : F → B → A → D → C → E → G → I → H
• 의사 코드(pseudo-code)

preorder(node)
print node.value
if node.left != null then preoder(node.left)
if node.right != null then preoder(node.right)

중위 순회(In-order)

• 중위 순회 방법 : L - N - R
  1. 왼쪽 서브 트리를 중위 순회
  2. 현재 노드를 방문
  3. 오른쪽 서브 트리를 중위 순회
• 방문 순서 : A → B → C → D → E → F → G → H → I
• 의사 코드(pseudo-code)

inorder(node)
if node.left != null then inorder(node.left)
print node.value
if node.right != null then inorder(node.right)

층별 순회(Level-order)

• 층별 순회 방법 : 낮은 Level부터 순차적으로 순회(Level 0 → Level N)
  1. root 노드 방문
  2. Level 증가
  3. 왼쪽에서 오른쪽 순으로 방문
• 방문 순서 : F → B → G → A → D → I → C → E → H
• 의사 코드(pseudo-code)

levelorder(node)
q.enqueue(root)
while noe q.empty do
    node := q.denqueue()
    print node.value
    if node.left != null then enqueue(node.left)
    if node.right != null then enqueue(node.right)

후위 순회(Post-order)

• 후위 순회 방법 : L - R - N
  1. 왼쪽 서브 트리를 후위 순회
  2. 오른쪽 서브 트리를 후위 순회
  3. 현재 노드 방문
• 방문 순서 : A → C→ E → D → B → H→ I → G → F
• 의사 코드(pseudo-code)

postorder(node)
if node.left != null then postorder(node.left)
if node.right != null then postorder(node.right)
print node.value

• 임의의 길이의 데이터를 고정된 길이의 데이터로 매핑하는 함수
• 해시 함수 특성
  • 압축성 : 다양한 가변 길이의 입력에 대해 고정된 크기의 결과값을 반환하는 성질
  • 효율성 : 어떤 입력 값에 대해서도 많은 자원과 시간이 소요되지 않고 처리되는 성질
  • 저항성 : 결과값을 바탕으로 입력 값을 찾는 것이 불가능한 성질

해시테이블(Hash Table)

• Hash 함수를 사용하여 평균 O(1) 시간 복잡도로 특정 값을 신속하게 찾는 자료구조
• 충돌(Collision) 해결 방법
  • 해시 함수 변경 : 더 큰 숫자의 공간과 Modulat 산술 값을 이용해 충돌 최소화
  • 자료 구조 확장 : Open Addressing Method (선형 조사법, 이중해시), Close Adreesing Method(체이닝)
• 구현 메서드(Method)

  // 배열에 대한 크기 지정
  const HASH_SIZE = 37;
  

// Element() : Key, Value 저장을 위한 생성자 function Element(key, value) { this.key = key; this.value = value; }

// HashTable() : 생성자 function HashTable() { this.table = new Array(HASH_SIZE); this.length = 0; }

// hashCode() : 해시 함수 HashTable.prototype.hashCode = function (key) { let hash = 0; for (let i = 0; i < key.length; i++) { // 누적 저장 hash += key.charCodeAt(i); }

return hash % HASH_SIZE; // 37이내의 숫자로 변환 };

let ht = new HashTable(); console.log(ht);

console.log(ht.hashCode("Ana")); console.log(ht.hashCode("Sue")); console.log(ht.hashCode("Paul"));

OUTPUT HashTable { table: [ <37 empty items> ], length: 0 } 13 5 32

- 객체 초기화 : `HashTable.clear()`
- 객체 크기 반환 : `HashTable.size()`
- 전체 데이터 반환 : `HashTable.getBuffer()`
- 전체 데이터 출력 : `HashTable.print()`

// 배열에 대한 크기 지정 const HASH_SIZE = 37;

// Element() : Key, Value 저장을 위한 생성자 function Element(key, value) { this.key = key; this.value = value; }

// HashTable() : 생성자 function HashTable() { this.table = new Array(HASH_SIZE); this.length = 0; }

// hashCode() : 해시 함수 HashTable.prototype.hashCode = function (key) { let hash = 0; for (let i = 0; i < key.length; i++) { // 누적 저장 hash += key.charCodeAt(i); }

return hash % HASH_SIZE; // 인덱스 값으로 사용 };

// clear() : 초기화 HashTable.prototype.clear = function () { this.table = new Array(HASH_SIZE); this.length = 0; };

// size() : 크기 변환 HashTable.prototype.size = function () { return this.length; };

// getBuffer() : 데이터 셋 반환 HashTable.prototype.getBuffer = function () { let array = []; for (let i = 0; i < this.table.length; i++) { if (this.table[i]) { array.push(this.table[i]); } }

return array; };

// print() : 데이터 셋 출력 HashTable.prototype.print = function () { for (let i = 0; i < this.table.length; i++) { if (this.table[i]) { console.log(i + " -> " + this.table[i].key + " : " + this.table[i].value); } } };

let ht = new HashTable();

ht.put("Ana", 172); ht.put("Sue", 163); ht.put("Paul", 190);

console.log(""); ht.print(); console.log(ht.getBuffer());

console.log(ht.size());

ht.clear(); console.log(ht);

OUTPUT key : Ana -> index : 13 key : Sue -> index : 5 key : Paul -> index : 32

5 -> Sue : 163 13 -> Ana : 172 32 -> Paul : 190 [ Element { key: 'Sue', value: 163 }, Element { key: 'Ana', value: 172 }, Element { key: 'Paul', value: 190 } ] 3 HashTable { table: [ <37 empty items> ], length: 0 }

- 데이터 추가 : `HashTable.put()`
- 데이터 삭제 : `HashTable.remove()`
- 데이터 반환 : `HashTable.get()`

// 배열에 대한 크기 지정 const HASH_SIZE = 37;

// Element() : Key, Value 저장을 위한 생성자 function Element(key, value) { this.key = key; this.value = value; }

// HashTable() : 생성자 function HashTable() { this.table = new Array(HASH_SIZE); this.length = 0; }

// hashCode() : 해시 함수 HashTable.prototype.hashCode = function (key) { let hash = 0; for (let i = 0; i < key.length; i++) { // 누적 저장 hash += key.charCodeAt(i); }

return hash % HASH_SIZE; // 인덱스 값으로 사용 };

// put() : 데이터 추가 HashTable.prototype.put = function (key, value) { let index = this.hashCode(key); console.log(key : ${key} -> index : ${index});

// 추가하려는 인덱스에 값이 있을 경우 if (this.table[index] !== undefined) { return false; }

// 값 추가 this.table[index] = new Element(key, value); this.length++;

return true; };

// get() : 데이터 조회 HashTable.prototype.get = function (key) { return this.table[this.hashCode(key)]; };

// remove() : 데이터 삭제 HashTable.prototype.remove = function (key) { let element = this.table[this.hashCode(key)];

// 값이 있을 경우 삭제 if (element !== undefined) { delete this.table[this.hashCode(key)]; this.length--; }

return element; };

let ht = new HashTable();

ht.put("Ana", 172); ht.put("Sue", 163); ht.put("Paul", 190);

console.log(ht);

console.log(ht.get("Paul")); console.log(ht.remove("Paul"));

console.log(ht.get("Paul")); console.log(ht.remove("Paul"));

console.log(ht);

OUTPUT key : Ana -> index : 13 key : Sue -> index : 5 key : Paul -> index : 32 → 각자 해당 인덱스 위치로 이동

HashTable { table: [ <5 empty items>, Element { key: 'Sue', value: 163 }, <7 empty items>, Element { key: 'Ana', value: 172 }, <18 empty items>, Element { key: 'Paul', value: 190 }, <4 empty items> ], length: 3 }

Element { key: 'Paul', value: 190 } Element { key: 'Paul', value: 190 }

undefined → Paul 을 지웠으니 undefined로 출력되는게 맞다. undefined → 지울 Paul이 없으니 undefined로 출력되는게 맞다.

HashTable { table: [ <5 empty items>, Element { key: 'Sue', value: 163 }, <7 empty items>, Element { key: 'Ana', value: 172 }, <23 empty items> ], length: 2 }

### 충돌 문제(use djb2)

![](https://velog.velcdn.com/images/frozen_land/post/bfd391cf-b341-49f2-bac0-68be3ee1b5e1/image.png)


인덱스 값이 중복되어 충돌 발생 → djb2 코드 사용하여 해결
```jsx
// djb2 hash size
const HASH_SIZE = 1013;

// Element() : Key, Value 저장을 위한 생성자
function Element(key, value) {
  this.key = key;
  this.value = value;
}

// HashTable() : 생성자
function HashTable() {
  this.table = new Array(HASH_SIZE);
  this.length = 0;
}

// hashCode() : 해시 함수
HashTable.prototype.hashCode = function (key) {
  // djb2 hash function
  let hash = 5381; // seed
  for (let i = 0; i < key.length; i++) {
    // 누적 저장
    hash = hash * 33 + key.charCodeAt(i);
  }

  return hash % HASH_SIZE; // 인덱스 값으로 사용
};

let ht = new HashTable();

ht.put("Ana", 172);
ht.put("Donnie", 183);
ht.put("Sue", 163);
ht.put("Jamie", 168);
ht.put("Paul", 190);

console.log("");
console.log(ht.size());
ht.print();

------------------------------------------------------------------------
OUTPUT
key : Ana -> index : 925
key : Donnie -> index : 278
key : Sue -> index : 502
key : Jamie -> index : 962
key : Paul -> index : 54

5
54 -> Paul : 190
278 -> Donnie : 183
502 -> Sue : 163
925 -> Ana : 172
962 -> Jamie : 168

• 우선순위를 고려하여 먼저 넣은 데이터가 먼저 나오는 FIFO(First In First Out) 기반의 선형 자료 구조

• 우선순위 정렬 방식 : 배열 기반, 연결리스트 기반, 힙(Heap) 기반 등의 정렬 방식 존재

• 구현 메서드 (method)

  • 데이터 전체 획득 : PriotiyQueue.getBuffer()

  • 데이터 비어있는지 확인 : PriotiyQueue.isEmpty()

    // Element() : 데이터와 우선수위를 저장하기 위한 생성자 함수
    function Element(data, priority) {
    this.data = data;
    this.priority = priority;
    }
    
    // priorityQueue() : Element 관리를 위한 생성자 함수
    function PriorityQueue() {
    this.array = [];
    }
    
    //getBuffer () : 객체 내 데이터 셋 반환
    PriorityQueue.prototype.getBuffer = function () {
    return this.array.map((element) => element.data);
    };
    
    //isEmpty() : 객체 내 데이터 존재 여부 파악
    PriorityQueue.prototype.isEmpty = function () {
    return this.array.length === 0;
    };
    
    console.log(Object.getOwnPropertyDescriptors(Element.prototype));
    console.log(Object.getOwnPropertyDescriptors(PriorityQueue.prototype));
    

  ---

  OUTPUT {

  constructor: {
    value: [Function: Element],
    writable: true,
    enumerable: false,
    configurable: true
  }

  } {

  constructor: {
    value: [Function: PriorityQueue],
    writable: true,
    enumerable: false,
    configurable: true
  },
  getBuffer: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  },
  isEmpty: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  }

  }

  
    - 데이터 추가 : `PriotiyQueue.enqueue()`
    - 데이터 삭제 : `PriotiyQueue.dequeue()`
  

  // Element() : 데이터와 우선수위를 저장하기 위한 생성자 함수 function Element(data, priority) {

  this.data = data;
  this.priority = priority;

  }

  // priorityQueue() : Element 관리를 위한 생성자 함수 function PriorityQueue() {

  this.array = [];

  }

  //getBuffer () : 객체 내 데이터 셋 반환 PriorityQueue.prototype.getBuffer = function () {

  return this.array.map((element) => element.data);

  };

  //isEmpty() : 객체 내 데이터 존재 여부 파악 PriorityQueue.prototype.isEmpty = function () {

  return this.array.length === 0;

  };

  // enqueue () : 데이터 추가 PriorityQueue.prototype.enqueue = function (data, priority) {

  let element = new Element(data, priority);
  let added = false;
  
  for (let i = 0; i < this.array.length; i++) {
    if (element.priority < this.array[i].priority) {
      this.array.splice(i, 0, element); // (i번째에, 삭제없이, element 추가)
      added = true;
      break;
    }
  }
  
  if (!added) {
    this.array.push(element);
  }
  
  return this.array.length;

  };

  // dequeue () : 데이터 삭제 PriorityQueue.prototype.dequeue = function () {

  return this.array.shift();

  };

  let pq = new PriorityQueue(); pq.enqueue("Alice", 1); pq.enqueue("bob", 2);

  console.log(pq);

  pq.enqueue("Tom", 1); pq.enqueue("John", 3);

  console.log(pq);

  console.log("dequeue : ", pq.dequeue()); console.log("dequeue : ", pq.dequeue());

  console.log(pq);

  ---

  OUTPUT PriorityQueue {

  array: [
    Element { data: 'Alice', priority: 1 },
    Element { data: 'bob', priority: 2 }
  ]

  } PriorityQueue {

  array: [
    Element { data: 'Alice', priority: 1 },
    Element { data: 'Tom', priority: 1 },
    Element { data: 'bob', priority: 2 },
    Element { data: 'John', priority: 3 }
  ]

  } dequeue : Element { data: 'Alice', priority: 1 } dequeue : Element { data: 'Tom', priority: 1 } PriorityQueue {

  array: [
    Element { data: 'bob', priority: 2 },
    Element { data: 'John', priority: 3 }
  ]

  }

  
    - 첫번째 데이터 : `PriotiyQueue.front()`
    - 데이터 사이즈 : `PriotiyQueue.size()`
    - 전체 삭제 : `PriotiyQueue.clear()`
  
    ```jsx
    // front() : 가장 첫 데이터 반환
    PriorityQueue.prototype.front = function () {
      return this.array.length === 0 ? undefined : this.array[0];
    };
    // size() : 큐 내 데이터 개수 확인
    PriorityQueue.prototype.size = function () {
      return this.array.length;
    };
    // clear() : 큐 초기화
    PriorityQueue.prototype.clear = function () {
      return (this.array = []);
    };

• 나중에 넣은 데이터가 먼저 나오는 LIFO(Last In First Out) 기반의 선형 자료 구조

• 구현 메서드(method)

  • 데이터 전체 획득 : Stack.getBuffer()

  • 비어있는지 확인 : Stack.isEmpty()

    // Stack() : 생성자 함수
    function Stack(array) {
    this.array = array ? array : [];
    }
    
    // getBuffer() : 객체 내 데이터 셋 반환 (값만 복사)
    Stack.prototype.getBuffer = function () {
    return this.array.slice();
    };
    // isEmpty() : 객체 내 데이터 O/X
    Stack.prototype.isEmpty = function () {
    return this.array.length === 0; // 비어있으면 O , 데이터가 있으면 X
    };
    
    let stack = new Stack([1, 2, 3]);
    console.log(stack);
    
    let data = stack.getBuffer();
    console.log(data);
    console.log(data === stack.array); 
    // ⬆️ 완벽하게 일치하였으면 true 지만 배열의 값만 복사해와서 다르므로 false
    console.log(stack.isEmpty());
    console.log(Object.getOwnPropertyDescriptors(Stack.prototype));
    

  ---

  OUTPUT Stack { array: [ 1, 2, 3 ] } [ 1, 2, 3 ] false ➡️ 완벽하게 일치하였으면 true 지만 배열의 값만 복사해와서 다르므로 False false {

  constructor: {
    value: [Function: Stack],
    writable: true,
    enumerable: false,
    configurable: true
  },
  getBuffer: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  },
  isEmpty: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  }

  }

  
    - 추가 : `Stack.push()`
    - 삭제 `Stack.pop()`
    - 마지막 데이터 조회 : `Stack.peak()`
    - 크기 확인 : `Stack.size()`
  
    ```jsx
    // Stack() : 생성자 함수
    function Stack(array) {
      this.array = array ? array : [];
    }
  
    // push() : 데이터 추가
    Stack.prototype.push = function (element) {
      return this.array.push(element);
    };
  
    // pop() : 데이터 삭제
    Stack.prototype.pop = function () {
      return this.array.pop();
    };
  
    //peak() : 가장 끝 데이터 반환
    Stack.prototype.peak = function () {
      return this.array[this.array.length - 1];
    };
  
    // size() : 스택 내 데이터 개수 확인
    Stack.prototype.size = function () {
      return this.array.length;
    };
  
    let stack = new Stack([1, 2]);
    console.log(stack);
    stack.push(3);
    console.log("push : ", stack);
    console.log("pop : ", stack.pop());
    console.log("pop : ", stack.pop());
    console.log("peak : ", stack.peak());
    console.log("size : ", stack.size());
    console.log(stack);
  
    ------------------------------------------------------------------------
    OUTPUT
    Stack { array: [ 1, 2 ] }
    push :  Stack { array: [ 1, 2, 3 ] }
    pop :  3
    pop :  2
    peak :  1
    size :  1
    Stack { array: [ 1 ] }

  • 데이터 위치 : Stack.indexOf()

  • 존재 여부 확인 : Stack.includes(

    // Stack() : 생성자 함수
    function Stack(array) {
    this.array = array ? array : [];
    }
    
    // indexOf() : 매개변수로 넘어온 element 위치 확인
    Stack.prototype.indexOf = function (element, position = 0) {
    for (let i = position; i < this.array.length; i++) {
      if (element === this.array[i]) return i;
    }
    return -1;
    // return this.array.indexOf(element, position);
    };
    
    // includes() : 데이터 존재 여부 확인
    Stack.prototype.includes = function (element, position = 0) {
    for (let i = position; i < this.array.length; i++) {
      if (element === this.array[i]) return true;
    }
    
    return false;
    };
    
    let stack = new Stack([1, 2, 3]);
    console.log("indexOf : ", stack.indexOf(1));
    console.log("indexOf : ", stack.indexOf(1, 2));
    console.log("includes : ", stack.includes(1));
    console.log("includes : ", stack.includes(1, 2));
    console.log("includes : ", stack.includes(5)); // 없는 값
    

  ---

  OUTPUT indexOf : 0 indexOf : -1 includes : true includes : false includes : false

큐(Queue)

• 먼저 넣은 데이터가 먼저 나오는 FIFO(First In First Out) 기반의 선형 자료 구조

• 구현 메서드(method)

  • 데이터 전체 획득 : Queue.getBuffer()

  • 데이터 비어 있는지 확인 : Queue.isEmpty()

    // Queue() : 생섬자 함수로 초기 데이터 설정
    function Queue(array) {
    this.array = array ? array : [];
    }
    
    // getBuffer() : 객체 내 데이터 셋 반환
    Queue.prototype.getBuffer = function () {
    return this.array.slice();
    };
    
    // isEmpty() : 객체 내 데이터 O/X
    Queue.prototype.isEmpty = function () {
    return this.array.length === 0;
    };
    
    let queue = new Queue([1, 2, 3]);
    console.log(queue);
    
    let data = queue.getBuffer();
    console.log(data);
    console.log(data === queue.array);
    console.log(queue.isEmpty());
    console.log(Object.getOwnPropertyDescriptors(Queue.prototype));
    

  ---

  OUTPUT Queue { array: [ 1, 2, 3 ] } [ 1, 2, 3 ] false false {

  constructor: {
    value: [Function: Queue],
    writable: true,
    enumerable: false,
    configurable: true
  },
  getBuffer: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  },
  isEmpty: {
    value: [Function (anonymous)],
    writable: true,
    enumerable: true,
    configurable: true
  }

  }

  
    - 데이터 추가 : `Queue.enqueue()`
    - 데이터 삭제 : `Queue.dequeue()`
  
    ```jsx
    // Queue() : 생섬자 함수로 초기 데이터 설정
    function Queue(array) {
      this.array = array ? array : [];
    }
  
    // enqueue() : 데이터 추가
    Queue.prototype.enqueue = function (element) {
      return this.array.push(element);
    };
    // dequeue() : 데이터 삭제
    Queue.prototype.dequeue = function () {
      return this.array.shift();
    };
  
    let queue = new Queue([1, 2, 3]);
    console.log(queue);
  
    queue.enqueue(3);
    queue.enqueue(4);
    console.log("enqueue : ", queue);
  
    queue.dequeue();
    console.log("dequeue : ", queue);
  
    ------------------------------------------------------------------------
    OUTPUT
    Queue { array: [ 1, 2, 3 ] }
    enqueue :  Queue { array: [ 1, 2, 3, 3, 4 ] }
    dequeue :  Queue { array: [ 2, 3, 3, 4 ] }

  • 첫번째 데이터 : Queue.front()

  • 데이터 사이즈 : Queue.size()

  • 전체 삭제 : Queue.clear()

    // Queue() : 생섬자 함수로 초기 데이터 설정
    function Queue(array) {
    this.array = array ? array : [];
    }
    
    // front() : 가장 첫 데이터 반환
    Queue.prototype.front = function () {
    return this.array.length === 0 ? undefined : this.array[0];
    };
    // size() : 큐 내 데이터 개수 확인
    Queue.prototype.size = function () {
    return this.array.length;
    };
    // clear() : 큐 초기화
    Queue.prototype.clear = function () {
    return (this.array = []);
    };
    
    let queue = new Queue([1, 2, 3, 4]);
    queue.dequeue();
    console.log("front : ", queue.front());
    console.log(queue); // 첫번째 데이터를 반환을 하고 배열 내에 삭제되지는 않음
    
    console.log("size : ", queue.size());
    queue.clear();
    console.log(queue);
    

  ---

  OUTPUT front : 2 Queue { array: [ 2, 3, 4 ] } size : 3 Queue { array: [] }

큐 최적화

• 방식 개선 : enqueue/dequeue 방식을 push/shift 에서 index 로 변경(shift는 O(n), index는 O(1))

// Queue() : 생섬자 함수로 초기 데이터 설정
function Queue(array) {
  this.array = array ? array : [];
  this.tail = array ? array.length : [];
  this.head = 0;
}

// enqueue() : 데이터 추가
Queue.prototype.enqueue = function (element) {
  // return this.array.push(element);
  return (this.array[this.tail++] = element);
};
// dequeue() : 데이터 삭제
Queue.prototype.dequeue = function () {
  if (this.tail === this.head) return undefined;

  let element = this.array[this.head];
  delete this.array[this.head++];

  return element;
};

let queue = new Queue([1, 2]);
console.log(queue);

queue.enqueue(3);
queue.enqueue(4);
console.log("enqueue : ", queue);

console.log(queue.dequeue());
console.log(queue.dequeue());
console.log("dequeue : ", queue);

------------------------------------------------------------------------
OUTPUT
Queue { array: [ 1, 2 ], tail: 2, head: 0 }
enqueue :  Queue { array: [ 1, 2, 3, 4 ], tail: 4, head: 0 }
1
2
dequeue :  Queue { array: [ <2 empty items>, 3, 4 ], tail: 4, head: 2 }

• 처음 작성한 enqueue, dequeue 보다 최적화된 코드가 수행이 더 빠르다.

• 어떠한 객체가 만들어지기 위해 객체의 모태가 되는 원형
• 자바스크립트는 일반적인 객체 지향 언어와는 다르게, 프로토타입을 이용한 복사(Cloning)을 통해 새로운 객체 생성
• 일반적인 객체 생성 방식 : 속성은 생성자, 메서드는 프로토타입에서 정의

// 생성자에서 속성 정의
function Test (a,b) {
    //속성 정의
}

// 첫 메소드 정의
Test.prototype.x = function() { ... };

// 두번째 메소드 정의
Test.prototype.y = function() { ... };

//객체 생성
let test = new Test(1,2);

예시

// 생성자에서 속성 정의
function Person (name, age) {
    //속성 정의
    this.name = name;
    this.age = age;
}

// prototype을 이용한 person 메서드 정의
Person.prototype.isAudlt = function() { 
    return this.age > 18;
 };

//객체 생성
const p1 = new Person("bob", 26);
const p2 = new Person("alice", 18);

console.log(p1)
console.log(p2)

console.log(p1.isAudlt());
console.log(p2.isAudlt());

--------------------------------------------
OUTPUT
Person { name: 'bob', age: 26 }
Person { name: 'alice', age: 18 }
true
false

연결 리스트(Linked List)

• 각 노드가 데이토와 포인터를 가지며, 한 줄로 연결되어 있는 방식으로 데이터를 저장하는 자료 구조

• 구현 메서드(method)

  • LinkedList() : head와 length를 가지고 있는 객체
  • 노드 개수 / 비어있는지 확인 / 노드 출력 :
    • LinkedList.size() : 연결 리스트 내 노드 개수 확인
    • LinkedList.isEmpty() : 객체 내 노드 존재 여부 파악(true/false)
    • LinkedList.printNode() : 노드 출력

  ---

  • 노드 추가
    • LinkedList.append() : 연결 리스트 가장 끝에 노드 추가
    • LinkedList.insert() : position 위치에 노드 추가
  • 노드 삭제
    • LinkedList.remove()` : value 데이터를 찾아 노드 삭제
    • LinkedList.removeAt() : position 위치 노드 삭제
  • 데이터 위치 확인
    • LinkedList.index() : value 값을 갖는 노드 위치 반환

• 맨 앞 Node = HEAD
• 맨 마지막 Node의 주소는 Null값이 들어간다

head → null → 노드1 생성

head → 생성한 노드1 → null → 노드 생성

head → 생성한 노드1 → 생성한 노드2 → null

작성한 코드

// Node() : data와 point를 가지고 있는 객체
function Node(data){
    this.data = data;
    this.next = null;
}

// LinkedList() : head와 length를 가지고 있는 객체
function LinkedList(){
    this.head = null;
    this.length = 0;
}

//size() : 연결 리스트 내 노드 개수 확인
LinkedList.prototype.size = function () {
    return this.length;
}

// isEmpty() : 객체 내 노드 존재 여부 파악(true/false)
LinkedList.prototype.isEmpty = function () {
    return this.length === 0;
}

// printNode() : 노드 출력
LinkedList.prototype.printNode = function() {
    for(let node = this.head ; node != null ; node = node.next){
        process.stdout.write(`${node.data} -> `);
    }
    console.log("null")
}

//append() : 연결 리스트 가장 끝에 노드 추가
LinkedList.prototype.append = function(value) {
    let node = new Node(value);
    let current = this.head;

    if(this.head === null){
        this.head = node;
    } else{
        while(current.next != null){
            current = current.next;
        }
        current.next = node;
    }

    this.length++;
}

// insert() : position 위치에 노드 추가
LinkedList.prototype.insert = function(value, position = 0) {
    if(position < 0 || position > this.length){
        return false;
    }

    let node = new Node(value),
    current = this.head,
    index = 0,
    prev;

    if(position === 0){
        node.next = current;
        this.head = node;
    } else{
        while(index++ < position){
            prev = current;
            current = current.next;
        }

        node.next = current;
        prev.next = node;
    }
    this.length++;
    return true;
}

// remove() : value 데이터를 찾아 노드 삭제
LinkedList.prototype.remove = function(value){
    let current = this.head,
    prev = current;

    while(current.data != value && current.next != null){
        prev = current;
        current = current.next;
    }

    if(current.data != value){
        return null;
    }

    if(current === this.head){
        this.head = current.next;
    } else{
        prev.next = current.next;
    }

    this.length--;

    return current.data;
}

// removeAt() : position 위치 노드 삭제
LinkedList.prototype.removeAt = function (position = 0){
    if(position < 0 || position >= this.length){
        return null;
    }

    let current = this.head,
    index = 0,
    prev;

    if(position == 0){
        this.head = current.next;
    } else{
        while(index ++ < position){
            prev = current;
            current = current.next;
        }
        prev.next = current.next;
    }
    this.length--;

    return current.data;
}

// index() : value 값을 갖는 노드 위치 반환
LinkedList.prototype.indexOf = function(value){
    let current = this.head,
    index = 0;

    while (current != null){
        if(current.data === value){
            return index;
        }

        index++;
        current = current.next;
    }

    return -1;
}

// remove2 = indexOf + removeAt = reomove
LinkedList.prototype.remove2 = function(value){
    let index = this.indexOf(value);
    return this. removeAt(index);
}

let ll = new LinkedList();

ll.insert(1);
ll.insert(10);
ll.insert(100);

ll.insert(2,1);
ll.insert(3,3)
ll.printNode();

console.log(ll.removeAt(1000));
console.log(ll.removeAt(1));
console.log(ll.removeAt(2));
console.log(ll.removeAt(100));

console.log(ll.remove2(1000));
ll.printNode();
console.log(ll.remove2(1));
ll.printNode();
console.log(ll.remove2(2));
ll.printNode();
console.log(ll.remove2(100));
ll.printNode();
console.log(ll.size());

--------------------------------------------
100 -> 2 -> 10 -> 3 -> 1 -> null
null
2
3
null
null
100 -> 10 -> 1 -> null
1
100 -> 10 -> null
null
100 -> 10 -> null
100
10 -> null
1

-1이 안나와서 오류난거 찾고 고칠 예정

📈 알고리즘 성능 평가 지표

• 정확성
• 작업량
• 메모리 사용량
• 최족성
• 효율성
  • 시간 복잡도
  • 공간 복잡도

⏱️ 시간 복잡도

• 입력 크기의 값에 대해 단위 연산을 몇 번 수행하는지 계산하여, 알고리즘의 수행 시간을 평가하는 방법

• 3가지 점근적 표현범

  • O(빅오) : 최악의 상황을 고려하여 성능 측정결과표현 ```js function big_O(n){ let sum = 0; sum = n *2; return sum; } 3 -> O(1)

    function big_O(arr, n){ let sum = 0; for(let i = 0 ; i < n; i++){

      sum+= arr[i];

    } return sum; } n+2 -> O(N)

    function big_O(arr, n){ let sum = 0; for(let i = 0 ; i < n; i++){

      for(let j = 0; j < n ; j++){
          sum+= arr[i][j];
      }

    } return sum; } n²+2 -> O(N²) n의 크기가 커질 수록 느려진다

    function big_O(arr, n){ let sum = 0; for(let i = 0 ; i < n; i*=2){

      sum+=2

    } return sum; } n/2+2 -> O(logN)

  • 병합 정렬, 분할 정복할 때 logN이 많이 나온다

  • logN 많으면 많을 수록 특정 이상 값이 안올라간다

  • N 보다 빠른 알고리즘을 가지고있다. ```

  • θ(세타) : 평균적인 경우에서의 성능 측정결과표현

  • Ω(오메가) : 최선의 상황일 때의 성능 측정결과표현

🔢 경우의 수

• 어떤 사건 혹은 일이 일어날 수 있는 경우의 가짓수를 수로 표현
• 완전 탐색으로 경우의 수를 푸는 알고리즘
  • 순열
  • 조합
  • 중복 순열

🔁 순열(Permutation)

서로 다른 n개의 원소 중에서 r개를 중복 없이 골라 순서에 상관 있게 나열하는 경우의 수(nPr)

🧩 3개의 알파벳으로 단어를 만드는 경우의 수

let input = ["a", "b", "c"];
let count = 0;

// s: 지금 바꿀 위치(=고정할 자리), r : 마지막 고정할 자리 (여기선 2 → 0~2까지 총 3개 자리 고정)
function permutation(arr, s, r){
    // 1. 재귀함수를 멈춰야할 조건
    if(s == r){
        count++;
        console.log(arr.join(" "));
        return;
    }
    // 2. 재귀를 돌변서 변경되어야 될 부분/메인로직
    for(let i = s; i < arr.length ; i++){
        [arr[s], arr[i]] = [arr[i], arr[s]]; // swap
        permutation(arr, s+1, r); // 요소 선택시 재귀함수 호출
        [arr[s], arr[i]] = [arr[i], arr[s]]; // swap 원상복구
    }

    /**
     s  r
     0  2   i=0 ["a",]
     1  2   i=1 ["a","b", ]
     2  2   ["a","b","c"]
     ...
     1  2   i=2 ["a","c",]
     2  2   ["a","c","b"]
     1  2   i=2 ["a","b",]
     ...
     0  2   i=1 ["b","a","c"]
     ...
     0  2   i=0 ["c",]
     */
}

permutation(input, 0, 2);
console.log(count)

--------------------------------------------------
OUTPUT
a b c
a c b
b a c
b c a
c b a
c a b
6

🤝 조합(Combination)

서로 다른 n개의 원소중에서 r개를 중복 없이 골라 순서에 상관 없이 나열하는 경우의 수(nCr)

🃏 4개의 숫자 카드에서 2개를 뽑는 경우의 수

• for문

  let input = [1,2,3,4]; // 4C2
  let count = 0;
  

function combination(arr){ // for -> 뽑는 갯수 ==> r ==> 2 for(let i = 0; i < arr.length; i++){ for(let j = i + 1; j<arr.length; j++){ count++; console.log(arr[i],arr[j]) } } }

combination(input, 0, 2); console.log(count)

OUTPUT 1 2 1 3 1 4 2 3 2 4 3 4 6

- 재귀 함수
```js
let input = [1,2,3,4]; // 4C2
let output = [];
let count = 0;

function combination(arr, data, s, idx, r){
    if(s == r){
        count++;
        console.log(data)
        return;
    }
    for(let i = idx; arr.length - i >= r - s ; i++){
        data[s] = arr[i]
        combination(arr, data, s + 1, i + 1, r)
    }
}

combination(input, output, 0, 0, 2);
console.log(count)

--------------------------------------------------
OUTPUT
[ 1, 2 ]
[ 1, 3 ]
[ 1, 4 ]
[ 2, 3 ]
[ 2, 4 ]
[ 3, 4 ]
6

🧮 점화식

점화식(재귀식)이란 수열에서 이웃하는 두개의 항 사이에 성립하는 관계를 나타낸 관계식

• 등차수열 : F(n) = F(n-1)+a // a : 고정된 상수

  //등차 수열 - for 문
  let result;
  

function forloop(s, t, number){ let acc = 0;

for(let i = 1; i <=number ; i++){
    if( i == 1) {
        acc += s;
    } else{
        acc += t;
    }
    console.log(i, acc)
}
return acc;

};

result = forloop(3, 2, 5) console.log(result)

OUTPUT 1 3 2 5 3 7 4 9 5 11 11

//등차 수열 - 재귀 함수 let result;

function recursive(s, t, number){ // 멈출 조간 if( number == 1){ return s; }

// 반복할 코드
return recursive(s, t, number-1) + t;

};

result = recursive(3, 2, 5) console.log(result)

OUTPUT 11

number : 5 recursive(s, t, 4) + 2 => 9+2 => 11 number : 4 recursive(s, t, 3) + 2 => 7+2 => 9 number : 3 recursive(s, t, 2) + 2 => 5+2 => 7 number : 2 recursive(s, t, 1) + 2 => 3+2 => 5 number : 1 recursive(s, t, 1) + 2 => 3

- 등비수열 : F(n) = F(n-1)*a

    ⇒ 등차수열 공식에서 `+ → *`로 바꾸면된다.

- 팩토리얼 : F(n) = F(n-1)*n
```js
    let reuslt;

    function recursive(number){
        if(number == 1){
            return number;
        }
        return recursive(number-1)*number;
    }

    reuslt = recursive(5);
    console.log(reuslt)

    --------------------------------------------------
    OUTPUT
    120
    5! = 5 X 4 X 3 X 2 X 1

    --------------------------------------------------
    --------------------------------------------------
    let reuslt;

    function recursive(number){
      let hap = 1;
      for( let i = 1 ; i <= number; i++){
        hap *= i;
      }
      return hap;
    }

    reuslt = recursive(5);
    console.log(reuslt)

    --------------------------------------------------
    OUTPUT
    120

• 피보나치 수열 : F(n) = F(n-1)+F(n-2)

  let reuslt;
  
  function recursive(number){
    if(number == 1|| number == 0){
      return number;
    }
  
    return recursive(number - 1)+(number -2);
  }
  
  reuslt = recursive(5);
  console.log(reuslt)
  
    --------------------------------------------------
  OUTPUT
  5
  
  f(5) = f(4) + f(3) => 2 + 3 = 5
  f(4) = f(3) + f(2) => 1 + 2 = 3
  f(3) = f(2) + f(1) => 1 + 1 = 2
  f(2) = f(1) + f(0) => 1 + 0 = 1
  f(1) = 1
  f(0) = 0

• 여러 값(Entity) 을 순차적으로 나열한 자료구조
• 배열 내 각 값은 요소(element) 라고 하며, 인덱스(index)를 통해 접근

🛠️ 대표 속성과 메서드

✔️ 배열 크기 및 배열 여부 확인

• Array.length
• Array.isArray(value)

✔️ 배열 추가/삭제

• push(), pop()
• shift(), unshift()
• splice(), slice()

✔️ 배열 탐색

• indexOf(), lastIndexOf()
• includes()

✔️ 배열 변형 (callback 미사용)

• sort(), reverse(), join()

📌 배열 선언, 접근, 속성

✅ 선언

"new Array()" 혹은 "[]"를 통해 선언하며, 사이즈 혹은 값을 입력하여 초기화도 가능

  let arr_1 = new Array(10);
  let arr_2 = [];

  console.log(arr_1);
  console.log(arr_2);

  let fruits = ["apple", "orange", "melon"];
  console.log(fruits);

✅ 접근

"Array[index]" 를 통해 index를 통하여 O(1) 접근

  console.log(fruits[0]); // apple
  console.log(fruits[1]); // orange
  console.log(fruits[2]); // melon

✅ 길이 확인

"Array.length" 를 통해 배열 요소의 개수 확인 가능

  console.log(fruits.length); // 3

✅ 값 변경

fruits[1] = "kiwi"; 
console.log(fruits); // ["apple", "kiwi", "melon"]

🧬 배열의 실체 (해시 기반 객체)

• 자바스크립트에서 배열은 일반 배열이 아닌 Hash 기반의 객체

• 메모리는 비연속적인 희소 배열(sparse array) 형태로 구성됨

  let nums = [];
  
  nums[0] = "one";
  nums[1] = "two";
  
  console.log(nums.length);
  console.log(nums);

  

  let nums = [];
  
  nums[0] = "one";
  nums[1] = "two";
  
  nums["once"] = "once";
  nums["twice"] = "twice";
  
  console.log(nums.length);
  console.log(nums);
  
  console.log(Object.getOwnPropertyDescriptors(nums));

  

nums[0], nums[1] 은 배열의 인덱스를 채운 것이고 nums["once"], nums["twice"] 은 객체 속성(키)를 추가한 것이다. 그래서 길이가 2인것 은 배열의 인덱스를 가르키고 비연속적인 희소 배열로 생성된 걸 알 수 있다

🔍 배열 타입 확인

• Array.isArray(value)

  let num = 123.456;
  let str = "here i am";
  let fruits = ["apple", "orange", "melon"];
  
  console.log(Array.isArray(num)); //false
  console.log(Array.isArray(str)); //false
  console.log(Array.isArray(fruits)); // true

❌ 배열 일부 요소 삭제

• delete array[index] ➡️ 요소를 삭제를 해도 배열 사이즈가 그대로인 문제점이 있다

  let fruits = ["apple", "orange", "melon"];
  
  console.log(fruits);
  console.log(fruits.length);
  
  delete fruits[1];
  
  console.log(fruits);
  console.log(fruits.length);

  

🔁 배열 추가/삭제

🔸 LIFO (Last-In First-Out) - Back

• Array.push(element) // 추가

• Array.pop() // 삭제

  let fruits = ["apple", "orange", "melon"];
  
  fruits.push("watermelon");
  console.log(fruits); // [ 'apple', 'orange', 'melon', 'watermelon']
  console.log(fruits.length); // 4
  
  fruits.pop();
  console.log(fruits); // [ 'apple', 'orange', 'melon' ]
  console.log(fruits.length); // 3
  

🔸 LIFO (Last-In First-Out) - Front

• Array.unshift(element) // 추가

• Array.shift() // 삭제

  let fruits = ["apple", "orange", "melon"];
  
  fruits.unshift("watermelon");
  console.log(fruits); // [ 'watermelon', 'apple', 'orange', 'melon' ]
  console.log(fruits.length); // 4
  
  fruits.shift();
  console.log(fruits); // [ 'apple', 'orange', 'melon' ]
  console.log(fruits.length); // 3
  

✂️ 배열 요소 삭제/삽입

✔️ Array.slice(index[,deleteCount, elem1, ... , elemN])

  let fruits = ["apple", "orange", "melon"];
  let ret;

  ret = fruits.splice(1); 
  console.log(ret); // [ 'orange', 'melon' ]
  console.log(fruits); // [ 'apple' ]

  fruits = ["apple", "orange", "melon", "strawberry"];
  ret = fruits.splice(1, 1);
  console.log(ret); // [ 'orange' ]
  console.log(fruits); // [ 'apple', 'melon', 'strawberry' ]

  ret = fruits.splice(1, 1, "mango", "kiwi"); // melon 위치에 "mango", "kiwi"가
  console.log(ret); // [ 'melon' ]
  console.log(fruits); // [ 'apple', 'mango', 'kiwi', 'strawberry' ]

✔️ slice(start, end) - 원본 유지

let fruits = ["apple", "orange", "melon"];

console.log(fruits.slice(1)); // [ 'orange', 'melon' ]
console.log(fruits); // [ 'apple', 'orange', 'melon' ]

console.log(fruits.slice(1, 2)); // [ 'orange' ]
console.log(fruits.slice(-2)); // [ 'orange', 'melon' ]

✔️ Array.concat(arg1, arg2)

let fruits = ["apple", "orange", "melon"];
let fruits_add = ["cherry", "banana"];

console.log(fruits.concat(fruits_add)); // [ 'apple', 'orange', 'melon', 'cherry', 'banana' ]
console.log(fruits); // [ 'apple', 'orange', 'melon' ]

🔁 배열 반복문

• 다양한 반복문 문법을 통해 배열 요소에 접근 가능
• 반복문 문법 • for + length: index 접근 • for...of: element 접근 • for...in: key(index) 접근

  let fruits = ["apple", "orange", "melon"];
  

for (let i = 0; i < fruits.length; i++) { console.log(fruits[i]); // apple // orange // melon }

for (let fruit of fruits) { console.log(fruit); // apple // orange // melon }

for (let key in fruits) { console.log(key); // 0 // 1 // 2 console.log(fruits[key]); // apple // orange // melon }

---
## 🔍 배열 탐색
- index탐색(앞에서부터) : `Array.indexOf(item, from)`
- index탐색(뒤에서부터) : `Array.lastIndexOf(item, from)`
- 값 포함 여부 확인(true/fasle) : `Array.includes(item,from)`
```js
let fruits = ["apple", "orange", "banana", "orange", "melon"];

console.log(fruits.indexOf("orange")); // 1
console.log(fruits.indexOf("Orange")); // -1 : 배열 내에 없다
console.log(fruits.indexOf("orange", 2)); // 3

console.log(fruits.lastIndexOf("orange")); // 3
console.log(fruits.lastIndexOf("orange", -3)); // 1
console.log(fruits.lastIndexOf("orange", 0)); // -1

console.log(fruits.includes("banana")); // true
console.log(fruits.includes("watermelon")); // false
console.log(fruits.includes("Banana")); // false

🔃 배열 정렬 / 반전

➡️ sort()와 reverse()는 원본 배열 자체를 변경함

• 배열 정렬 : Array.sort()
• 배열 반전 : Array.reverse()

  let nums = [1, -1, 4, 5, 2, 0];
  

console.log(nums.sort()); // [ -1, 0, 1, 2, 4, 5 ] 오름차순으로 정렬한 nums를 console.log(nums.reverse()); // [ 5, 4, 2, 1, 0, -1 ] 반전시킨 형태 console.log(nums); // [ 5, 4, 2, 1, 0, -1 ]

let fruits = ["apple", "orange", "banana", "melon"];

console.log(fruits.sort()); // [ 'apple', 'banana', 'melon', 'orange' ] console.log(fruits.reverse()); // [ 'orange', 'melon', 'banana', 'apple' ] console.log(fruits); // [ 'orange', 'melon', 'banana', 'apple' ]

## 🔄 배열 변환
➡️ 원본 데이터에 영향을 미친다.
- 배열 값을 문자열로 변환 : `Array.join(separator)`
```js
let fruits = ["apple", "orange", "banana", "melon"];
let str = fruits.join();
console.log(str); // apple,orange,banana,melon ➡️ ","가 기본값

let str_separator = fruits.join(";");
console.log(str_separator); // apple;orange;banana;melon

• 데이터의 종류
• 자바스크립트는 총 7개의 기본 타입(6개의 원시타입 + 1개의 객체 타입)을 가지고 있습니다.

🔹 원시 타입 (Primitive Type)

🔸 객체 타입 (Object Type)

• 두 개 이상의 복잡한 개체를 저장하는 데 사용
• {} 중괄호로 생성하며, key-value 쌍으로 구성
• 다수의 원시자료형을 포함하거나 복잡한 개체(Entity)를 표현할 수 있는 자료형
• 접근은 objecy.key형태로 표현
• 변수를 주소값에 넣어서 저장

let user = {
  name : "John",
  age : 27
}

✅ 객체 접근

console.log(user.name); -> OUTPUT : John
-> user라는 위치에서 name이라는 번지를 찾는다

✅ 객체 추가

user.weight = 72;

✅ 객체 삭제

delete user.weight;

⚠️ 객체 복사 시 문제점

• 객체는 주소값을 참조하므로, 복사 후 값을 변경하면 원본도 함께 변경됨

👏🏻 복사 문제점 해결 방안

✅ 얕은 복사(Shallow Copy)

• 내부 객체는 참조만 복사되므로 한 단계까지만 복사
  • for 문
  • Object.assign(복사할 곳, 복사할 값)
  • spread 연산자
  • ❗ 중첩 객체가 있을 경우 내부까지 복사되지 않음

    ✅ 깊은 복사 (Deep Copy)

• 내부 객체까지 완전히 복사
• 재귀 함수
• JSON.parse(JSON.stringify(obj)) (단점: 함수/심볼 누락) ➡️ 서버와 데이터를 주고받을때 주로 사용

📏 자료형 확인 방법

typeof 123; // "number"
typeof null; // "object" ❗ (자바스크립트 설계상 버그)
typeof undefined; // "undefined"
typeof {} // "object"
typeof [] // "object"
typeof (() => {}) // "function"

❗ typeof null은 “object”로 나오는 역사적 버그입니다. 배열과 객체는 모두 "object"로 나오므로 주의!

🔄 형 변환 (Type Conversion)

• 느슨한 타입 언어 혹은 동적 타입 언어로 변수의 자료형은 명시적으로 선언할 필요가 없는 언어

✔️ 암묵적 형 변환 (자동)

자바스크립트는 동적 타입 언어이므로 상황에 따라 자동으로 형 변환을 수행

"5" * 2    // 10 (string → number)
true + 1   // 2  (boolean → number)

✔️ 명시적 형 변환 (강제)

🔡 문자열로 변환 : String()

String(123); // "123"
123 + "";     // "123" (암묵적)

으로 형변환

🔢 문자열로 변환 : Number()

• parseInt() -> 정수 변환
• parseFloat -> 실수 변환 ```js Number("123"); // 123 parseInt("123.45"); // 123 parseFloat("123.45"); // 123.45
• "123"; // 123 (단항 연산자)

❗️ Boolean으로 변환 : Boolean()

• False 가 나오는 값 : 빈 문자열 , NaN, Null, undefined

  Boolean("hello"); // true
  Boolean("");      // false

브라우저에 저장되는 작은 크기의 문자열 데이터입니다.
웹 서버와 클라이언트(브라우저) 간의 상태 유지를 위한 수단으로 사용됩니다.

📝 쿠키 용도

• 로그인 유지 (자동 로그인 기능) • 사용자 맞춤 설정 저장 (다크모드 등) • 장바구니 정보 유지 • 방문 횟수 기록

🧾 쿠키 구성 요소

✍️ 쿠키 사용 방법

1️⃣ 쿠키 쓰기

🔹 클라이언트 측 쿠키 생성 (JavaScript)

document.cookie = "name=wonji; path=/; max-age=3600";

🔹 서버 측 쿠키 생성 (예시)

response.setHeader("Set-Cookie", "name=wonji; path=/; max-age=3600");

서버에서 Set-Cookie 헤더를 사용하여 클라이언트에 쿠키 전송

🔍 쿠키 접근 (읽기)

document.cookie

현재 페이지에서 사용 가능한 모든 쿠키를 문자열 형태로 반환합니다.

❌ 쿠키 삭제

// 쿠키 만료시켜서 삭제
document.cookie = "max-age=0"

max-age=0 또는 expires=과거 날짜로 설정하면 해당 쿠키 삭제됨

📤 쿠키 전송 (요청 시 포함)

// 쿠키를 포함하여 서버에 요청 전송
fetch(URL,{
  credentials : 'include';
});

credentials: 'include' 설정 시, 쿠키를 요청 헤더에 자동으로 포함

📍 쿠키 vs 세션 차이점

💡 일반적으로 보안이 중요한 정보는 세션, 간단한 사용자 설정 정보는 쿠키에 저장하는 것이 좋습니다.

모듈(Module)은 하나의 큰 프로그램을 구성하는 독립된 파일 단위입니다.
여러 파일로 어플리케이션을 분리하고, 각각의 파일을 모듈이라 부릅니다.

• 코드 재사용을 높이고
• 유지보수를 쉽게 하며
• 전역 스코프 오염을 방지합니다.

✅ 모듈 사용하는 방법

배열에 다양한 동물 이름을 담고, 각 동물에 맞는 울음소리를 출력하는 예제를 통해 알아볼게요.

1. 📤 모듈 내보내기 (export)

example1.mjs

// 강아지 울음소리
export const dog = () => {
  return "bow-wow";
};

example2.mjs

// 고양이 울음소리
export const cat = () => {
  return "meow";
};

2. 📥 모듈 가져오기 (import)

import { dog } from "./example1.mjs";
import { cat } from "./example2.mjs";

3. 🛡️ 모듈 시스템의 장점

• 내보내지 않은 변수/함수는 외부에서 접근 불가 • 캡슐화를 통해 외부로부터 자원 보호 • 코드 충돌 방지

4. 💻 전체 예제 코드

import { dog } from "./example1.mjs";
import { cat } from "./example2.mjs";

const animals = ["dog", "cat", "rabbit", "cow", "bird"];

animals.forEach((animal) => {
  if (animal === "dog") {
    console.log(`${animal} is `, dog());
  } else if (animal === "cat") {
    console.log(`${animal} is `, cat());
  } else {
    console.log(`${animal} is search plz`);
  }
});

🖨️ 출력 결과

✚ 추가 내용

📄 .mjs 확장자란?

.mjs는 "module JavaScript"의 줄임말로,
ES6 모듈을 사용하고 있다는 것을 명시하는 파일 확장자입니다.

✅ 사용 이유

• 브라우저 또는 Node.js에서 해당 파일이 모듈 형식이라는 걸 명확히 하기 위해 사용합니다.
• 특히 Node.js에서는 .js 확장자만으로는 모듈인지 스크립트인지 구분이 어려워 .mjs를 사용합니다.

✅ 예시

node example.mjs

.html 없이도 터미널에서 직접 실행이 가능하며 모듈을 사용할 수 있습니다.

• 객체 기반의 스크립트 프로그래밍 언어
• 웹 페이지에 생동감을 불어넣기 위해 만들어진 프로그래밍 언어
• 자바스크립트로 작성한 프로그램을 스크립트(script) 라고 함
• 웹페이지의 HTML 안에 작성 가능하며, 페이지가 로드될 때 자동 실행됨

📌 자바스크립트의 특징

✅ 브라우저에서 자바스크립트로 할 수 있는 일

• 페이지에 새로운 HTML을 추가하거나 기존 HTML 및 스타일 수정
• 사용자의 행동 (마우스 클릭, 키보드 입력 등)에 반응하기
• 네트워크를 통해 원격 서버에 요청을 보내거나, 파일 다운로드 및 업로드하기
• 쿠키를 가져오거나 설정하기, 사용자에게 질문을 건네거나 메시지를 보여주기
• 클라이언트 측에 데이터 저장하기 (로컬 스토리지)

❌ 브라우저에서 자바스크립트로 할 수 없는 일

• 웹페이지 내 스크립트는 디스크에 저장된 임의의 파일을 읽거나 실행하는 것이 제한됨

  카메라나 마이크 같은 디바이스와 상호 작용하려면 사용자의 명시적인 허가가 필요함

• 브라우저 내 다른 탭과 창의 정보 접근 불가

  단, 자바스크립트로 새 창을 열 경우 예외가 적용되지만, 도메인, 프로토콜, 포트가 다르면 접근 불가

• 자바스크립트는 서버와 쉽게 정보를 주고받을 수 있지만, 타 사이트나 도메인의 데이터 접근은 불가능

  원격 서버에서 명확하게 승인(CORS 설정) 해야 함

📜 자바스크립트의 배경

자바스크립트는 빠르게 개발되고, 개방적이며, 많은 사람들이 사용할 수 있도록 설계됨
다양한 언어의 장점을 결합하여 만들어짐

🎯 ECMAScript와 JavaScript

JavaScript는 프로그래밍 언어이고, ECMAScript(ES)는 JavaScript의 명세(표준)

🔹 ECMAScript 버전

• ES1, ES2, ES3... 최신 버전으로 발전 중
• ES6(ES2015) 이후 화살표 함수, let, const, Promise 등 추가됨

🌍 자바스크립트 Everywhere

⚡ V8 엔진 & Node.js

• V8 엔진 : Google Chrome에서 사용하는 JavaScript 엔진
• Node.js : Chrome V8 엔진을 기반으로 한 JavaScript 런타임 ➡️ 자바스크립트를 실행시켜줄 수 있는 환경 ➡️ 환경을 통해서 서버를 구축

  console.log("Hello, Node.js!");

📲 JavaScript의 활용

• Facebook 앱 : React로 개발됨
• Electron : 자바스크립트를 사용해 데스크탑 애플리케이션 개발 가능
• VSCode, Slack, Notion 모두 Electron 기반
• 개발자 도구(F12)에서 자바스크립트 코드 확인 가능

🚀 크로스 플랫폼 개발 가능

• HTML + CSS + JavaScript 활용 → 다양한 플랫폼에서 사용 가능
• React Native : 모바일 앱 개발
• Electron : 데스크탑 앱 개발 (Windows, Mac 지원)
• Node.js : 서버 개발

📚 참고 문헌

🔗 JAVASCRIPT.INFO

📌 굵은 글씨 요소 : <b>, <strong>

독자의 주의를 요소의 콘텐츠로 끌기 위한 용도로 사용하며, 특정 부분만 굵게 표시합니다.

<p>
    This article describes several
    <b class="keywords">text-level</b> elements. It explains their usage in an
    <strong>HTML</strong> document.
</p>

💡 <b>, <strong> 차이점

• <b> : 특별한 중요성을 가지고 있지는 않지만 굵게 표시한 부분에 사용
• <strong> : 중요한 의미를 강조할 때 사용

📌 기울임 글씨 요소 :<i>, <em>

• 일반적으로 기울임꼴(Italic)로 표시됩니다.

<p>I looked at it and thought <i>This can't be real!</i></p>
<p>Get out of bed <em>now</em>!</p>

💡 <i>, <em> 차이점

• <i> : 기술 용어, 외국어 구절, 등장인물의 생각 등에 사용
• <em> : 문장에서 강조할 부분을 나타낼 때 사용

🔗 하이퍼링크 (Hyperlink)

📌 <a> 태그 (앵커 태그)

HTML <a> 요소는 href 속성을 사용해 다른 웹 페이지, 파일, 이메일, 전화번호 등으로 연결하는 하이퍼링크를 만듭니다.

<ul>
  <li><a href="https://example.com">Website</a></li>
  <li><a href="mailto:m.bluth@example.com">Email</a></li>
  <li><a href="tel:+123456789">Phone</a></li>
</ul>

📌 <a> 태그 속성

🔹 href 속성 (절대경로 vs 상대경로)

• 절대경로 (Absolute Path) 전체 URL을 포함하여 특정 리소스에 접근하는 방식입니다. <a href="https://www.example.com/about.html">About Page</a> ✅ 어느 위치에서든 접근 가능하지만, URL이 길어질 수 있음

• 상대경로 (Relative Path) 현재 문서를 기준으로 다른 페이지를 연결하는 방식입니다. ➡️ 같은 도메인 내에서만 접근 가능 <a href="/about.html">About Page</a> ✅ 같은 사이트 내에서 관리하기 편리하며, URL이 짧아짐

🔹 target 속성 (새 창에서 열기)

🏷️ 엔티티 (Entity)

HTML 엔티티는 특수문자나 예약된 기호를 표현할 때 사용됩니다. 각 엔티티는 ”&”로 시작하고 ”;”로 끝납니다.

📚 참고 문헌

🔗 MDN Web Docs: Anchor elements
🔗 MDN Web Docs: HTML Entities

📌 제목 : <h1> - <h6>

HTML <h1> - <h6> 요소는 6단계의 구획 제목을 나타냅니다.

• <h1>이 가장 중요하고 <h6>이 가장 덜 중요한 제목입니다.
• 웹 브라우저는 제목의 정보를 활용해 자동으로 목차를 생성할 수 있습니다.

<h1>제목 1</h1>
<h2>제목 2</h2>
<h3>제목 3</h3>
<h4>제목 4</h4>
<h5>제목 5</h5>
<h6>제목 6</h6>

💡 참고사항

• 글자 크기를 조절하려고 <h1>을 사용하지 말 것 → 대신 CSS의 font-size 사용 • <h1>은 페이지당 하나만 사용 (웹 접근성 향상) • <h1>부터 순차적으로 사용해야 웹 표준에 적합

두 개의 제목을 가진 책이나, 여러 개의 이름을 가진 영화는 볼 수 없는 것 처럼 !

📌 본문 : <p></p>(문단)

HTML <p> 요소는 하나의 문단(문장들의 집합)을 나타냅니다.

<p>첫 번째 문단입니다.
    첫 번째 문단입니다.
    첫 번째 문단입니다.
    첫 번째 문단입니다.</p>
<p>두 번째 문단입니다.
    두 번째 문단입니다.
    두 번째 문단입니다.
    두 번째 문단입니다.</p>  

✅ 문단은 블록 레벨 요소이며, 닫는 태그 </p> 이전에 다른 블록 요소가 분석되면 자동으로 닫힙니다. ✅ 줄바꿈이 자동으로 적용되지 않습니다!

🟡 빈 요소

📌 본문 : <br> (줄바꿈)

HTML <br> 요소는 줄바꿈(Line Break)을 생성합니다.

<p>
  O’er all the hilltops<br />
  Is quiet now,<br />
  In all the treetops<br />
  Hearest thou<br />
  Hardly a breath;<br />
  The birds are asleep in the trees:<br />
  Wait, soon like these<br />
  Thou too shalt rest.
</p>

✅ <br> 요소는 여는 태그만 작성하면 됩니다! ✅ <br>을 사용한 만큼 줄바꿈이 적용됩니다.

⚠️ <br>을 문단 간 여백을 줄 때 사용하지 마세요! → CSS의 margin 속성을 활용하세요.

📌 본문 : <hr> (구분선)

HTML <hr> 요소는 콘텐츠의 주제 변경이나 장면 전환을 나타냅니다.

<p>§1: The first rule of Fight Club is: You do not talk about Fight Club.</p>

<hr />

<p>§2: The second rule of Fight Club is: Always bring cupcakes.</p>

✅ 화면 너비만큼 선이 출력됩니다.

🟢 인용 요소

• 출처 텍스트는 <cite> 요소로 제공 ➡️ 출력되지는 않는다.

📌 본문 : <blockquote></blockquote> (긴 인용문)

HTML <blockquote> 요소는 긴 인용문을 표현합니다.

<blockquote cite="https://www.huxley.net/bnw/four.html">
    <p>Words can be like X-rays, if you use them properly—they’ll go through anything. You read and you’re pierced.</p>
</blockquote>
<p>—Aldous Huxley, <cite>Brave New World</cite></p>

✅ 기본적으로 들여쓰기가 적용됩니다. ✅ 출처는 <cite> 요소로 제공할 수 있습니다.

⚠️ <p> 태그 안에 <blockquote> 태그를 사용하면 안 됩니다!

<p>
    <blockquote>
        Avian carriers can provide high delay, low throughput, and low altitude
        service.
    </blockquote>
</p>

HTML 구조상 자동으로 <p>가 닫히기 때문입니다. 그래서 HTML 상으로는

<p></p>
    <blockquote>
        Avian carriers can provide high delay, low throughput, and low altitude
        service.
    </blockquote>
</p>

이렇게 되어있어서 HTML에서 인식을 못해서 잘못된 코드이다.

📌 본문 : <q></q> (짧은 인용문)

HTML <q> 요소는 짧은 인용문을 표현할 때 사용됩니다. • 브라우저에서 자동으로 따옴표(“ ”)를 추가합니다.

<p>
    Mozilla 재단의 웹사이트에 따르면,
    <q cite="https://www.mozilla.org/en-US/about/history/details/">
    Firefox 1.0 은 2004년 처음 공개되어 큰 성공을 거두었습니다.</q>
</p>

✅ 줄바꿈 없이 간단한 인용문에 적합합니다.

🟠 미리 서식 정의된 텍스트 요소

📌 본문 : <pre></pre> (미리 서식화된 텍스트)

HTML <pre> 요소는 HTML 문서에서 작성한 그대로 표현합니다.

<pre>
  L          TE
    A       A
      C    V
       R A
       DOU
       LOU
      REUSE
      QUE TU
      PORTES
    ET QUI T'
    ORNE O CI
     VILISÉ
    OTE-  TU VEUX
     LA    BIEN
    SI      RESPI
            RER       - Apollinaire
</pre>

✅ 고정폭 글꼴이 사용됩니다. ✅ 공백과 줄바꿈이 그대로 유지됩니다.

고정폭 글꼴이란?

<pre>IIII</pre>
<p>IIII</p>

• 일반 <p> 태그에서는 가변폭 글꼴을 사용합니다. ✅ <pre>를 사용하면 글자가 동일한 간격으로 정렬됩니다.

📚 참고 문헌

🔗 MDN Web Docs: Heading Elements

마크업(Markup)은 텍스트를 구조화하고 의미를 부여하기 위해 고안된 언어입니다.
일반적인 문서에서 텍스트 자체뿐만 아니라, 문서의 서식(스타일), 의미(구조), 데이터 속성 등을 표현할 수 있어요.

📌 HTML, XML, LaTeX, Markdown 등이 마크업 언어의 대표적인 예시!

✨ Markup 언어의 종류

마크업 언어는 표현 방식에 따라 크게 3가지 유형으로 나뉩니다.

💡 설명적 마크업이 가장 널리 사용되며, 현대적인 HTML 문서 작성에서 중요한 역할을 해요!

🌟 Markdown이란?

Markdown(마크다운)은 일반 텍스트 기반의 경량 마크업 언어입니다.
HTML 같은 복잡한 문법 없이, 간단한 기호로 문서의 서식을 지정할 수 있어요.

✨ Markdown의 장점과 단점

✅ 장점

• 문법이 간결하고 배우기 쉽다
• 다양한 플랫폼에서 지원
• 용량이 작고 빠르게 렌더링 가능
• 다양한 형태로 변환 가능 (HTML, PDF 등)

❌ 단점

• HTML의 모든 기능을 대체하지 못한다
• 표준이 없어서 환경에 따라 다르게 표현될 수 있음
• 이미지 삽입 시 경로를 수동으로 입력해야 함

📌 주요 사용처

• GitHub (README.md 문서 작성)
• 블로그 (Velog, Notion, Tistory 등)
• 위키 문서 (Wikipedia, GitBook)

🔹 Markdown 문법 예시

# 큰 제목
## 작은 제목
**굵은 글씨**  
_이탤릭체_  
[네이버로 이동](https://naver.com)

✅ Markup vs Markdown 비교 정리

🎯 한 줄 요약

Markup은 문서의 구조를 정의하는 일반적인 개념이고,
Markdown은 간단한 문법으로 문서를 서식화할 수 있는 경량 마크업 언어입니다.

클래스 컴포넌트의 기능을 함수 컴포넌트에서도 이용할 수 있는 React의 특수한 기능들을 함수 컴포넌트에서도 사용할 수 있도록 도와주는 메서드들 (함수 컴포넌트에서도 클래스 컴포넌트의 기능을 마치 낚아채듯이(hook) 가져와서 사용할 수 있게 해준다)

📍 React Hooks 종류

1. useState ➡️ State 라는 기능을 낚아채오는 Hook
2. useRef ➡️ Reference 라는 기능을 낚아채오는 Hook
3. useEffect
4. useReducer 등등

📍 React Hooks 특징

• React Hooks에는 이름 앞에 use라는 접두사가 붙는 특징이 있다.
• 컴포넌트 내부에서만 호출 가능
• 조건문, 반복문 내부에서는 호출 불가
• use 라는 접두사를 이용해서 직접 나만의 새로운 Hook인 Custom Hook을 만들 수 있다.

📍 예시

1. HookExam 파일 생성

   HookExam.jsx
   

const HookExam = () => { return

export default HookExam;

2. App.jsx에서 호출

App.jsx

import "./App.css"; import Register from "./components/Register"; import HookExam from "./components/HookExcam";

function App() { return ( <> </> ); }

export default App;

<img src="https://velog.velcdn.com/images/frozen_land/post/0052ffea-1a5b-4899-aef3-ea130ee837e3/image.png">

---

## 📍 3가지 hook 관련된 팁
### 1. 함수 컴포넌트, 커스텀 훅, React 함수 내부에서만 호출 가능
<img src="https://velog.velcdn.com/images/frozen_land/post/c1e9b102-abe2-405f-a064-0a6818f41da1/image.png" width="40%">
이렇게 작성하면 state가 외부에 있어서 오류 표시가 떠야하는데 오류가 안떠서 당황 ;;
혹시 몰라서 브라우저 콘솔창 확인했더니 
<img src="https://velog.velcdn.com/images/frozen_land/post/defa4e9b-0844-48f5-980a-4b14dcd85e5d/image.png">

`Invalid hook call. Hooks can only be called inside of the body of a function component.`
후 ~ 이제 마음이 편안해진다.
오류를 해결하기 위해서는 `const state = useState();` 를 함수 컴포넌트 안에 넣어주면 된다.

import { useState } from "react";

const HookExam = () => { const state = useState();

return <div>HookExam</div>;

};

export default HookExam;

### 2. 조건부로 호출될 수 없다.
> 조건부로 호출 : 조건문이나 반복문 내부에서 hook이 호출된다.

#### 왜?
: React가 내부적으로 컴포넌트들을 호출해서 화면에 렌더링할 때 이런 조건문과 반복문 내부에서 hook을 호출하게되면 서로 다른 hook들의 호출 순서가 엉망이 되어버리는 현상이 발생 ➡️ **내부적인 오류가 발생**

### 3. 나만의 훅(Custom Hook)을 직접 만들 수 있다.

const HookExam = () => { const [input,setInput] = useState("");

const onChange = (e) =>{
    setInput(e.target.value);
}

const state = useState();

return (
    <div>
        <input value={input} onChange={onChange}/>
    </div>
);

};

위의 내용을 custom hook로 만들어보기 !

import { useState } from "react";

function useInput() { const [input, setInput] = useState("");

const onChange = (e) => {
    setInput(e.target.value);
}

return [input, onChange];

}

const HookExam = () => { const [input, onChange] = useInput(); const [input2, onChange2] = useInput();

return (
    <div>
        <input value={input} onChange={onChange}/>
        <input value={input2} onChange={onChange2}/>
    </div>
);

};

export default HookExam;

그냥 함수 앞에 **use만 붙이면 custom hook이 완성**된다.
(근데 use대신 get을 써도 오류가 안나,,, react 레퍼런스 보면 되는게 맞을 것 같기도하고 아닌 것 같기도 하고,,, help.....)

---

## 📍 Custom Hooks 보관 방법
>보통 scr 디렉토리 아래에 Hooks 라는 별도의 폴더를 만들고 여기에 Hook의 이름으로 보관한다.

<img src="https://velog.velcdn.com/images/frozen_land/post/d6b3d1dc-176d-40e6-a15a-5b7302c0160d/image.png">

✍🏻 작성법

1. ❎ : 실천하지않았다. / ✅ : 실천했다.
2. 📍 Life : 잊지 말고 해야할 일만 작성
3. 📍 Study : 내가 할 수 있을만큼의 양만 작성 💫 (프로젝트 3시간 + 작성한 코드 공부 2시간 + 개인 공부 2시간)
4. 💭 How do you feel today : 오늘 내가 느낀점 작성

🏂 January 🏂

🗓️ 2025/01/03

📍 Life ✅ 월 지출 정리하기 ❎ 빨래통 새로 구입하기 ➡️ 돈이 없으니깐 굳이? 라는 생각이 들었다. ✅ 일기 쓰기

📍 Study ✅ 프로젝트용 코드 PR 올리기 ✅ 프로젝트용 코드 계획 세우기

🗓️ 2025/01/04

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ API 설계하기 ❎ 설계한 API 공부하기 ❎ React 강의 듣고 정리하기 ❎ TypeScript 강의 듣고 정리하기

🗓️ 2025/01/05

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 설계한 API 공부하기 ✅ React 강의 듣고 정리하기 ❎ TypeScript 강의 듣고 정리하기

💭 How do you feel today 어제보다 할 일을 한 개 더했다:) 내일은 3-4개 달성해야지!

🗓️ 2025/01/06

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 멘토링 ✅ 멘토링 기록 정리하기

💭 How do you feel today 멘토링을 할 때마다 느끼는 건데 내가 잘하고 있는건지 잘 모르겠다

🗓️ 2025/01/07

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기 ✅ 집안일하기

📍 Study ✅ 멘토링 기록 최종 정리 ✅ 프로젝트 PR에 달린 commit 처리하기 ✅ 4주차 개발기록 작성하기 ✅ 프로젝트 일기 생성 구현하기 ➡️ 소요시간 : 일주일? ✅ 상태관리, API 테스트하는 법 찾아보기 ➡️ Jest로 테스트중 ✅ 공부용 프로젝트 초기 설정하기 ✅ React_Study Github readme 정리하기

💭 How do you feel today 새벽 2시에 강제 기상해서 열심히 살았🐓....

🗓️ 2025/01/08

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ❎ 프로젝트 일기 생성 구현하기 ➡️ 소요시간 : 일주일?

🗓️ 2025/01/09

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 프로젝트 일기 생성 구현하기 ➡️ 소요시간 : 일주일?

🗓️ 2025/01/10

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 프로젝트 일기 생성 구현하기 ➡️ 소요시간 : 일주일?

구현 완료한 부분

• 날짜 선택 시 제목에 있는 날짜가 선택한 날짜로 변경됨
• 태그를 추가할 수 있는 모달 및 모달에서 선택한 내용 갖고오고 삭제 가능
• 사진 추가영역에 react-dropzone 라이브러리로 구현

🗓️ 2025/01/13

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study 🔺 한입강의 기초부분 강의 다 듣기 ✅ 프로젝트 일기 생성에 API 연결하기

🗓️ 2025/01/14

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ❎ 한입강의 기초부분 강의 다 듣기 ✅ 프로젝트 일기 조회페이지 생성 및 API 연결하기

🗓️ 2025/01/15

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study ❎ 한입강의 기초부분 강의 다 듣기 ✅ 프로젝트 일기 수정 페이지 구상 ➡️ 생성/조회/수정 페이지를 각각 만들고 path가 동일하니 Router를 따로 만들어서 원하는 URL로 이동 유도할 예정

🗓️ 2025/01/16

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ [한입강의] 콜백함수까지 듣기 ✅ 일기 수정 페이지 구현 및 API 연동하기

🗓️ 2025/01/17

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 생성/조회/수정 별로 URL 이동하게끔 구현 ➡️ Mock 데이터를 만들고나서 해야하는데 Mock 데이터 구현에 시간이 걸릴 예정 ✅ 내가 작성한 코드 직접 쓰면서 공부하기 ✅ [한입강의] 배열까지 강의 듣기

🗓️ 2025/01/20

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study 🔺 생성/조회/수정 별로 URL 이동하게끔 구현 (중단) ➡️ create, view, update 코드 안에서 계속 수정이 이루어져서 추후 진행 ✅ 내가 작성한 코드 직접 쓰면서 공부하기 (create) ✅ [한입강의] truthy & falsy 한 값 강의 듣기

💭 How do you feel today 잘하고 있는지 하나도 모르겠다

🗓️ 2025/01/21

📍 Life ✅ 일기 쓰기 ❎ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 자바스크립트 실전 강의 [원시타입 VS 객체타입] 듣기

🗓️ 2025/01/22

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 프론트엔드서버 배포하는 법 공부하기 ✅ post API 배포값으로 조회페이지 띄울 수 있게 하기

🗓️ 2025/01/23 - 27

📍 Life ✅ 일기 쓰기 ✅ 유산균 + 종합 영양제 챙겨먹기

📍 Study ✅ 프론트엔드 환경 분리하기

🗓️ 2025/01/28

📍 Life ❎ 일기 쓰기 ❎ 1월 블로그 작성하기

📍 Study ❎ 백엔드에 보낼 이미지가 있을 경우 이미지를 format 하는 방법 찾아보고 구현해보기