전송 계층(OSI 7계층의 4계층)은 말 그대로 데이터를 전송하는 계층이다. 바로 아래의 네트워크 계층(IP)이 주소를 따라 어디까지 갈지를 결정한다면, 전송 계층은 그 안에서 “어떤 앱이 데이터를 보냈고, 어떻게 보낼지”를 책임진다.

📌 쉽게 말하면:

IP가 집 주소라면, TCP/UDP는 편지의 내용과 주고받는 방식이다.

✅ 2. TCP와 UDP란?

구분 TCP UDP 이름 Transmission Control Protocol User Datagram Protocol 목적 신뢰성 있는 전송 빠른 전송 연결 방식 연결 지향(Connection-oriented) 비연결형(Connectionless) 특징 순서 보장, 손실 복구, 흐름 제어, 혼잡 제어 순서 보장 안 됨, 손실 복구 안 됨 사용 예시 웹브라우저(HTTP), 이메일, 파일 전송 게임, 영상 스트리밍, 음성 통화

⸻

✅ 3. TCP (Transmission Control Protocol)

📌 핵심 개념

“신뢰성 있는 통신”을 위한 프로토콜. 데이터가 순서대로 도착하고, 손실 없이 정확하게 전달되도록 보장해줌.

⚙️ 동작 방식: 3-Way Handshake

Client ------> Server : SYN (접속 요청) Client <------ Server : SYN-ACK (승인 + 응답) Client ------> Server : ACK (응답 확인)

📦 연결 완료!

💡 이걸 3-Way Handshake라고 한다. 연결 전에 서로 약속을 맺는 절차라고 보면 된다.

📌 데이터 전송 • 데이터를 작은 세그먼트(Segment) 단위로 쪼개서 보냄. • 각각의 세그먼트에는 순서 번호(Sequence Number)가 붙음. • 수신 측은 ACK(응답)을 보내서 잘 받았는지 확인함. • 도중에 패킷이 유실되면 자동으로 재전송함. • 수신 속도가 느리면 흐름 제어로 속도를 조절함.

⚙️ 연결 종료: 4-Way Handshake

Client ------> Server : FIN (나 그만할래) Client <------ Server : ACK Client <------ Server : FIN (나도 이제 그만) Client ------> Server : ACK

📦 연결 종료!

✅ TCP의 장점 • 순서 보장 • 신뢰성 (오류 감지, 재전송) • 흐름 제어 (수신 속도에 맞춰 보냄) • 혼잡 제어 (네트워크 상태에 따라 속도 조절)

❌ 단점 • 속도 느림 • 오버헤드(검사, 제어 기능 많음) • 실시간성이 필요한 서비스엔 부적합

✅ TCP를 사용하는 사례

서비스 설명 HTTP/HTTPS 웹 페이지 요청/응답 FTP 파일 업로드/다운로드 SMTP/IMAP/POP3 이메일 송수신 SSH 원격 접속

✅ 4. UDP (User Datagram Protocol)

📌 핵심 개념

“속도가 중요한 통신”을 위한 프로토콜. 신뢰성은 낮지만 빠르게 전송됨. 연결 없이 그냥 던지고 마는 느낌이라 “비연결형 프로토콜”이라고 부른다.

⚙️ 동작 방식 • HandShake 없음 → 연결 X • 데이터그램(datagram)이라는 단위로 바로 전송 • 순서 보장 X • 응답(ACK) 없음 • 재전송 없음

✅ UDP의 장점 • 빠름 (지연 없음) • 오버헤드 적음 (검사 기능 최소화) • 실시간에 적합

❌ 단점 • 순서 바뀔 수 있음 • 중간에 유실돼도 모름 • 재전송도 없음

✅ UDP를 사용하는 사례

서비스 설명 온라인 게임 반응 속도가 가장 중요! 유튜브/넷플릭스 영상은 중간에 조금 끊겨도 됨 VoIP (음성 통화) 실시간 통화에서 속도가 중요 DNS 요청 단순한 요청–응답 처리

✅ 5. TCP와 UDP 구조 비교

🔸 TCP 헤더 구조 (복잡함)

| Source Port | Destination Port | | Sequence Number | | Acknowledgment Number | | Flags (SYN, ACK, FIN 등) | | Window Size | | Checksum | | Data |

🔸 UDP 헤더 구조 (간단함)

| Source Port | Destination Port | | Length | Checksum | | Data |

✅ 6. 둘 중 뭐를 써야 할까?

상황 TCP UDP 데이터 정확성이 중요함 ✅ ❌ 속도가 가장 중요함 ❌ ✅ 순서대로 받아야 함 ✅ ❌ 네트워크 상태가 불안정함 ✅ ❌ 대용량 파일 전송 ✅ ❌ 게임, 스트리밍, 통화 ❌ ✅

💡 비유로 정리하면

비유 TCP UDP 택배 📦 택배 회사: 배송 추적, 도착 확인, 정확 🛵 배달 오토바이: 빠르지만 잃어버릴 수도 있음 문자 메시지 카톡: 읽음 확인, 순서 보장 알림톡: 빠르지만 순서, 응답 없음

✅ 최종 요약

항목 TCP UDP 연결 방식 연결 지향 비연결형 신뢰성 O (재전송, 순서 보장) X (빠르게 던지고 끝) 속도 느림 빠름 오버헤드 큼 작음 사용처 웹, 이메일, 파일 게임, 영상, 음성

네트워크 계층(Network Layer, 3계층)은 데이터를 목적지까지 올바른 경로(Routing)를 통해 전달하는 역할을 한다.

이 계층에서 가장 중요한 프로토콜이 바로 IP(Internet Protocol)이다.

1️⃣ 네트워크 계층의 역할

네트워크 계층의 핵심 역할은 크게 두 가지다.

✅ 1. 논리적 주소 지정 (Logical Addressing)

• 각 장치에 고유한 주소(IP 주소)를 할당하여 통신할 수 있도록 함.

• 물리적인 위치(예: MAC 주소)와 달리, IP 주소는 네트워크 상황에 따라 변경 가능.

• 패킷을 목적지까지 정확하게 전달하는 역할.

✅ 2. 라우팅(Routing)

• 패킷이 출발지에서 목적지까지 가는 최적의 경로를 찾음.

• 라우터(Router)가 경로를 결정하고 패킷을 전달함.

2️⃣ IP (Internet Protocol)

IP는 인터넷에서 장치 간 데이터를 전달하는 핵심 프로토콜이다.

✅ IP의 주요 기능

• 데이터를 패킷(Packet) 단위로 나누어 전송.

• 목적지의 IP 주소를 보고 최적의 경로를 찾아 이동.

• 장치 간 논리적 주소 할당(IP 주소)을 담당.

✅ IP의 특징

• 비연결형(Connectionless) → 데이터가 목적지에 도착할지 보장하지 않음.

• 신뢰성 없음(Unreliable) → 패킷이 중간에 유실될 수도 있음.

• 최선형 전달(Best-effort Delivery) → 오류 검출이나 재전송 기능이 없음.

(💡 신뢰성 있는 데이터 전송을 위해 TCP(전송 계층)과 함께 사용됨!)

3️⃣ IP 주소 (IP Address)

IP 주소는 네트워크에서 장치를 식별하는 고유한 주소다.

현재 사용되는 IP 주소 체계는 IPv4와 IPv6 두 가지가 있음.

✅ IPv4 (Internet Protocol version 4)

• 32비트 주소 체계 (예: 192.168.1.1)

• 약 43억 개의 주소 제공 (부족 문제 발생)

• 10진수 점(.)으로 구분된 4개 옥텟(Octet)

• 예: 192.168.0.1

IPv4 주소 체계 (A~E 클래스)

✅ IPv6 (Internet Protocol version 6)

• 128비트 주소 체계 (예: 2001:db8::ff00:42:8329)

• 주소 공간이 무한에 가깝게 많음

• 16진수(:)로 구분된 8개 그룹

• 예: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

💡 IPv4 주소 부족 문제를 해결하기 위해 등장했으며, 현재 점점 IPv6로 전환 중.

4️⃣ 공인 IP vs 사설 IP

IP 주소는 크게 공인 IP와 사설 IP로 나뉜다.

✅ 공인 IP (Public IP)

• 인터넷에 직접 연결되는 IP 주소.

• 전 세계에서 유일하게 배정됨.

• ISP(인터넷 서비스 제공 업체)에서 제공.

✅ 사설 IP (Private IP)

• 내부 네트워크에서만 사용되는 IP 주소.

• 인터넷과 직접 연결되지 않으며 NAT(Network Address Translation)를 통해 공인 IP로 변환.

• IPv4에서 주소 부족 문제를 해결하기 위해 사용됨.

사설 IP 주소 범위:

(💡 우리가 Wi-Fi에 연결된 기기들은 일반적으로 사설 IP를 사용함.)

5️⃣ IP 패킷 구조

IP는 데이터를 패킷(Packet) 단위로 나누어 전송한다.

IP 패킷은 크게 헤더(Header)와 페이로드(Payload)로 구성된다.

✅ IP 패킷의 구조

(💡 TTL(Time To Live): 패킷이 네트워크를 몇 번 통과할 수 있는지 제한하는 값. 0이 되면 폐기됨.)

6️⃣ IP와 함께 사용하는 프로토콜

IP는 혼자서는 신뢰성 있는 통신을 보장하지 않기 때문에, 다음 프로토콜들과 함께 사용된다.

💡 정리

✅ 네트워크 계층은 데이터가 최적의 경로로 목적지까지 도달하도록 관리

✅ IP(Internet Protocol)은 네트워크에서 데이터를 패킷으로 분할해 전달하는 핵심 프로토콜

✅ IPv4(32비트) vs IPv6(128비트) → IPv6는 주소 부족 문제 해결

✅ 공인 IP vs 사설 IP → 사설 IP는 NAT를 통해 인터넷 연결

✅ IP 패킷 구조 → TTL, 출발지 IP, 목적지 IP 등의 정보 포함

✅ ICMP, ARP, NAT, DHCP 같은 보조 프로토콜과 함께 사용됨

네트워크의 기본 구조를 이해하려면 OSI 7계층 모델을 알아야 하는데, 그중에서도 1계층(물리 계층)과 2계층(데이터 링크 계층)은 네트워크의 하드웨어적 요소와 관련이 깊다

1️⃣ 물리 계층 (Physical Layer)

네트워크에서 데이터를 전기 신호, 빛 신호, 무선 신호 등의 형태로 변환하여 전송하는 역할을 함.

✅ 주요 기능

• 데이터를 0과 1(비트, Bit) 형태로 변환하여 전송

• 전송 매체(케이블, 광섬유, 전파 등)를 통해 데이터 이동

• 전송 속도, 신호의 세기, 전압 수준, 주파수, 변조 방식 등 정의

• 네트워크 장비 간 물리적 연결(플러그, 커넥터, 케이블 등) 담당

✅ 대표적인 장비 & 기술

✅ 데이터 전송 방식

• 단방향(Simplex): 한 방향으로만 데이터 전송 (TV 방송, 라디오)

• 반이중(Half-duplex): 양방향 전송 가능하지만 한 번에 한 방향만 가능 (무전기)

• 전이중(Full-duplex): 양방향 동시 전송 가능 (전화 통화)

2️⃣ 데이터 링크 계층 (Data Link Layer)

물리 계층을 통해 전송된 데이터를 오류 없이 안정적으로 전달하는 역할을 함.

네트워크에서 MAC 주소를 이용해 장치 간 데이터 전송을 제어하고, 충돌을 방지함.

✅ 주요 기능

• 프레임(Frame) 단위로 데이터 전송

• MAC 주소를 이용한 장치 식별

• 오류 감지 및 재전송 기능

• 흐름 제어(Flow Control): 송신 속도가 너무 빠르면 조절

• 충돌 방지(Collision Handling)

• 네트워크를 논리적 링크(LAN, VLAN)로 분할하는 역할

✅ 대표적인 장비 & 기술

✅ 데이터 링크 계층의 하위 계층

데이터 링크 계층은 두 개의 하위 계층으로 나뉨.

✅ MAC 주소 vs IP 주소

3️⃣ 물리 계층과 데이터 링크 계층 비교

💡 정리

✅ 물리 계층(1계층): 데이터를 신호로 변환하여 전송하는 역할

✅ 데이터 링크 계층(2계층): MAC 주소를 이용하여 신뢰성 있게 데이터 전송

✅ 물리 계층은 비트(Bit) 단위, 데이터 링크 계층은 프레임(Frame) 단위로 데이터 처리

✅ 물리 계층의 장비: 허브, 리피터, 모뎀, 케이블

✅ 데이터 링크 계층의 장비: 스위치, 브리지, 네트워크 인터페이스 카드(NIC)

✅ MAC 주소 vs IP 주소: MAC 주소는 하드웨어 고유 주소, IP 주소는 네트워크에서 변경 가능

네트워크는 노드와 간선으로 이루어진 자료구조라는 점에서 그래프의 형태를 띈다고 할수있다.

네트워크 기기 - 노드 랜선 or WIFI - 간선

네트워크의 기본 구조는 데이터를 송수신하는 기기들과 이를 연결하는 방식으로 구성된다. 크게 보면 네트워크는 노드(Node), 링크(Link), 프로토콜(Protocol) 로 이루어진다.

네트워크의 기본 구성 요소

🔹 노드(Node)

네트워크에서 데이터를 주고받는 모든 장치를 노드라고 한다.

예를 들어:

• 호스트(Host): 컴퓨터, 스마트폰, 서버 등

• 네트워크 장비: 라우터, 스위치, 허브 등

🔹 링크(Link)

노드 간에 데이터를 주고받을 수 있도록 연결하는 물리적 또는 논리적 경로.

• 유선(Wired): 이더넷(Ethernet) 케이블, 광케이블

• 무선(Wireless): Wi-Fi, LTE, 5G

🔹 프로토콜(Protocol)

네트워크에서 데이터를 송수신하는 규칙과 절차를 정의한 것.

대표적인 프로토콜:

• IP(Internet Protocol): 장치에 주소를 부여하고 데이터를 전달하는 규칙

• TCP(Transmission Control Protocol): 신뢰성 있는 데이터 전송

• UDP(User Datagram Protocol): 빠르지만 신뢰성이 낮은 데이터 전송

네트워크의 계층 구조 (OSI 7계층 & TCP/IP 4계층)

네트워크는 데이터를 효율적으로 전달하기 위해 계층 구조를 가진다.

🔸 OSI 7계층 모델과 실제로 많이 쓰이는 TCP/IP 4계층 모델을 살펴보자.

🔸 OSI 7계층 (이론적인 네트워크 모델)

🔸 TCP/IP 4계층 (실제 인터넷에서 쓰이는 모델)

네트워크의 유형

🏠 LAN (Local Area Network) - 근거리 네트워크

• 작은 범위(가정, 회사)에서 사용

• 빠른 속도(Ethernet, Wi-Fi)

🌎 WAN (Wide Area Network) - 광역 네트워크

• 여러 도시, 국가 간 연결 (ex. 인터넷)

• 라우터, 광섬유 케이블을 사용

🔄 VPN (Virtual Private Network) - 가상 사설망

• 공용 네트워크를 사용하지만, 보안이 강화된 사설 네트워크처럼 동작

• 터널링(Tunneling) 기법을 사용해 데이터 암호화

네트워크의 기본 동작 방식

✔ 패킷(Packet) 기반 통신

네트워크에서는 데이터를 작은 조각(패킷)으로 나누어 전송한다.

패킷은 출발지 주소, 목적지 주소, 데이터 등을 포함한다.

✔ 라우팅(Routing)

패킷이 출발지에서 목적지까지 가는 경로를 찾는 과정.

• 라우터(Router)가 경로를 결정하고 패킷을 전달한다.

• IP 주소와 서브넷 마스크를 이용해 네트워크를 구분한다.

✔ DNS(Domain Name System)

• 우리가 흔히 사용하는 웹사이트 주소(예: google.com)를 실제 IP 주소(예: 142.250.190.78)로 변환하는 역할.

5. 네트워크의 핵심 장비

6. 네트워크 보안 개념

🔐 방화벽(Firewall)

• 외부에서 내부 네트워크로의 접근을 차단하거나 제한하는 보안 장비.

🔐 IDS/IPS (침입 탐지/방지 시스템)

• IDS(침입 탐지 시스템): 비정상적인 트래픽을 감지

• IPS(침입 방지 시스템): 감지 후 공격을 차단

🔐 HTTPS (Hypertext Transfer Protocol Secure)

• SSL/TLS 암호화를 통해 HTTP 통신을 안전하게 보호

💡 정리

✅ 네트워크는 노드(Node), 링크(Link), 프로토콜(Protocol)로 구성됨

✅ 계층 구조는 OSI 7계층 모델과 TCP/IP 4계층 모델이 있음

✅ 네트워크는 패킷(Packet) 기반으로 동작하고 라우팅(Routing)을 통해 경로를 찾음

✅ LAN/WAN/VPN 같은 네트워크 유형이 있으며, 라우터/스위치/허브 등의 장비가 있음

✅ 보안을 위해 방화벽, IDS/IPS, HTTPS 등의 기술이 사용됨

트리(Tree)란?

트리는 계층적인 관계를 표현하는 자료구조다. 여러 개의 데이터를 부모-자식 관계로 연결하여 저장하는 방식.

예시

• 가족 족보 → 조상이 있고, 그 아래로 자식, 손자가 계층적으로 이어짐.
• 회사 조직도 → CEO가 있고, 그 아래로 부서장이 있고, 부서장 아래에 직원들이 있음.
• 폴더 구조 → 컴퓨터에서 하나의 폴더 안에 여러 파일과 하위 폴더가 포함될 수 있음.

트리는 한 개의 최상위 노드(루트)에서 시작해서 가지처럼 뻗어나가는 구조이다.

트리의 기본 개념

트리의 구성 요소

트리의 특징

1️⃣ 루트에서 시작해 여러 개의 자식 노드로 가지를 뻗어나간다. 2️⃣ 하나의 노드는 한 개의 부모 노드만 가질 수 있다 (단, 루트 노드는 부모가 없음). 3️⃣ 트리는 사이클이 없다 (순환 구조가 불가능함). 4️⃣ 깊이(depth)와 높이(height) 개념이 존재한다.

트리의 종류

1️⃣ 일반 트리 (General Tree)

• 하나의 부모가 여러 개의 자식을 가질 수 있는 트리.
• 예시: 회사 조직도, 족보, 폴더 구조.

2️⃣ 이진 트리 (Binary Tree)

• 모든 노드가 최대 2개의 자식 노드만 가질 수 있는 트리.
• 예시: 이진 검색 트리(Binary Search Tree, BST), 힙(Heap)

3️⃣ 이진 탐색 트리 (BST, Binary Search Tree)

• 왼쪽 자식은 부모보다 작은 값, 오른쪽 자식은 부모보다 큰 값을 가지는 이진 트리.
• 데이터 검색, 정렬에 효율적 (O(log n) 시간복잡도).
• 예시: 검색 엔진 자동완성 기능, 데이터베이스 인덱스.

4️⃣ 균형 트리 (Balanced Tree)

• 높이가 일정하게 유지되도록 자동 정렬되는 트리.
• 예시: AVL 트리, 레드-블랙 트리 (빠른 검색을 위해 사용됨).

5️⃣ 힙(Heap) 트리

• 부모가 항상 자식보다 크거나(최대 힙), 작도록(최소 힙) 정렬되는 트리.
• 예시: 우선순위 큐 (Priority Queue), 작업 스케줄링 시스템.

6️⃣ B-Tree / B+Tree

• 데이터베이스 인덱스 구조로 사용되는 트리. 검색 속도를 빠르게 하기 위해 설계됨.
• 예시: MySQL, MongoDB 같은 데이터베이스에서 사용.

트리의 활용 예시

1️⃣ 파일 시스템

• 📁 폴더 안에 여러 개의 파일과 하위 폴더가 포함되는 구조.
• 트리 구조로 구성되어 있어 탐색이 편리함.

2️⃣ 검색 엔진 자동완성

• 🔎 구글 검색창에서 "hello"를 입력하면 "hello world" 같은 추천 단어가 뜨는 기능.
• Trie(트라이) 트리라는 자료구조를 활용하여 빠르게 단어 검색 가능.

3️⃣ 게임 AI & 의사결정 트리

• 🤖 체스 AI가 다음 수를 결정할 때 트리 탐색을 이용해 최적의 선택을 찾음.
• 🎮 RPG 게임에서 퀘스트 분기점을 결정할 때도 사용됨.

4️⃣ 데이터베이스 인덱스 (B-Tree, B+Tree)

• 📊 데이터베이스에서 데이터를 빠르게 찾기 위해 사용됨.
• 대용량 데이터 검색을 최적화하는 역할.

5️⃣ 네트워크 라우팅 (인터넷 패킷 전달)

• 🌐 인터넷에서 데이터가 목적지까지 갈 때 최적의 경로를 찾기 위해 라우팅 트리를 사용함.

트리 탐색 알고리즘

1️⃣ DFS (Depth First Search, 깊이 우선 탐색)

• 한 방향으로 깊이 탐색한 후, 더 이상 갈 곳이 없으면 돌아옴.
• 예시: 미로 찾기, 퍼즐 게임에서 경로 찾기.

function dfs(node) {
    if (!node) return;
    console.log(node.value); // 방문한 노드 출력
    dfs(node.left);
    dfs(node.right);
}

2️⃣ BFS (Breadth First Search, 너비 우선 탐색)

• 같은 레벨의 노드를 먼저 탐색한 후, 다음 레벨로 이동.
• 예시: 최단 거리 찾기 (네비게이션, AI 경로 탐색).

function bfs(root) {
    let queue = [root];
    while (queue.length) {
        let node = queue.shift();
        console.log(node.value);
        if (node.left) queue.push(node.left);
        if (node.right) queue.push(node.right);
    }
}

마무리

1️⃣ 트리는 부모-자식 관계를 가지는 계층적 자료구조이다. 2️⃣ 이진 탐색 트리(BST)는 검색이 빠른 트리 구조이다. 3️⃣ DFS / BFS 탐색 알고리즘이 있다 (미로 찾기, AI 등에서 활용). 4️⃣ 트리는 파일 시스템, 데이터베이스, AI, 검색 엔진 등 실생활에서 다양하게 활용된다.

그래프(Graph)는 여러 개의 노드(Node, 정점)들이 연결된 자료구조다.

트리가 부모-자식 관계로 연결된 계층적 구조였다면, 그래프는 좀 더 자유로운 연결 구조를 갖고 있다

즉, 어떤 데이터들이 서로 연결될 수 있는지 표현하는 강력한 자료구조.

✅ 그래프란?

그래프는 노드(Node, 정점) 들과 이들을 연결하는 간선(Edge) 들로 이루어진 자료구조이다.

각 노드는 여러 개의 다른 노드와 연결될 수 있으며, 연결의 방향과 유무에 따라 그래프의 종류가 달라진다.

쉽게 비유하면?

• 도시 지도 : 각 도시(노드)들이 도로(간선)로 연결된 모습 • SNS 친구 관계 : 유저(노드)들이 서로 친구 요청(간선)을 보내서 연결된 모습

그래프의 기본 용어

노드(Node)와 간선(Edge)

A, B, C 세 개의 노드가 있다고 가정해보자.

A ↔ B, B ↔ C로 연결되어 있다면?

A - B - C (연결 상태)

여기서 A, B, C는 노드(Node), A-B, B-C는 간선(Edge)

그래프의 종류

그래프는 방향성과 가중치에 따라 여러 가지로 나뉜다.

1️⃣ 방향 그래프(Directed Graph) vs 무방향 그래프(Undirected Graph)

1. 무방향 그래프 (Undirected Graph)

• 간선에 방향이 없음

• A ↔ B (A에서 B로 갈 수도 있고, B에서 A로도 갈 수 있음)

• 예시: SNS 친구 관계, 도로 양방향 통행

A - B - C

여기서 A-B, B-C는 서로 양방향 연결이 가능

2. 방향 그래프 (Directed Graph, Digraph)

• 간선에 방향이 있음 (한쪽으로만 이동 가능)

• A → B (A에서 B로 갈 수 있지만, B에서 A로 못 감)

• 예시: 트위터 팔로우, 도로 일방통행

A → B → C

A에서 B로 갈 수 있지만, B에서 A로 돌아올 수 없음.

2️⃣ 가중치 그래프(Weighted Graph) vs 비가중치 그래프(Unweighted Graph)

1. 비가중치 그래프

• 간선에 가중치가 없음 (연결 유무만 중요)

• 예시: SNS 친구 관계 (그냥 친구 여부만 중요)

2. 가중치 그래프 (Weighted Graph)

• 간선에 비용이 있음 (거리, 시간 등)

• 예시: 지도에서 도시 간의 거리(서울↔부산 400km, 서울↔대전 140km)

A --(4)--> B --(2)--> C

여기서 A→B 가중치는 4, B→C 가중치는 2

그래프의 표현 방법

그래프를 코드로 표현하는 방법은 여러 가지가 있다

주로 인접 행렬(Adjacency Matrix) 과 인접 리스트(Adjacency List) 두 가지 방식이 많이 쓰인다.

1️⃣ 인접 행렬 (Adjacency Matrix)

• 그래프를 2차원 배열로 표현

• 노드 개수 n이면, n×n 행렬(배열)을 사용

• 공간 복잡도: O(n²) (노드 개수가 많으면 메모리 낭비 심함)

• 탐색 속도 빠름 (O(1))

// 3개의 노드(A, B, C)
const graph = [
  [0, 1, 0],  // A → B
  [1, 0, 1],  // B → A, B → C
  [0, 1, 0]   // C → B
];

console.log(graph[0][1]); // 1 (A→B 연결됨)
console.log(graph[0][2]); // 0 (A→C 연결 안 됨)

행렬에서 1이면 연결됨, 0이면 연결되지 않음

2️⃣ 인접 리스트 (Adjacency List)

• 노드별로 연결된 노드 리스트를 저장

• 공간 효율적 (O(V + E), 노드+간선 개수만큼)

• 탐색 속도는 다소 느릴 수 있음 (O(V))

const graph = {
  A: ["B"],
  B: ["A", "C"],
  C: ["B"]
};

console.log(graph["A"]); // ['B'] (A는 B와 연결됨)
console.log(graph["B"]); // ['A', 'C'] (B는 A, C와 연결됨)

각 노드별로 연결된 노드를 리스트로 저장하는 방식

그래프 탐색 (Graph Traversal)

그래프에서 모든 노드 방문하기 위해 DFS와 BFS 탐색 방법이 사용됨

1️⃣ DFS (깊이 우선 탐색, Depth First Search)

• 한 갈래를 끝까지 탐색한 후 돌아오는 방식

• 재귀(Recursive) 또는 스택(Stack) 사용

• 주로 경로 찾기 문제에 사용

const graph = {
  A: ["B", "C"],
  B: ["A", "D", "E"],
  C: ["A", "F"],
  D: ["B"],
  E: ["B", "F"],
  F: ["C", "E"]
};

function dfs(node, visited = new Set()) {
  if (visited.has(node)) return;
  console.log(node); // 방문 출력
  visited.add(node);

  for (let neighbor of graph[node]) {
    dfs(neighbor, visited);
  }
}

dfs("A"); // A → B → D → E → F → C

2️⃣ BFS (너비 우선 탐색, Breadth First Search)

• 같은 레벨의 노드들을 먼저 탐색

• 큐(Queue) 사용

• 최단 경로 문제에 자주 사용

function bfs(start) {
  let queue = [start];
  let visited = new Set();

  while (queue.length > 0) {
    let node = queue.shift();
    if (visited.has(node)) continue;
    console.log(node); // 방문 출력
    visited.add(node);

    for (let neighbor of graph[node]) {
      queue.push(neighbor);
    }
  }
}

bfs("A"); // A → B → C → D → E → F

BFS는 큐(Queue)를 이용해 같은 레벨 노드를 먼저 방문한다.

최단 경로 문제(미로 찾기, 지도 길 찾기)에 자주 사용됨

그래프 활용 예제

✔ 네트워크 연결: 컴퓨터 네트워크, 친구 관계, 추천 시스템

✔ SNS 관계 분석: 페이스북, 인스타그램의 친구 추천

✔ 지도 및 길 찾기: 네비게이션, 지하철 노선도

✔ 웹 크롤링: 페이지 간의 링크 구조 분석

✔ AI & 경로 탐색: 최적 경로 찾기 (A* 알고리즘)

마무리

✅ 그래프는 노드(Node)와 간선(Edge)로 이루어진 자료구조

✅ 방향 그래프 / 무방향 그래프, 가중치 그래프 / 비가중치 그래프가 있음

✅ 그래프 표현 방식: 인접 행렬 vs 인접 리스트

✅ 탐색 방법: DFS(깊이 우선 탐색), BFS(너비 우선 탐색)

✅ 실생활에서 다양한 문제 해결에 사용됨

1️⃣ 트리(Tree)란?

✅ 트리의 개념

트리는 계층적인 구조를 가진 비선형 자료구조입니다. 일반적으로 부모-자식 관계를 가지며, 루트 노드(Root Node)에서 시작해 여러 개의 자식 노드(Child Node)로 분기된다.

✅ 트리의 주요 특징

• 계층적 구조: 부모-자식 관계를 가짐.
• 사이클 없음: 트리는 비순환 그래프(Directed Acyclic Graph, DAG).
• 노드(Node)와 간선(Edge)으로 구성: 한 노드는 여러 개의 자식을 가질 수 있음.
• 트리는 하나의 루트(Root) 노드에서 시작: 모든 노드는 하나의 부모를 가짐 (예외: 루트 노드)
• 트리의 깊이(Depth)와 높이(Height) 개념 중요
  • 깊이(Depth): 루트 노드에서 특정 노드까지의 거리
  • 높이(Height): 특정 노드에서 가장 깊은 리프 노드까지의 거리

✅ 트리 용어 정리

✅ 트리의 종류

1. 일반 트리 (General Tree)

   • 자식 노드의 개수에 제한이 없는 트리.

2. 이진 트리(Binary Tree)

   • 각 노드가 최대 두 개의 자식을 가질 수 있는 트리.
   • 예제 코드 (JavaScript):

   class Node {
       constructor(value) {
           this.value = value;
           this.left = null;
           this.right = null;
       }
   }
   
   const root = new Node(1);
   root.left = new Node(2);
   root.right = new Node(3);

3. 이진 탐색 트리(Binary Search Tree, BST)

   • 왼쪽 자식 노드는 부모보다 작고, 오른쪽 자식 노드는 부모보다 큼.
   • 예제 코드 (JavaScript):

   class BST {
       constructor(value) {
           this.value = value;
           this.left = null;
           this.right = null;
       }
   
       insert(value) {
           if (value < this.value) {
               if (this.left === null) {
                   this.left = new BST(value);
               } else {
                   this.left.insert(value);
               }
           } else {
               if (this.right === null) {
                   this.right = new BST(value);
               } else {
                   this.right.insert(value);
               }
           }
       }
   }
   
   const root = new BST(10);
   root.insert(5);
   root.insert(15);

4. 균형 트리 (Balanced Tree)

   • AVL 트리: 노드의 균형을 유지하기 위해 회전 연산(Rotation)을 수행하는 트리.
   • 레드-블랙 트리 (Red-Black Tree): 삽입 및 삭제 연산 시 균형을 유지하는 이진 탐색 트리.

5. 힙(Heap) 트리

   • 최대 힙(Max Heap) → 부모 노드가 항상 자식보다 큼.
   • 최소 힙(Min Heap) → 부모 노드가 항상 자식보다 작음.

✅ 트리 순회 방법 (Tree Traversal)

트리의 노드를 탐색하는 방법에는 DFS(깊이 우선 탐색)과 BFS(너비 우선 탐색)이 있다.

1. DFS (Depth First Search, 깊이 우선 탐색)

   • 전위 순회 (Preorder Traversal): 루트 → 왼쪽 → 오른쪽
   • 중위 순회 (Inorder Traversal): 왼쪽 → 루트 → 오른쪽
   • 후위 순회 (Postorder Traversal): 왼쪽 → 오른쪽 → 루트

   function inorderTraversal(node) {
       if (node !== null) {
           inorderTraversal(node.left);
           console.log(node.value);
           inorderTraversal(node.right);
       }
   }
   inorderTraversal(root);

2. BFS (Breadth First Search, 너비 우선 탐색)

   • 큐(Queue)를 이용하여 레벨 단위로 탐색함.

   function bfsTraversal(root) {
       let queue = [root];
       while (queue.length > 0) {
           let node = queue.shift();
           console.log(node.value);
           if (node.left) queue.push(node.left);
           if (node.right) queue.push(node.right);
       }
   }
   bfsTraversal(root);

✅ 트리의 활용 예시

• 파일 시스템 (디렉토리 구조)
• 데이터베이스 인덱싱 (B-Tree, B+Tree)
• HTML DOM 구조
• AI, 게임에서의 의사결정 트리
• 네트워크 라우팅 (최단 경로 탐색)

3️⃣ 집합(Set)의 내부 동작

✅ JavaScript의 Set 객체 내부 원리

• JavaScript의 Set은 해시 테이블(Hash Table)을 기반으로 동작한다.
• 해시 테이블은 키-값(Key-Value) 구조를 사용하여 O(1) 시간 복잡도로 데이터를 찾을 수 있다.
• 즉, Set.has(value) 연산은 매우 빠르게 수행된다.

const mySet = new Set();
mySet.add(1);
mySet.add(2);
mySet.add(3);
console.log(mySet.has(2)); // true
console.log(mySet.size); // 3

✅ Set을 이용한 중복 제거

const arr = [1, 2, 2, 3, 4, 4, 5];
const uniqueArr = [...new Set(arr)];
console.log(uniqueArr); // [1, 2, 3, 4, 5]

트리와 집합의 기본적인 개념은 직관적이라 쉬웠지만.. 조금만 파고들어가니 아니나 다를까 이건 또 뭔소리인가 싶었다.

트리는 예를 들자면 족보나 폴더 구조를 떠올려보면 쉽게 이해 할 수 있고 집합은 쇼핑할 때 장바구니나 누군가의 버킷리스트를 떠올려보면 쉽게 이해 할 수 있다.

파일 시스템은 운영체제가 보조기억장치에 있는 데이터를 파일과 디렉터리 형태로 관리하는 체계다.

• 데이터가 무질서하게 저장되면 찾기 힘들고 관리도 어려움 • 파일 시스템이 이름, 경로, 속성 등으로 데이터를 효율적으로 관리 • 손상 방지, 빠른 접근성, 데이터 보안까지 가능하다

2. 파일과 디렉터리

2-1. 파일(File)

파일은 데이터를 저장하는 기본 단위.

구성 요소:

• 파일 이름: 사용자가 파일을 구별하는 이름 • 메타데이터(Metadata): 파일의 속성 정보 (파일 크기, 위치, 생성일, 수정일, 권한 등) • 데이터(Data): 실제 내용 (문서, 이미지, 실행 파일 등)

메타데이터가 왜 중요하냐

• 파일 검색 속도 증가 • 보안 설정 가능 (읽기/쓰기 권한 등) • 수정 및 접근 이력 관리

2-2. 디렉터리(Directory)

디렉터리는 파일과 다른 디렉터리를 조직적으로 모아 놓은 컨테이너.

Windows: 폴더 Mac,Linux: 디렉터리라고 부른다

디렉터리 구조

• 트리 구조(Tree Structure): 계층적인 구조 • 루트 디렉터리(/): 최상위 폴더 • 서브 디렉터리: 하위 폴더

경로(Path)

• 절대 경로: 루트(/)부터 시작 → /home/user/docs/file.txt • 상대 경로: 현재 위치 기준 → ../docs/file.txt

중요! 디렉터리도 결국 “파일”이다

• 디렉터리 = 파일 목록을 담고 있는 특별한 파일 • 디렉터리 엔트리(Directory Entry) 에 파일 이름 + 파일 위치 정보 포함

3. 파일 디스크립터(File Descriptor)와 시스템 콜

3-1. 파일 디스크립터(File Descriptor)

파일을 사용할 때 운영체제가 파일을 식별하기 위해 부여하는 정수 값이다.

• Linux/Unix: 파일 디스크립터 • Windows: 파일 핸들(File Handle)

대표적인 파일 디스크립터 번호

3-2. 시스템 콜(System Call)

응용 프로그램이 운영체제의 자원을 요청할 때 사용하는 인터페이스.

파일 관련 주요 시스템 콜:

• open(): 파일 열기 → 파일 디스크립터 반환 • write(): 파일 쓰기 → 디스크립터 필요 • read(): 파일 읽기 • close(): 파일 닫기

왜 시스템 콜을 사용하냐

• 사용자 프로그램이 직접 메모리나 하드 접근 못하게 막아서 보안 강화 • 운영체제가 권한 관리하고 자원 낭비 방지

4. 파일 할당 방식 (보조기억장치에 파일 저장 방법)

4-1. 블록 단위 저장

• 보조기억장치 → 블록(Block) 단위로 데이터를 저장 • 블록 크기: 보통 4KB • 하나의 파일 = 여러 블록에 분산 저장 가능

4-2. 파일 할당 기법

(1) 연속 할당(Contiguous Allocation)

• 연속된 블록에 파일을 저장

장점: 빠른 접근

단점: 외부 단편화 발생, 파일 크기 예측 어려움

(2) 연결 할당(Linked Allocation)

• 각 블록에 다음 블록의 주소 저장

장점: 단편화 해결

단점: 임의 접근 속도 느림 (순차 접근만 빠름)

(3) 색인 할당(Indexed Allocation)

• 모든 블록 주소를 색인 블록에 저장

장점: 빠른 임의 접근 가능

단점: 색인 블록이 커질 수 있음

5. 아이노드(Inode)와 EXT4 파일 시스템

5-1. 아이노드(Inode)란?

Linux와 macOS 같은 시스템에서는 아이노드라는 구조체로 파일 정보를 관리한다.

아이노드에 저장된 정보:

• 파일 크기, 생성일, 수정일 • 파일 권한 및 소유자 • 데이터 블록 주소(중요!)

아이노드에는 “파일 이름”이 없음

→ 파일 이름은 디렉터리 엔트리에서 관리

5-2. EXT4 파일 시스템 구조

EXT4는 Linux에서 가장 널리 쓰이는 파일 시스템

구성 요소

5-3. 아이노드와 디렉터리 관계

디렉터리 엔트리 구조

디렉터리는 결국 “아이노드 번호 목록”을 가진 파일이라고 보면 된다.

?? 아이노드와 파일 디스크립터 비교

아이노드(Inode) vs 파일 디스크립터(File Descriptor)

아이노드와 파일 디스크립터, 둘 다 “파일과 관련된 정보”지만 역할이 완전히 다르다

• 아이노드: 파일의 영구적인 정보 (크기, 위치, 권한 등)를 관리 • 디스크립터: 파일을 현재 열고 있는 프로세스가 사용하기 위한 임시 번호

쉽게 정리하자면

• 아이노드: 파일의 주민등록번호 카드 → 항상 존재 & 영구 정보 • 디스크립터: 파일 열 때 받는 일회용 번호표 → 작업 끝나면 사라짐

커피를 고를 때 메뉴판 보고 주문하면 진동벨을 받는 것처럼 아이노드로 파일 위치를 확인하고 디스크립터로 파일을 다룬다.

6. 링크 파일: 하드 링크 vs 심볼릭 링크

6-1. 하드 링크(Hard Link)

• 같은 아이노드를 공유하는 다른 이름의 파일 • 원본 삭제 시에도 데이터 유지 (링크가 남아 있으면 파일 유효)

6-2. 심볼릭 링크(Symbolic Link)

• 원본 파일 경로를 저장한 파일 (Windows 바로가기 개념) • 원본 삭제 시 링크 깨짐

7. 마운트(Mount)

7-1. 마운트란?

• 외부 저장장치(USB, 외장하드 등)를 운영체제에 연결해 사용하는 과정

예: USB 연결 시 /mnt/usb 경로에서 접근 가능

자동 마운트 vs 수동 마운트

마운트와 링크 파일의 차이

마무리.

1. 논리 주소(Logical Address) CPU가 생성한 주소로 가상주소 라고도 불린다. 프로세스는 메모리 할당 시 실제 물리주소를 직접 알지 못한다. 이 논리 주소는 CPU 내부의 레지스터에서 생성된다.
2. 물리주소(Physical Address) 실제 RAM에서 데이터가 저장되는 위치의 주소 논리 주소와 달리, 메모리 컨트롤러가 실제 메모리 접근에 사용된다.

주소 변환 과정 (MMU의 역할)

MMU (Memory Management Unit) 는 논리 주소를 물리 주소로 변환하는 장치다.

동적/정적 주소 바인딩

• 정적 바인딩 : 컴파일 시 주소 결정 (물리적 이동 불가능)
• 동적 바인딩 : 실행 시 주소 결정 (가상 메모리 구현 가능) 가상 메모리 -> 동적 주소 바인딩이 필수다.

스와핑과 연속 메모리 할당

스와핑은 프로세스를 메모리에서 디스크로 내보냈다가 필요 시 다시 불러오는 것이다. 스와핑을 사용하는 이유는 메모리 공간 확보 와 CPU 유휴 방지 로 사용한다.

스와핑 과정

1. 메모리에 공간 부족 -> 실행 중인 프로세스 중 비활성 상태 찾음
2. 해당 프로세스를 디스크에 저장
3. 새 프로세스가 메모리에 올라감
4. 이전 프로세스 필요 시 다시 메모리로 불러오기

스레싱

스와핑이 지나치게 자주 발생하면 시스템 성능이 급격하게 저하된다.

연속 메모리 할당 (Contiquous Memory Allocation)

프로세스가 메모리에 연속된 블록으로 할당받는 방식이다. 주소 계산이 간단해 빠른 접근이 가능하고 하드웨어 구현이 쉽지만 메모리의 빈 공간이 작은 조각들로 흩어져 큰 프로세스 수용이 불가하고 내부 단편화로 할당된 메모리보다 작은 프로세스가 공간 낭비.

페이징을 통한 가상 메모리 관리

페이징 기법이란 가상 메모리와 물리 메모리를 같은 크기의 블록으로 나누어 관리하는 방법이다.

• 가상 메모리 = 페이지(Page)
• 물리 메모리 = 프레임(Frame) 페이지와 프레임 크기가 같아서, 페이지가 프레임에 딱 맞게 들어간다.

페이징 과정

1. 가상 주소 = 페이지 번호 + 오프셋 -> 페이지 테이블 확인 = 해당 페이지의 물리적 프레임 찾기.

-> 물리 주소 = 프레임 번호 + 오프셋

페이지 테이블과 주소 변환

페이지 테이블 (Page Table) 페이지 번호와 해당 프레임 번호를 매핑 프로세스 마다 자신만의 페이지 테이블을 가진다

페이지부재(Page Fault)

CPU가 참조하려는 페이지가 메모리에 없을 때 발생한다.

페이지 교체 알고리즘

페이지 교체가 왜 필요할까?

메모리 공간이 가득 찼는데 새로운 페이지가 필요하면 기존 페이지 중 하나를 제거해야 한다. 여기서 어떤 페이지를 제거할지 결정하는게 페이지 교체 알고리즘.

교체 알고리즘 종류

1. FIFO (Forst In First Out) 가장 먼저 들어온 페이지 제거 단순하지만, Belady의 이상현상 발생 가능
2. LRU (Least Recently Used) 가장 오래 사용되지 않은 페이지 제거 과거 사용 패턴 기반이라 현실적이지만, 최근 사용 기록 관비 비용이 크다.
3. Optimal (최적 교체) 앞으로 가장 오랫동안 사용되지 않을 페이지 제거 이론적으로 최적 미래참조를 예측할 수 없어 실전 사용불가
4. Second Chance (Clock Algorithm) FIFO 개선 버전 각 페이지에 참조 비트가 1이면 다시 기회 부여 참조 비트가 0이면 제거

CPU 스케줄링은 운영체제가 CPU를 여러 프로세스에 어떻게 할당할지 결정하는 과정이다.

• 다수의 프로세스가 동시에 실행될 때, CPU는 한 번에 하나의 프로세스만 실행할 수 있기 때문에 효율적 할당이 중요.

• 스케줄링 알고리즘을 통해 응답 시간, 처리량, 공정성 등을 최적화한다.

CPU 스케줄링의 목적

✅ CPU 사용률 최대화: CPU가 가능한 한 놀지 않도록 유지

✅ 처리량(Throughput) 증가: 단위 시간당 완료된 작업 수 증가

✅ 대기 시간 최소화: 프로세스가 대기 큐에서 기다리는 시간 감소

✅ 응답 시간 개선: 사용자 요청에 대한 빠른 응답 제공

✅ 공정성 보장: 모든 프로세스에 공평한 CPU 할당

스케줄링이 필요한 이유

• 멀티태스킹: 여러 프로그램을 동시에 실행할 때, CPU는 프로세스 간 빠르게 전환해야 함

• 리소스 최적화: CPU 자원을 효율적으로 사용하여 시스템 성능 향상

• 사용자 경험 개선: 빠른 프로그램 반응으로 사용자 만족도 증가

CPU 스케줄링의 기본 개념

프로세스 상태 (Process States)

1. Ready: CPU 할당을 기다림

2. Running: CPU를 할당받아 실행 중

3. Waiting: I/O 작업 등으로 대기 중

4. Terminated: 실행 완료

스케줄러(Scheduler) 는 Ready 상태의 프로세스 중 하나를 선택해 CPU 할당

CPU 스케줄링 알고리즘 종류

1️⃣ FCFS (First-Come, First-Served)

• 가장 먼저 도착한 프로세스부터 처리 • 비선점형(Non-Preemptive) 방식

✅ 장점: 구현이 쉽고 공정함 ⚠️ 단점: 평균 대기 시간이 길어질 수 있음 (Convoy Effect 발생)

📝 예시:

프로세스 도착 순서: P1(도착0, 실행4), P2(도착1, 실행3), P3(도착2, 실행2) 스케줄링 순서: P1 → P2 → P3

2️⃣ SJF (Shortest Job First)

• 실행 시간이 가장 짧은 프로세스부터 처리 • 비선점형/선점형(Preemptive) 둘 다 가능

✅ 장점: 평균 대기 시간 최소화 ⚠️ 단점: 긴 작업이 계속 대기할 수 있음 (Starvation 문제)

3️⃣ Round Robin (RR)

• 각 프로세스에 동일한 시간 할당량(Quantum) 부여 • 선점형 방식 → 시간 초과 시 다음 프로세스로 전환

✅ 장점: 공정성 보장, 반응 시간 개선 ⚠️ 단점: Quantum 설정이 너무 짧으면 과도한 컨텍스트 스위치 발생

📝 비유:

놀이공원에서 회전목마에 한 번씩 돌아가며 타는 것과 유사

4️⃣ Priority Scheduling

• 우선순위가 높은 프로세스부터 실행 • 선점형/비선점형 모두 가능

✅ 장점: 중요한 작업 우선 처리 가능 ⚠️ 단점: 낮은 우선순위 프로세스가 무한 대기 (Starvation)

💡 해결책: 우선순위에 노화(Aging) 기법 적용 (시간 경과 시 우선순위 상승)

5️⃣ Multilevel Queue Scheduling

• 프로세스를 여러 큐로 분류 (예: 시스템 프로세스, 사용자 프로세스) • 각 큐마다 다른 스케줄링 알고리즘 적용

✅ 장점: 프로세스 특성에 맞는 스케줄링 가능 ⚠️ 단점: 큐 간 이동이 제한적일 수 있음

📊 스케줄링 성능 지표

💻 Round Robin 간단 코드 예시 (JavaScript)

function roundRobin(processes, quantum) {
  let time = 0;
  const queue = [...processes];

  while (queue.length) {
    const process = queue.shift();
    if (process.burstTime <= quantum) {
      time += process.burstTime;
      console.log(`${process.name} 완료 at time ${time}`);
    } else {
      time += quantum;
      process.burstTime -= quantum;
      queue.push(process); // 남은 작업 재삽입
    }
  }
}

const processes = [
  { name: 'P1', burstTime: 5 },
  { name: 'P2', burstTime: 3 },
  { name: 'P3', burstTime: 1 },
];

roundRobin(processes, 2);

✅ 코드 설명:

• 각 프로세스에 시간 할당량(Quantum)을 주고 실행

• 시간이 남으면 다시 큐에 추가하여 공정성 유지

🧭 스케줄링 알고리즘 비교

정리하자면

✅ CPU 스케줄링은 시스템 성능과 사용자 경험에 직결됩니다.

✅ 공정성, 빠른 응답, 처리량을 모두 고려해 적절한 알고리즘 선택이 중요!

✅ 실생활 비유:

• FCFS: 식당 줄 서기

• Round Robin: 놀이공원 회전목마

• Priority: VIP 고객 우선 입장

JS 엔진은 큐를 가지고있다. JS 동작원리 중 스택을 실행 하기 위해 큐를 사용한다.(Callback Queue)

데이터를 순차적으로 처리함. 사용 예로는 티켓예매 사이트를 예로 들수있다 티켓을 예매하기 위해 우선적으로 예매 버튼을 클릭한 사람에게 판매할수있는..? 선입선출 (FIFO)!!

1️⃣ shift() 메서드 사용하기

• shift() 메서드는 배열의 첫 번째 요소를 제거하고 반환한다.
• 큐의 dequeue 동작과 동일한 원리.

const queue = [1, 2, 3, 4];
console.log(queue.shift()); // 1 (제거된 값)
console.log(queue); // [2, 3, 4]

✅ 장점: 간단하고 코드가 직관적임
⚠️ 단점: 배열 요소 이동으로 시간 복잡도 O(n)

2️⃣ 배열을 이용하는 방식

• 큐를 배열로 구현할 때 push() 와 shift() 를 사용한다.
• 삽입: push() – O(1)
• 삭제: shift() – O(n) (앞의 요소들이 한 칸씩 이동해야 함)

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    return this.items.shift();
  }

  front() {
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

✅ 장점: 코드가 간단하고 이해하기 쉬움
⚠️ 단점: 대규모 데이터 처리 시 비효율적

3️⃣ 연결 리스트를 이용하는 방식

• 연결 리스트(Linked List) 를 사용하면 shift() 시 발생하는 문제를 해결할 수 있다.
• 삽입과 삭제 모두 O(1)의 시간 복잡도를 가진다.

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedListQueue {
  constructor() {
    this.front = null;
    this.rear = null;
  }

  enqueue(value) {
    const newNode = new Node(value);
    if (!this.front) this.front = newNode;
    else this.rear.next = newNode;
    this.rear = newNode;
  }

  dequeue() {
    if (!this.front) return null;
    const value = this.front.value;
    this.front = this.front.next;
    if (!this.front) this.rear = null;
    return value;
  }
}

✅ 장점: 삽입과 삭제 시 빠름
⚠️ 단점: 메모리 사용량 증가

🔑 해시(Hash)

1️⃣ 해시의 개념

• 해시(Hash) 란 데이터를 고정된 크기의 해시 값으로 변환하여 저장하고 빠르게 검색할 수 있는 방법이다.
• "사물함 번호로 물건 찾기"와 유사한 개념이다.

2️⃣ 해시의 특징

• 빠른 검색: 평균 O(1)의 시간 복잡도
• 효율적인 데이터 관리: 큰 데이터 집합에서 유용
• 충돌 발생 가능성: 서로 다른 키가 같은 해시 값을 가질 수 있음

3️⃣ 해시 함수

• 입력 데이터를 고정된 크기의 해시 값으로 변환하는 함수.
• 좋은 해시 함수의 조건:
  • 빠른 계산 속도
  • 균등한 값 분포
  • 충돌 최소화

function simpleHash(key, size) {
  let hashValue = 0;
  for (let char of key) {
    hashValue += char.charCodeAt(0);
  }
  return hashValue % size;
}

4️⃣ 해시 함수를 구현할 때 고려할 내용

• 해시 충돌 가능성 최소화
• 계산 속도와 해시 테이블 크기 균형
• 해시 값의 균등한 분포

5️⃣ 자주 사용하는 해시 함수 알아보기

• Division Method: hash = key % tableSize
• Multiplication Method: hash = floor((key * A) % 1 * tableSize)
• JavaScript 내장 함수: 객체의 속성 접근 시 내부적으로 해시 사용

6️⃣ 충돌 처리

• 충돌(Collision): 서로 다른 두 입력이 같은 해시 값을 가질 때 발생한다.
• 해결 방법:
  • 체이닝(Chaining)
  • 개방 주소법(Open Addressing)

7️⃣ 체이닝으로 처리하기

• 같은 인덱스에 여러 값을 연결 리스트로 저장한다.
• 간단하고 구현이 쉬움

class HashTable {
  constructor(size = 50) {
    this.table = new Array(size);
  }

  hash(key) {
    let hashValue = 0;
    for (let char of key) {
      hashValue += char.charCodeAt(0);
    }
    return hashValue % this.table.length;
  }

  set(key, value) {
    const index = this.hash(key);
    if (!this.table[index]) {
      this.table[index] = [];
    }
    this.table[index].push([key, value]);
  }

  get(key) {
    const index = this.hash(key);
    if (this.table[index]) {
      for (let [storedKey, value] of this.table[index]) {
        if (storedKey === key) return value;
      }
    }
    return undefined;
  }
}

✅ 장점: 충돌 처리 시 연결 리스트 사용으로 유연함
⚠️ 단점: 추가 메모리 사용

8️⃣ 개방 주소 법으로 처리하기

• 충돌 발생 시 빈 인덱스를 찾아 데이터를 저장.
• 방식 종류:
  • 선형 탐사(Linear Probing): 한 칸씩 이동하며 탐색
  • 이차 탐사(Quadratic Probing): 일정한 간격으로 탐색
  • 더블 해싱(Double Hashing): 두 번째 해시 함수를 사용

class OpenAddressHashTable {
  constructor(size = 50) {
    this.table = new Array(size).fill(null);
  }

  hash(key) {
    let hashValue = 0;
    for (let char of key) {
      hashValue += char.charCodeAt(0);
    }
    return hashValue % this.table.length;
  }

  set(key, value) {
    let index = this.hash(key);
    while (this.table[index] !== null) {
      index = (index + 1) % this.table.length; // 선형 탐사
    }
    this.table[index] = [key, value];
  }

  get(key) {
    let index = this.hash(key);
    while (this.table[index] !== null) {
      if (this.table[index][0] === key) return this.table[index][1];
      index = (index + 1) % this.table.length;
    }
    return undefined;
  }
}

✅ 장점: 추가 데이터 구조 필요 없음
⚠️ 단점: 탐색 시간 증가 가능성

첫 번째 기둥: 스코프와 클로저

스코프(Scope)

스코프는 변수에 접근할 수 있는 범위를 의미한다.

양동이 = 스코프 구슬 = 변수

• 양동이(스코프)에 구슬(변수)을 넣어둔다. • 특정 구슬을 찾으려면 같은 색의 양동이부터 찾는다.

let globalBall = "전역 구슬"; // 전역 스코프 양동이

function outerBucket() {
  let outerBall = "바깥 양동이 구슬"; // 함수 스코프 양동이

  function innerBucket() {
    let innerBall = "안쪽 양동이 구슬 "; // 내부 양동이
    console.log(globalBall); //  찾음!
    console.log(outerBall);  //  찾음!
    console.log(innerBall);  //  찾음!
  }

  innerBucket();
}

outerBucket();

✅ 중요 포인트:

• 내부 양동이(스코프)는 바깥 양동이 구슬을 쉽게 찾을 수 있지만, • 바깥 양동이는 내부 양동이 구슬을 못 찾는다

렉시컬 스코프(Lexical Scope)

스코프는 함수가 정의될 때 결정.

“함수가 어디서 작성됐는지” 가 중요하지, “어디서 호출됐는지” 는 중요하지 않다.

함수를 건물 설계도 에 비유해보면

• 설계도를 만든 위치에서 어떤 방을 연결할지 미리 결정하고

• 나중에 어디서 불러도 이미 설계된 대로만 연결하면 된다.

const outerCode = "외부 코드 ";

function outer() {
  const innerCode = "내부 코드 ";

  function inner() {
    console.log(outerCode); //  접근 가능 (설계도에서 연결)
    console.log(innerCode); //  접근 가능
  }

  inner();
}

outer();

✅ 중요 포인트:

• inner 함수는 outer에서 정의됐기 때문에 outerCode에 접근 가능

• 어디서 호출하든 함수가 만들어질 때의 스코프가 중요

클로저(Closure)

클로저는 함수가 외부 변수(환경)를 기억해서 나중에도 사용할 수 있는 기능이다.

스코프가 일시적인 양동이라면, 클로저는 양동이를 집에 영구적으로 보관하는 것과 같다.

엄마가 냉장고에 메모를 붙여 놨을때

“우유 사와!”

• 냉장고(함수)에 메모(변수)를 붙이면 • 엄마가 집을 나가도 메모는 남아있음.

클로저도 똑같다

함수 실행 후에도 외부 변수를 기억하고 있다가 필요할 때 꺼내 쓸 수 있음.

다른 예로 비밀 금고에 비유 할 수 있다

function safe() {
  let secret = "비밀 코드 🔐"; // 외부 변수

  return function revealSecret() {
    console.log(`비밀은 ${secret}입니다!`);
  };
}

const openSafe = safe(); // 금고 열쇠 받기
openSafe(); // "비밀은 🔐입니다!"

✅ 중요 포인트:

• secret 변수는 외부에서 접근 못한다.

• 금고 열쇠(openSafe) 를 통해서만 비밀을 열 수 있다.

클로저 실전 예시: 카운터 만들기

function makeCounter() {
  let count = 0; // 외부 변수 (초기값 저장)

  return function () {
    count += 1; // 외부 변수 접근
    return count;
  };
}

const counter = makeCounter();

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

✅ 왜 유용할까?

• 데이터 보호: 외부에서 count를 직접 변경 못함 • 상태 유지: 함수 호출마다 값을 기억하고 누적

두 번째 기둥: 프로토타입(Prototype)

프로토타입이란?

자바스크립트는 클래스 없이도 객체를 만들고 상속할 수 있는 몇 안되는 언어라고 한다.

모든 객체는 프로토타입이라는 레시피 책(프로토타입 체인)을 갖고 있다.

객체에 없는 기능을 찾을 때, 레시피 책(프로토타입 체인)에서 찾아서 사용한다.

예를 들어 요리사와 레시피 책

• 나(객체)는 쿠키를 만들고 싶은데 방법을 모른다. • 레시피 책(프로토타입)에 bake 만드는 법이 있다. • 나는 책을 보고 구워낼 수 있다

💻 코드 예시

function CookieMaker(flavor) {
  this.flavor = flavor; // 쿠키 맛
}

// 🍪 쿠키 굽기 레시피 추가!
CookieMaker.prototype.bake = function () {
  console.log(`${this.flavor} 쿠키 완성! 🍪`);
};

const chocoCookie = new CookieMaker("초코");
chocoCookie.bake(); // "초코 쿠키 완성! 🍪"

✅ 작동 원리:

• chocoCookie는 bake 메서드를 모른다.

• CookieMaker.prototype(레시피 책)을 찾아서 사용

다른 예로 유전자 상속이 있다.

• 부모(프로토타입) → “운전 가능” 유전자 보유

• 나(객체) → 운전 못 배웠지만 유전자 덕에 운전 가능

const parent = { canDrive: true };
const child = Object.create(parent);

console.log(child.canDrive); // true (부모한테 상속받음!)

✅ 중요:

• 프로토타입 체인을 통해 속성이나 메서드를 상속

• 찾을 때까지 부모 → 조부모 → 최상위까지 올라감

🔄 세 번째 기둥: 타입과 타입 강제 변환

타입(Type)이란?

값의 데이터 종류를 뜻한다.

• 숫자: 123 • 문자열: "hello" • 불린: true / false

타입 강제 변환(Type Coercion)

자바스크립트는 필요할 때 알아서 타입을 변환해준다.

이게 바로 암시적 변환(자동 변환)이다.

예를 들어 만능 요리사 vs 실수 많은 점원

만능 요리사 (암시적 변환)

내가 “밥 + 물” 요청하면 = 죽 만들어줌 🍚+💧=🥣

"5" + 2; // "52" (문자열 붙이기)
"5" - 2; // 3 (숫자 계산 필요 → 숫자로 변환)
true + 1; // 2 (true → 1 변환)

✅ 중요 포인트:

• + 연산자는 문자열이면 문자 붙이기 • - 연산자는 숫자 계산을 위해 변환

실수 많은 점원 (헷갈리는 변환)

"5" == 5;  // true (자동 변환!)
"5" === 5; // false (타입까지 비교!)

✅ 비교할 때는?

== : 대충 맞으면 같다고 판단

=== : 타입과 값 모두 비교 (안전 추천)

명시적 변환 (직접 변환)

Number("123"); // 123
String(456);   // "456"
Boolean(0);    // false

✅ 포인트:

명시적 변환을 사용하면 에러 방지 가능

컴퓨터 시스템에서 여러 개의 프로세스나 스레드가 공유 자원에 동시에 접근하는 상황은 흔히 발생한다. 이때 데이터의 일관성과 프로그램의 안정성을 유지하기 위해 동기화라는 개념이 필요하며, 이와 관련된 문제점인 교착 상태에 대해 알아보자.

1. 동기화 (Synchronization)

• 정의: 여러 개의 프로세스 또는 스레드가 공유 자원에 동시에 접근하는 것을 방지하고, 실행 순서를 제어하여 데이터의 일관성을 유지하는 것을 의미한다.
• 목적:*
  • 데이터 일관성 유지: 공유 데이터가 여러 프로세스/스레드에 의해 동시에 변경되는 경우 발생할 수 있는 데이터 불일치 문제를 해결.
  • 경쟁 조건 방지: 여러 프로세스/스레드가 공유 자원을 차지하기 위해 경쟁하는 상황에서 예상치 못한 결과를 방지.
  • 프로세스/스레드 협력: 여러 프로세스/스레드가 특정 작업을 함께 수행해야 할 때, 실행 순서를 조절하여 효율적인 협업을 가능하게 한다.

2. 교착 상태 (Deadlock)

• 정의: 두 개 이상의 프로세스 또는 스레드가 서로 필요한 자원을 점유하고 상대방의 자원 반납을 기다리는 상태를 의미.
• 발생 조건:*
  • 상호 배제 (Mutual Exclusion): 공유 자원은 한 번에 하나의 프로세스/스레드만 사용할 수 있다.
  • 점유 및 대기 (Hold and Wait): 프로세스/스레드가 자원을 점유한 상태에서 다른 자원을 기다린다.
  • 비선점 (No Preemption): 프로세스/스레드가 점유한 자원을 강제로 빼앗을 수 없다.
  • 순환 대기 (Circular Wait): 프로세스/스레드들이 서로의 자원을 요구하며 순환 형태로 대기한다.
• 문제점:*
  • 시스템 멈춤: 교착 상태에 빠진 프로세스/스레드들은 작업을 진행하지 못하고, 시스템 전체가 멈추는 상황이 발생할 수 있다.
  • 자원 낭비: 교착 상태에 빠진 프로세스/스레드들이 점유한 자원은 다른 프로세스/스레드들이 사용할 수 없게 되어 자원 낭비가 발생한다.

3. 동기화 기법

• 뮤텍스 (Mutex): 공유 자원에 대한 접근을 제한하는 잠금 메커니즘이다.
• 세마포어 (Semaphore): 공유 자원에 접근할 수 있는 프로세스/스레드의 수를 제한하는 카운터다.
• 모니터 (Monitor): 공유 자원과 이를 접근하는 함수들을 묶어 관리하는 동기화 기법이다.

4. 교착 상태 해결 방법

• 교착 상태 예방: 교착 상태 발생 조건을 사전에 제거한다. (예: 상호 배제 조건 완화, 점유 및 대기 방지 등)
• 교착 상태 회피: 시스템의 상태를 감시하며 교착 상태 발생 가능성이 있는 자원 할당을 피한다. (예: 은행원 알고리즘)
• 교착 상태 탐지 및 복구: 교착 상태 발생 여부를 탐지하고, 관련된 프로세스/스레드를 강제 종료하거나 자원을 선점하여 교착 상태를 해결한다.

결론

동기화는 멀티 프로세스/스레드 환경에서 데이터 일관성을 유지하고 프로그램의 안정성을 높이는 데 필수적인 개념이다. 하지만 잘못된 동기화는 교착 상태를 유발할 수 있으므로, 동기화 기법을 올바르게 이해하고 사용하는 것이 중요하다.

세마포

세마포는 컴퓨터 시스템에서 여러 프로세스나 스레드가 공유 자원에 접근할 때, 접근 가능한 개수를 제한하는 동기화 기법이다. 마치 주차장의 주차 가능 대수와 비슷하다고 생각하면 된다.

핵심 개념

• 카운터: 세마포는 정수 값을 가지는 카운터로, 공유 자원에 접근 가능한 프로세스/스레드의 수를 나타낸다.
• P 연산 (wait): 프로세스/스레드가 공유 자원에 접근하려고 할 때, 세마포 카운터 값을 1 감소시킨다. 만약 카운터 값이 0이라면, 해당 프로세스/스레드는 대기한다.
• V 연산 (signal): 프로세스/스레드가 공유 자원 사용을 마치면, 세마포 카운터 값을 1 증가시킨다. 대기 중인 프로세스/스레드가 있다면, 그중 하나를 깨워 공유 자원에 접근할 수 있도록 한다.

작동 방식

1. 세마포 초기화: 공유 자원에 접근 가능한 최대 개수로 세마포 카운터를 초기화한다.
2. P 연산: 프로세스/스레드가 공유 자원에 접근하기 전에 P 연산을 수행한다.
3. 공유 자원 접근: P 연산 후, 해당 프로세스/스레드는 공유 자원에 접근하여 작업을 수행한다.
4. V 연산: 공유 자원 사용을 마치면 V 연산을 수행하여 세마포 카운터를 증가시킨다.

종류

• 이진 세마포 (Binary Semaphore): 카운터 값이 0 또는 1인 세마포이다. 주로 뮤텍스와 같이 상호 배제를 구현하는 데 사용된다.
• 계수 세마포 (Counting Semaphore): 카운터 값이 1 이상인 세마포이다. 유한한 자원의 개수를 관리하는 데 사용된다.

장점

• 간단함: 이해하고 구현하기 쉽다.
• 유연성: 다양한 상황에 맞게 카운터 값을 조절하여 사용할 수 있다.
• 효율성: 대기 큐를 사용하여 자원 접근을 효율적으로 관리한다.

단점

• 데드락 가능성: 잘못된 세마포 사용은 데드락을 유발할 수 있다.
• 우선순위 역전: 우선순위가 낮은 프로세스/스레드가 자원을 독점하여 우선순위가 높은 프로세스/스레드가 대기하는 상황이 발생할 수 있다.

활용 예시

• 프린터 공유: 여러 대의 컴퓨터가 한 대의 프린터를 공유할 때, 세마포어를 사용하여 프린터 접근을 제한할 수 있다.
• 데이터베이스 연결: 제한된 수의 데이터베이스 연결을 여러 사용자가 공유할 때, 세마포어를 사용하여 동시 접속자 수를 제한할 수 있다.

결론

세마포는 공유 자원 접근을 효율적으로 관리하고 동기화 문제를 해결하는 데 유용한 도구이다. 하지만 데드락 및 우선순위 역전과 같은 문제점을 야기할 수 있으므로, 세마포 사용 시 주의해야 한다.

조건 변수, 모니터, 스레드 안전

1. 조건 변수 (Condition Variable)

• 정의: 특정 조건이 만족될 때까지 스레드를 대기시키거나, 대기 중인 스레드를 깨우는 데 사용되는 동기화 기법이다.
• 역할: 공유 자원에 대한 접근 순서를 제어하고, 스레드 간 협력을 효율적으로 관리한다.
• 메커니즘:
  • wait(): 스레드를 대기 상태로 만들고, 조건 변수에 연결된 뮤텍스를 해제한다.
  • signal(): 대기 중인 스레드 중 하나를 깨운다.
  • broadcast(): 대기 중인 모든 스레드를 깨운다.
• 사용 예시: 생산자-소비자 문제에서, 소비자는 큐가 비어있으면 대기하고, 생산자는 큐에 데이터를 추가하면 대기 중인 소비자를 깨운다.

2. 모니터 (Monitor)

• 정의: 공유 자원과 해당 자원에 대한 접근을 제어하는 함수들을 묶어 관리하는 동기화 기법이다.
• 특징:
  • 상호 배제: 모니터 내에서는 한 번에 하나의 스레드만 접근할 수 있다.
  • 조건 변수: 모니터 내에서 조건 변수를 사용하여 스레드 간 동기화를 구현한다.
• 구현:
  • 뮤텍스: 공유 자원에 대한 접근을 제한하는 잠금 역할을 한다.
  • 조건 변수: 특정 조건이 충족될 때까지 스레드를 대기시키거나 깨우는 역할을 한다.
• 장점:
  • 안전성: 공유 자원에 대한 동시 접근을 방지하여 데이터 일관성을 유지한다.
  • 편의성: 모니터 내에서 동기화 관련 코드를 캡슐화하여 코드의 가독성과 유지 보수성을 높인다.

3. 스레드 안전 (Thread Safety)

• 정의: 여러 개의 스레드가 공유 자원에 동시에 접근해도 데이터 손상이나 예기치 않은 오류 없이 프로그램이 정상적으로 동작하는 것을 의미한다.
• 조건:
  • 경쟁 조건 (Race Condition) 방지: 여러 스레드가 공유 자원에 동시에 접근하여 결과를 예측할 수 없는 상황을 방지한다.
  • 원자성 (Atomicity) 보장: 특정 작업이 중간에 중단되지 않고 완벽하게 수행되도록 보장한다.
  • 가시성 (Visibility) 확보: 스레드 간 변경된 데이터가 서로에게 제대로 반영되도록 보장한다.
• 스레드 안전한 코드 작성 방법:
  • 뮤텍스/세마포어 사용: 공유 자원에 대한 접근을 제한한다.
  • 불변 객체 (Immutable Object) 사용: 값이 변경되지 않는 객체를 사용하여 동시 접근 문제를 방지한다.
  • 스레드 로컬 저장소 (Thread-Local Storage) 사용: 각 스레드마다 독립적인 저장 공간을 제공하여 공유 자원 접근을 최소화한다.

핵심 요약

결론

조건 변수, 모니터, 스레드 안전은 멀티 스레드 환경에서 공유 자원을 안전하게 관리하고 프로그램의 안정성을 높이는 데 필수적인 개념이다. 이러한 개념들을 제대로 이해하고 활용하여 안전하고 효율적인 프로그램을 개발할 수 있다.

프로세스(Process)와 스레드(Thread)의 개념

• 프로세스(Process): 실행 중인 프로그램의 인스턴스이다. • 스레드(Thread): 프로세스 내부에서 실행되는 작업의 흐름으로, 여러 스레드가 하나의 프로세스 내에서 동작할 수 있다.

주요 역할

1. 프로세스 생성과 종료

• 새로운 프로그램 실행 시 운영체제(OS)가 프로세스를 생성하고, 종료 시 자원을 반환한다.

2. 프로세스 상태 관리

• 실행(Running), 준비(Ready), 대기(Waiting) 등의 상태를 관리한다.

3. 프로세스 스케줄링

• CPU를 효율적으로 사용하기 위해 어떤 프로세스를 실행할지 결정한다.

4. 문맥 교환(Context Switching)

• CPU가 다른 프로세스로 전환될 때 CPU 레지스터와 메모리 상태를 저장하고 복원한다.

2. 자원 할당 및 관리

운영체제는 컴퓨터 자원(CPU, 메모리, 디스크 등)을 각 프로세스가 원활하게 사용할 수 있도록 할당하고 회수한다.

자원을 효율적으로 나누어 사용하도록 관리하여 성능을 최적화한다.

3. CPU 관리: CPU 스케줄링

CPU 스케줄링이란?

CPU 스케줄링은 운영체제가 어떤 프로세스에게 CPU를 할당할지 결정하는 과정이다.

컴퓨터 시스템의 효율성을 극대화하고 사용자에게 빠른 응답성을 제공하는 것이 목표이다.

CPU 스케줄링의 중요성

시스템 효율성 향상

• CPU가 유휴 상태로 낭비되는 시간을 최소화하고, 최대한 많은 프로세스를 처리하여 전체 시스템의 효율성을 높인다.

사용자 응답성 향상

• 사용자의 요청에 빠르게 응답하여 사용자 경험을 개선한다.

공정성 확보

• 모든 프로세스에게 공평하게 CPU 사용 기회를 제공하여 특정 프로세스가 불이익을 받지 않도록 한다.

주요 CPU 스케줄링 알고리즘

운영체제는 상황에 따라 적절한 스케줄링 알고리즘을 선택하여 사용한다.

4. 멀티 프로세스와 멀티 스레드

현대 컴퓨터 시스템은 멀티태스킹을 통해 여러 작업을 동시에 처리한다.

이때 사용되는 핵심 개념이 멀티 프로세스와 멀티 스레드이다.

두 방식 모두 동시에 여러 작업을 처리하지만, 작동 방식과 장단점에 차이가 있다.

📌 1. 멀티 프로세스 (Multi-Process)

• 각 프로세스는 독립적인 메모리 공간을 가지며, 서로 간섭 없이 작업을 수행한다.

• 프로세스 간 통신(IPC, Inter-Process Communication)이 필요할 때, 오버헤드가 발생할 수 있다.

✅ 장점

• 안정성: 하나의 프로세스가 오류가 나도 다른 프로세스에 영향을 주지 않는다.

• 병렬 처리 가능: 여러 개의 CPU 코어를 활용하여 작업을 병렬로 실행할 수 있다.

❌ 단점

• 오버헤드 발생: 프로세스를 생성하고 관리하는 데 많은 비용이 발생한다.

• 자원 사용량 증가: 독립적인 메모리 공간을 사용하므로 메모리 사용량이 많다.

📌 2. 멀티 스레드 (Multi-Thread)

• 하나의 프로세스 내에서 여러 개의 스레드를 생성하여 작업을 병렬로 실행하는 방식이다.

• 모든 스레드는 공유 메모리 공간을 사용하므로, 스레드 간 통신이 빠르다.

✅ 장점

• 자원 효율성 증가: 프로세스 내에서 메모리를 공유하므로 메모리 사용량이 적다.

• 빠른 응답성: 여러 작업을 동시에 수행할 수 있어 프로그램의 응답성이 향상된다.

❌ 단점

• 안정성 문제: 하나의 스레드가 오류가 나면 전체 프로세스가 영향을 받을 수 있다.

• 동기화 문제 발생 가능: 공유 자원에 여러 스레드가 접근하면 데이터 충돌이 발생할 수 있다.

멀티 프로세스 vs 멀티 스레드 비교

웹 브라우저, 게임 엔진 등에서는 멀티 스레드를, 서버 관리 등에서는 멀티 프로세스를 활용한다.

프로세스 메모리 영역

운영체제는 프로세스가 실행될 때 코드, 데이터, 스택, 힙 영역으로 메모리를 관리한다.

힙(Heap) 영역을 많이 사용하면 메모리 누수가 발생할 수 있다.

🔥 결론

• 운영체제는 프로세스와 스레드를 관리하며, CPU 스케줄링을 통해 최적의 성능을 제공한다.

• 멀티 프로세스는 안정성이 높고 멀티 스레드는 효율성이 높다.

• 프로세스는 메모리 영역(코드, 데이터, 스택, 힙)을 사용하며, 효율적인 메모리 관리가 필요하다.

배열은 순서가 있는 데이터 저장소이다.

각 요소는 인덱스(index) 를 통해 접근할 수 있으며, 데이터를 연속된 메모리 공간에 저장한다.

JavaScript에서 배열은 동적 배열로 구현되어 있으며, 크기가 자동으로 조정된다.

배열은 다양한 메서드를 제공하여 데이터를 쉽게 추가, 삭제, 정렬할 수 있다.

배열의 특징

1. 인덱스를 사용하여 빠르게 접근할 수 있다.

• arr[0], arr[1]과 같은 방식으로 요소를 가져올 수 있다.

2. 배열의 크기는 동적으로 변경된다.

• 새로운 요소를 추가하면 크기가 자동으로 늘어나고, 요소를 삭제하면 줄어든다.

3. 배열의 중간 요소를 삭제하면 재정렬이 필요하다.

• 특정 요소를 삭제하면 뒤에 있는 요소들이 한 칸씩 앞으로 이동해야 한다.

4. 배열은 객체로 구현되어 있다.

• JavaScript의 배열은 실제로 객체이며, length 속성과 다양한 메서드를 제공한다.

배열의 주요 메서드

배열의 내부 동작

배열은 연속된 메모리 공간에 데이터를 저장하지만, JavaScript의 배열은 동적 배열이므로

공간이 부족할 경우 새로운 메모리를 할당하고 기존 데이터를 복사하는 과정이 발생한다.

배열의 인덱스 접근은 O(1)의 시간 복잡도를 가지지만, 중간 삽입 및 삭제는 O(n) 이 된다.

const arr = ["🍎", "🍌", "🍇"]; // 메모리 구조 예시
// 메모리 구조:
// 0x100 -> "🍎"
// 0x104 -> "🍌"
// 0x108 -> "🍇"

배열의 길이를 초과하여 요소를 추가하면 새로운 메모리를 할당하고 데이터를 복사하는 작업이 발생한다.

배열의 활용 예시

1. 데이터 저장 및 관리

• JSON 데이터 구조를 다룰 때 배열을 사용한다.

2. UI 요소 관리

• React와 같은 프레임워크에서 상태(state) 관리 시 배열을 사용한다.

3. 정렬 및 검색

• 배열을 정렬(sort())하거나 특정 조건에 맞는 요소를 찾을 때(filter(), find()) 사용한다.

2차원 배열

2차원 배열은 1차원 배열을 확장한 것 이다. 2차원 배열은 다음과 같이 선언할수있다.

//  2 차원 배열을 리터럴로 표현
const arr = l[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]1;

//  arr[2][3] 에 저장된 값을 출력
console. Log(arr [2J[3]); / / 12

//  arr[2][3]에 저장된 값을 15로 변경
arr[2J[3] = 15;

//  변경된 값을 출 력
console. log(arr[2][3]); / / 15

스택이란?

스택은 후입선출(LIFO, Last In First Out) 방식으로 동작하는 자료구조이다.

데이터의 추가(push())와 제거(pop())가 맨 위(Top)에서만 이루어진다.

배열을 사용하여 쉽게 구현할 수 있으며, 실행 취소(Undo), 함수 호출 스택(Call Stack) 등 다양한 곳에서 사용된다.

스택의 특징

1. 후입선출(LIFO) 구조를 가진다.

• 마지막에 추가된 요소가 가장 먼저 제거된다.

2. 맨 위(Top)에서만 데이터 추가 및 삭제가 가능하다.

• 중간의 요소를 제거할 수 없으며, 반드시 마지막 요소부터 제거해야 한다.

3. 배열을 사용하여 쉽게 구현할 수 있다.

• JavaScript의 push()와 pop()을 활용하면 간단하게 스택을 구현할 수 있다.

스택의 주요 메서드

스택의 내부 동작

스택은 데이터를 배열의 끝에 추가하고(push()), 끝에서 제거(pop())하는 방식으로 동작한다.

이로 인해 O(1)의 시간 복잡도를 가지며, 매우 빠른 데이터 추가 및 삭제가 가능하다.

// 스택 구현 (배열 사용)
const stack = [];

// 데이터 추가
stack.push("🟥 빨강");
stack.push("🟦 파랑");
stack.push("🟩 초록");

console.log(stack); // ["🟥 빨강", "🟦 파랑", "🟩 초록"]

// 데이터 제거
const lastItem = stack.pop();
console.log(lastItem); // "🟩 초록" (마지막에 넣은 값이 먼저 나옴)
console.log(stack); // ["🟥 빨강", "🟦 파랑"]

스택의 활용 예시

1. 실행 취소(Undo) 기능

• 문서 편집기에서 실행 취소할 때 마지막 작업을 먼저 제거하는 방식으로 동작한다.

2. 브라우저 뒤로 가기(History) 관리

• 사용자가 방문한 페이지를 스택에 저장하고, “뒤로 가기” 버튼을 누르면 최근 페이지부터 제거하는 방식이다.

3. 함수 호출 스택(Call Stack)

• JavaScript의 함수 실행 과정에서 콜 스택(Call Stack)이 사용되며, 후입선출 방식으로 실행된다.

function first() {
  console.log("첫 번째 실행");
  second();
}

function second() {
  console.log("두 번째 실행");
  third();
}

function third() {
  console.log("세 번째 실행");
}

first();

실행 과정

1. first() 실행 → 스택에 first() 추가
2. first() 안에서 second() 실행 → 스택에 second() 추가
3. second() 안에서 third() 실행 → 스택에 third() 추가
4. third() 실행 완료 → 스택에서 제거
5. second() 실행 완료 → 스택에서 제거
6. first() 실행 완료 → 스택에서 제거

이처럼 실행이 끝난 함수는 마지막 실행된 함수부터 제거되며, 후입선출(LIFO) 방식으로 동작한다.

배열 vs 스택 비교

배열과 스택의 개념을 깊이 이해하면, 다양한 알고리즘과 데이터 구조를 쉽게 이해할 수 있다.

배열은 데이터 저장과 검색에 유용하고, 스택은 후입선출 방식이 필요한 곳에서 강력한 성능을 발휘한다.

추상 자료형 = ADT(Abstract Data Type)

ADT는 자료구조를 어떻게 구현할지보다는, 무엇을 할 수 있는지를 정의하는 개념적인 모델이다. 어떤 연산을 제공해야 하는지 명확하게 정의하는 것이 핵심이며, 내부 구현 방식은 중요하지 않다.

쉬운 예로 자동차와 운전자의 관계를 들수있다. 자동차를 운전할 때 자동차의 내부 엔진 구조를 몰라도 엑셀을 밟으면 가속하고, 브레이크를 밟으면 멈춘다는 기능만 알면된다.

클로저는 “내부 함수가 외부 함수의 변수를 기억하는 현상”이다. 함수 안에서 만든 내부 함수가, 자신을 감싸는 함수의 변수를 기억하는 것

function outer() {
  let count = 0;  // 외부 함수의 변수

  return function inner() { // 내부 함수 (클로저)
    count++;  // 외부 함수의 변수 접근 가능!
    console.log(count);
  };
}

const closureFunc = outer(); // outer 실행 → 내부 함수 반환
closureFunc(); // 1
closureFunc(); // 2
closureFunc(); // 3

왜 클로저가 중요할까?

✔ 상태 유지: count 값이 초기화되지 않고 계속 유지됨 ✔ 데이터 은닉: count는 outer() 바깥에서 직접 접근할 수 없음. ✔ 함수형 프로그래밍에서 많이 사용

클로저가 없으면 어떻게 될까?

function noClosure() {
  let count = 0;
  count++;
  console.log(count);
}

noClosure(); // 1
noClosure(); // 1 (다시 초기화됨!)

클로저 없이 함수 실행하면 count가 초기화되지만, 클로저를 사용하면 값이 유지된다

2. this 키워드란?

this는 “함수가 실행될 때 결정되는 ’실행 컨텍스트(Execution Context)’를 가리키는 키워드” 이다.

this가 가리키는 값은 ‘함수가 호출되는 방식’에 따라 달라진다

• this 키워드 동작 방식 (중요한 4가지 규칙)

1. 일반 함수 호출

function sayHello() {
  console.log(this);
}

sayHello(); // 일반 함수 실행 → this는 window (또는 undefined)

브라우저 환경에서는 window 객체를 가리킴.

"use strict"; // 엄격 모드 활성화

function sayHello() {
  console.log(this);
}

sayHello(); // undefined

strict mode("use strict")에서는 undefined가 된다.

2️. 객체의 메서드 호출

const person = {
  name: "료니",
  greet() {
    console.log(this.name);
  }
};

person.greet(); // "료니"  (this는 person 객체)

this는 이 메서드를 호출한 객체를 가리킴.

3️. 생성자 함수 (new 키워드 사용)

function Person(name) {
  this.name = name;
}

const me = new Person("료니");
console.log(me.name); // "료니"

new 키워드를 쓰면 새로운 객체가 생성되고, this가 그 객체를 가리킴.

4️. 화살표 함수 (this 바인딩)

const obj = {
  name: "료니",
  greet: () => {
    console.log(this.name);
  }
};

obj.greet(); // undefined (this는 obj가 아니라 window)

화살표 함수는 this를 자신을 감싸는 부모 스코프의 this로 고정한다.

즉, obj.greet() 안의 this는 obj가 아니라 전역 객체(window)를 가리킴.

3. 프로토타입(Prototype)이란?

프로토타입은 “객체가 상속받을 수 있는 속성과 메서드들을 저장하는 공간”이다.

“모든 객체는 숨겨진 proto(프로토타입 링크)를 가지고 있으며, 이걸 통해 상속을 구현한다.”

프로토타입 기본 개념

function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  console.log(`안녕! 나는 ${this.name}이야.`);
};

const me = new Person("료니");
me.sayHello(); // "안녕! 나는 료니야."

me 객체에는 sayHello 메서드가 없음

하지만 Person.prototype에 있기 때문에 proto를 통해 접근 가능

프로토타입 체인 (Prototype Chain)

console.log(me.__proto__ === Person.prototype); // true
console.log(Person.prototype.__proto__ === Object.prototype); // true
console.log(Object.prototype.__proto__ === null); // true

모든 객체는 proto를 따라 위쪽으로 상속 구조(체인)를 따라가며 프로퍼티를 찾음.

최종적으로 Object.prototype까지 올라감.

4. 객체 연결 장치 (Prototype Chain)

객체 연결 장치는 “프로토타입 체인을 따라 상속되는 구조” 이다.

객체가 자신의 프로퍼티를 찾을 때 없으면 proto를 따라가서 부모 객체에서 찾는다

객체 연결 장치 예제

const parent = {
  hello() {
    console.log("안녕, 나는 부모야!");
  }
};

const child = Object.create(parent); // parent를 상속받는 객체 생성
child.hello(); // "안녕, 나는 부모야!"

child 객체에는 hello() 메서드가 없음.

하지만 proto를 따라 parent에서 hello()를 찾고 실행한다.

결론적으로

1. 이터레이션 (Iteration)

이터레이션은 데이터를 한 덩어리씩 순회하며 처리하는 과정을 의미한다. 데이터 전체를 한 번에 다루기보다, 한 요소씩 차례대로 접근하여 처리함으로써 효율적이고 유연한 코드 작성을 가능하게 한다.

• 특징

• 데이터를 일정 단위(예: 한 요소씩)로 나누어 처리한다. • 반복문을 통해 컬렉션 내의 모든 값을 순회한다.

이터레이션은 보통 이터레이터(Iterator) 패턴을 사용하여 구현된다.

2. 이터레이터 소비하기 (Consuming an Iterator)

이터레이터는 데이터를 순차적으로 반환하는 객체이다. 이터레이터를 소비한다는 것은 이터레이터가 제공하는 데이터를 하나씩 받아서 사용하는 것을 의미한다.

2.1. 이터레이터의 기본 구조

이터레이터는 일반적으로 next() 메서드를 가지고 있으며, 이 메서드를 호출할 때마다 다음과 같은 형태의 객체를 반환한다.

{
  value: 현재 처리 중인 값,
  done: 이터레이션이 끝났는지 여부를 나타내는 불리언 값
}

• value: 현재 순회 중인 데이터 값을 나타낸다. • done: 이터레이션이 완료되었으면 true가, 아직 진행 중이면 false가 된다.

2.2. 이터레이터 소비 방법

이터레이터 소비에는 여러 가지 방법이 있으며, 대표적인 방법은 다음과 같다.

2.2.1. for...of 반복문 사용

for...of 문은 이터러블(Iterator를 소비할 수 있는 객체)을 순회하며 내부적으로 이터레이터 소비 프로토콜을 따른다.

const array = [1, 2, 3];
for (const value of array) {
  console.log(value); // 1, 2, 3 순서대로 출력된다.
}

2.2.2. 전개 구문(Spread Syntax) 사용

전개 구문(...)은 이터레이터를 소비하여 배열이나 함수의 인수 목록 등으로 확장한다.

const iterable = [1, 2, 3];
const arrayCopy = [...iterable];
console.log(arrayCopy); // [1, 2, 3]

2.2.3. 나머지 매개변수(Rest Parameter) 사용

함수의 매개변수로 나머지 매개변수를 사용하면 전달된 이터러블 객체가 배열로 변환된다.

function sum(...numbers) {
  return numbers.reduce((acc, cur) => acc + cur, 0);
}

console.log(sum(1, 2, 3)); // 6

3. 이터러블 (Iterable)

이터러블은 이터레이터 소비 프로토콜을 준수하는 객체를 의미한다. 즉, 이터러블 객체는 Symbol.iterator 메서드를 가지며, 이를 호출하면 이터레이터를 반환한다.

3.1. 기본 이터러블 객체

자바스크립트에서는 여러 기본 데이터 구조가 이터러블로 제공된다.

• 배열(Array)

배열은 이터러블하여 for...of 문, 전개 구문 등으로 쉽게 순회할 수 있다.

• 문자열(String)

문자열은 문자 하나하나가 순회 가능한 요소로 취급된다.

• Map

Map 객체는 [키, 값] 형태의 튜플을 순회할 수 있다.

• Set

Set 객체는 중복되지 않는 값들의 집합으로 이터러블하다.

// 배열의 이터러블 예시
const arr = [10, 20, 30];
for (const num of arr) {
  console.log(num);
}

// 문자열의 이터러블 예시
const greeting = "Hello";
const characters = [...greeting];
console.log(characters); // ["H", "e", "l", "l", "o"]

// Map의 이터러블 예시
const map = new Map();
map.set('a', 1);
map.set('b', 2);
for (const [key, value] of map) {
  console.log(key, value);
}

3.2. 직접 이터러블 구현하기

사용자가 직접 이터러블 객체를 만들고 싶다면, 객체에 Symbol.iterator 메서드를 정의하면 된다.

const customIterable = {
  data: [1, 2, 3],
  [Symbol.iterator]() {
    let index = 0;
    const data = this.data;
    return {
      next() {
        if (index < data.length) {
          return { value: data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

for (const value of customIterable) {
  console.log(value); // 1, 2, 3 순서대로 출력된다.
}

• 설명

위 예시에서 customIterable 객체는 Symbol.iterator 메서드를 통해 이터레이터를 반환한다.

이터레이터의 next() 메서드는 현재 인덱스가 배열의 길이보다 작으면 다음 값을 반환하고, 그렇지 않으면 done: true를 반환하여 순회를 종료한다.

정리하자면

// ✅ 1. 이터러블 객체 (Iterable) - 과자 상자 만들기
const snackBox = {
  snacks: ["🍫 초콜릿", "🍪 쿠키", "🍬 사탕"], // 이터러블 대상
  [Symbol.iterator]: function () {
    let index = 0;
    return {
      next: () => {
        return index < this.snacks.length
          ? { value: this.snacks[index++], done: false } // 과자 반환
          : { value: undefined, done: true }; // 반복 종료
      },
    };
  },
};

// ✅ 2. 이터레이션 (Iteration) - for...of 사용해서 과자 먹기
console.log("🎯 for...of 반복문 실행 (이터레이션)");
for (const snack of snackBox) {
  console.log(snack); // 과자를 하나씩 출력
}

// ✅ 3. 이터레이터 직접 사용 (next() 호출)
console.log("\n🎯 next()를 직접 호출 (이터레이터)");
const iterator = snackBox[Symbol.iterator]();
console.log(iterator.next()); // { value: "🍫 초콜릿", done: false }
console.log(iterator.next()); // { value: "🍪 쿠키", done: false }
console.log(iterator.next()); // { value: "🍬 사탕", done: false }
console.log(iterator.next()); // { value: undefined, done: true } // 반복 끝

// ✅ 4. 제너레이터 (Generator) 사용해서 쉽게 구현
console.log("\n🎯 제너레이터 사용해서 과자 자동 나누기");
function* snackGenerator() {
  yield "🍫 초콜릿";
  yield "🍪 쿠키";
  yield "🍬 사탕";
}

const gen = snackGenerator();
console.log(gen.next()); // { value: "🍫 초콜릿", done: false }
console.log(gen.next()); // { value: "🍪 쿠키", done: false }
console.log(gen.next()); // { value: "🍬 사탕", done: false }
console.log(gen.next()); // { value: undefined, done: true } // 반복 끝

• 이터레이션은 데이터를 한 덩어리씩 순회하여 처리하는 방식이다. • 이터레이터는 next() 메서드를 통해 순차적으로 데이터를 반환하며, 이터레이터 소비는 이를 활용하는 것이다. • 이터러블은 Symbol.iterator 메서드를 가진 객체로, 배열, 문자열, Map, Set 등이 대표적이다. • yield 키워드를 사용해 next() 를 쉽게 관리 할 수 있는 함수.

커널(Kernel)

커널은 운영체제의 핵심 부분으로, 하드웨어와 애플리케이션 사이에서 중재자 역할을 한다.
애플리케이션이 하드웨어에 직접 접근하지 않고, 커널을 통해 간접적으로 접근하게 하여 안정성과 보안을 유지한다.

커널의 주요 역할

1. 프로세스 관리

   • 여러 프로그램이 동시에 실행될 때 프로세스를 생성하고 종료하며, CPU 시간을 분배한다.
   • 문맥 교환(Context Switching) 을 통해 여러 프로세스가 CPU를 효율적으로 사용할 수 있도록 한다.

2. 메모리 관리

   • 각 프로세스가 메모리를 안전하고 효율적으로 사용할 수 있게 메모리 할당 및 회수를 한다.
   • 가상 메모리 기술을 이용해 실제 메모리보다 더 큰 메모리를 사용하는 것처럼 보이게 한다.

3. 디바이스 관리

   • 키보드, 마우스, 하드디스크 등 하드웨어 장치에 접근하고 입출력(I/O) 작업을 관리한다.
   • 디바이스 드라이버를 통해 하드웨어와 소프트웨어가 원활하게 통신할 수 있도록 한다.

4. 파일 시스템 관리

   • 데이터를 파일 단위로 저장하고 관리한다.
   • 파일 생성, 삭제, 읽기, 쓰기, 이동 등을 처리한다.

운영체제의 역할

운영체제는 컴퓨터 하드웨어와 사용자 간의 중재자 역할을 한다.
하드웨어 자원을 효율적으로 관리하고, 사용자와 애플리케이션이 편리하고 안전하게 시스템을 사용할 수 있게 해준다.
운영체제의 주요 역할은 다음과 같다.

1. 프로세스 관리

• 프로세스는 실행 중인 프로그램의 인스턴스다.
• 운영체제는 프로세스를 생성하고 종료하며, CPU 시간을 분배하고 자원을 할당한다.
• 여러 프로세스가 동시에 실행될 때 문맥 교환(Context Switching) 을 통해 공정하게 CPU를 사용할 수 있게 한다.

예시: 놀이공원에서 놀이기구 타기

• 여러 사람이 놀이기구를 타려면 순서를 정해야 한다.
• 각 사람에게 정해진 시간만큼 놀이기구를 타게 하고, 순서대로 바꿔가며 탄다.
• 운영체제도 여러 프로세스가 공평하게 CPU를 사용할 수 있도록 관리한다.

2. 메모리 관리

• 메모리는 프로그램이 실행되는 공간으로, RAM을 의미한다.
• 운영체제는 프로세스마다 필요한 메모리를 할당하고, 사용이 끝나면 회수한다.
• 가상 메모리(Virtual Memory) 기술을 사용해 물리 메모리보다 더 큰 메모리를 사용하는 것처럼 보이게 할 수 있다.
• 가상 메모리(Virtual Memory) 는 실제 물리 메모리 크기와 상관없이 더 큰 메모리 공간을 사용하는 것처럼 보이게 한다.
• 페이징(Paging) 과 세그멘테이션(Segmentation) 기법을 사용해 프로세스에 필요한 메모리만 나누어 할당한다.

페이지 교체 알고리즘

• FIFO (First In First Out): 가장 먼저 들어온 페이지를 교체한다.
• LRU (Least Recently Used): 가장 오랫동안 사용하지 않은 페이지를 교체한다.
• LFU (Least Frequently Used): 사용 빈도가 가장 적은 페이지를 교체한다.

예시: 책상 공간 관리

• 여러 사람이 한 책상에서 공부할 때, 한 사람씩 필요한 책만 펼치고 나머지 책은 책장에 보관한다.
• 필요할 때만 책장에서 가져와 보는 것처럼, 운영체제는 필요한 메모리만 효율적으로 관리한다.

3. 파일 및 디렉터리 관리

• 데이터를 파일 단위로 저장하고, 디렉터리(폴더) 를 통해 체계적으로 관리한다.
• 파일 생성, 삭제, 읽기, 쓰기, 복사, 이동 등을 처리하며, 권한 설정으로 보안을 강화한다.

파일 시스템 종류

• FAT (File Allocation Table): DOS와 Windows에서 사용되며, 구조가 단순하지만 대용량 파일 관리에 비효율적이다.
• NTFS (New Technology File System): Windows NT 계열에서 사용하며, 보안과 대용량 파일 처리가 뛰어나다.
• ext (Extended File System): 리눅스에서 주로 사용되며, 버전에 따라 성능과 안정성이 다르다.

  예시: 서류철 관리

• 회사에서 문서를 종류별로 서류철에 정리하고, 필요할 때 찾아보고 수정하거나 폐기한다.
• 운영체제도 데이터를 파일과 디렉터리 구조로 체계적으로 관리한다.

4. 장치 관리 (입출력 관리)

• 키보드, 마우스, 프린터, 하드디스크 등 입출력 장치(I/O Device) 를 관리한다.
• 디바이스 드라이버를 통해 하드웨어와 소프트웨어가 원활하게 통신할 수 있게 한다.

예시: 공용 장비 예약 시스템

• 회사에서 공용 프린터나 회의실을 예약하고 사용하는 순서를 정하는 것처럼,
  운영체제는 여러 프로그램이 장치를 사용할 때 충돌 없이 순서대로 사용하게 관리한다.

5. 사용자 인터페이스 제공

• 사용자가 컴퓨터를 쉽게 사용할 수 있도록 그래픽 사용자 인터페이스(GUI) 와 명령줄 인터페이스(CLI) 를 제공한다.
• GUI는 아이콘과 창을 사용한 직관적인 조작을 가능하게 하고, CLI는 명령어를 입력해 작업을 수행한다.

예시: 자동차 대시보드

• 자동차 대시보드에서 속도계, 연료 게이지 등을 보면서 운전자가 쉽게 차량 상태를 확인하고 조작할 수 있다.
• 운영체제도 사용자에게 직관적인 화면을 제공하여 컴퓨터를 쉽게 조작할 수 있게 한다.

6. 보안 및 권한 관리

• 사용자 계정마다 권한을 설정하고, 인증(로그인)과 인가(권한 부여)를 통해 보안을 강화한다.
• 악성 코드(바이러스, 해킹) 로부터 시스템을 보호하고, 데이터 무결성을 유지한다.

예시: 회사 사무실 출입 관리

• 사무실에 들어갈 때 출입증을 확인하고, 등급에 따라 접근 가능한 방이 정해져 있다.
• 운영체제도 사용자마다 접근 권한을 설정해 보안을 강화한다.

7. 네트워크 관리

• 컴퓨터 간의 데이터 통신을 관리하고, 인터넷 연결 및 파일 공유 등을 지원한다.
• 프로토콜(예: TCP/IP)을 통해 안정적이고 효율적인 데이터 전송을 가능하게 한다.

예시: 우편 시스템 관리

• 우편물을 보내려면 주소를 확인하고, 정해진 규칙에 따라 배달해야 한다.
• 운영체제는 네트워크 프로토콜을 통해 데이터가 정확한 주소로 안전하게 전달되게 한다.

시스템 콜과 이중 모드

1. 이중 모드: 왕국과 시민의 이야기

• 왕국 (커널 모드): 운영체제가 사는 곳! 모든 권력을 가지고 있어서 컴퓨터의 모든 자원을 마음대로 사용할 수 있다.
• 시민 (사용자 모드): 우리가 사용하는 프로그램들이 사는 곳. 왕국의 허락 없이는 중요한 일을 할 수 없다.

왜 이중 모드가 필요할까?

만약 시민들이 왕국처럼 모든 권력을 가진다면? 컴퓨터는 금방 엉망진창이 될 거다. 그래서 왕국(커널 모드)이 시민(사용자 모드)을 감시하고, 필요한 일만 허락하는 것이다.

2. 시스템 콜: 시민의 SOS 요청

• 시스템 콜: 시민(사용자 모드)이 왕국(커널 모드)에게 도움을 요청하는 방법. "왕님, 저 파일 좀 읽어주세요!" 또는 "왕님, 저 메모리 좀 빌려주세요!"처럼 필요한 일을 부탁하는 거다.

시스템 콜은 어떻게 작동할까?

1. 시민의 SOS: 프로그램이 필요한 작업을 시스템 콜을 통해 왕국에 요청한다.
2. 왕국의 출동: 왕국(커널 모드)이 시민의 요청을 확인하고, 필요한 일을 처리해준다.
3. 시민의 행복: 왕국이 일을 마치면 시민(사용자 모드)에게 결과를 알려준다.

시스템 콜이 왜 필요할까?

• 안전: 시민들이 직접 왕국의 자원을 사용하면 위험하니까, 왕국을 통해서만 안전하게 사용할 수 있도록 하는 것이다.
• 효율: 왕국이 시민들의 요청을 한 번에 처리해주면, 시민들은 더 효율적으로 일할 수 있다.

시스템 콜(System Call)

시스템 콜은 프로그램(애플리케이션) 이 커널에 요청을 보낼 때 사용하는 인터페이스 다.
애플리케이션이 직접 하드웨어에 접근할 수 없기 때문에, 시스템 콜을 통해 커널에게 요청하고 커널이 대신 작업을 수행한다.

시스템 콜의 종류 및 예시

1. 프로세스 제어

   • fork() : 새로운 프로세스를 생성한다.
   • exec() : 새로운 프로그램을 실행한다.
   • exit() : 프로세스를 종료한다.

2. 파일 조작

   • open() : 파일을 연다.
   • read() : 파일을 읽는다.
   • write() : 파일을 쓴다.
   • close() : 파일을 닫는다.

3. 장치 조작

   • ioctl() : 장치의 제어 및 상태 정보를 얻는다.
   • read() / write() : 장치에서 데이터를 읽거나 쓴다.

4. 정보 유지

   • getpid() : 현재 프로세스의 ID를 얻는다.
   • alarm() : 일정 시간이 지나면 시그널을 보낸다.

소프트웨어 인터럽트 (Software Interrupt)

소프트웨어 인터럽트는 CPU에서 실행 중인 프로그램의 흐름을 명시적으로 변경시키는 메커니즘이다. 하드웨어 인터럽트와 달리, 소프트웨어적으로 특정 명령이나 조건에 의해 발생한다.

주요 특징

• 동기적 발생: 특정 프로그램 코드 실행 중 예측 가능하게 발생한다.
• 다양한 목적: 시스템 호출, 예외 처리, 타이머 이벤트 등 여러 가지 용도로 사용된다.
• 우선순위: 하드웨어 인터럽트와 마찬가지로 우선순위를 가질 수 있다.

작동 방식

1. 인터럽트 발생: 프로그램 실행 중 특정 명령 (예: INT 명령어)이나 조건 (예: 0으로 나누기)이 발생하면 소프트웨어 인터럽트가 트리거된다.
2. 인터럽트 벡터: CPU는 인터럽트 벡터 테이블을 참조하여 해당 인터럽트를 처리하는 핸들러의 주소를 찾는다.
3. 핸들러 실행: CPU는 현재 실행 중인 프로그램의 상태를 저장하고, 해당 인터럽트 핸들러로 제어 흐름을 옮겨 인터럽트를 처리한다.
4. 복귀: 인터럽트 처리가 완료되면, 저장된 상태를 복구하고 원래 프로그램으로 복귀하여 실행을 계속한다.

주요 용도

• 시스템 호출 (System Call): 사용자 프로그램이 운영체제의 기능을 호출할 때 사용된다. (예: 파일 입출력, 네트워크 통신)
• 예외 처리 (Exception Handling): 프로그램 실행 중 오류 (예: 0으로 나누기, 잘못된 메모리 접근)가 발생했을 때 처리한다.
• 타이머 인터럽트 (Timer Interrupt): 주기적인 작업을 수행하기 위해 특정 시간 간격으로 발생한다.
• 프로세스 간 통신 (Inter-Process Communication): 프로세스 간에 데이터를 주고받을 때 사용될 수 있다.

장점

• 유연성: 다양한 상황에 맞춰 인터럽트 핸들러를 작성하여 처리할 수 있다.
• 효율성: 특정 작업을 수행하기 위해 운영체제에 직접 접근하는 것보다 효율적이다.

단점

• 오버헤드: 인터럽트 발생 및 처리 과정에서 일정 정도의 오버헤드가 발생할 수 있다.

소프트웨어 인터럽트는 시스템의 효율적인 작동을 위해 필수적인 메커니즘이며, 다양한 방식으로 활용된다.

1. Number.EPSILON이란?

Number.EPSILON은 자바스크립트에서 표현할 수 있는 가장 작은 부동소수점 차이값을 나타내는 상수다. 즉, 두 개의 숫자가 같다고 간주할 수 있는 최소한의 차이를 의미한다.

console.log(Number.EPSILON); // 2.220446049250313e-16

✔️ Number.EPSILON의 값은 2.220446049250313e-16 (약 2.22 × 10⁻¹⁶)이다. 이는 1과 1보다 큰 가장 작은 숫자 간의 차이를 의미한다.

2. Number.EPSILON이 필요한 이유

자바스크립트에서 숫자는 IEEE 754 부동소수점 방식으로 저장된다. 이 방식은 정확한 소수를 저장하지 못하는 경우가 있다.

🔹 부동소수점 연산 오류 예시

console.log(0.1 + 0.2); // 0.30000000000000004 ❌ console.log(0.1 + 0.7); // 0.7999999999999999 ❌

위 코드에서 기대값은 0.3, 0.8이지만, 부동소수점 방식의 특성상 작은 오차가 발생한다.

이러한 오차 때문에 0.1 + 0.2 === 0.3을 비교하면 false가 나온다.

console.log(0.1 + 0.2 === 0.3); // false ❌

✅ Number.EPSILON을 사용하면 이 문제를 해결할 수 있다.

3. Number.EPSILON을 활용한 오차 보정

Number.EPSILON을 사용하면 두 숫자의 차이가 아주 작을 때, 같은 값으로 간주할 수 있다.

🔹 정확한 소수 비교 함수

function isEqual(a, b) { return Math.abs(a - b) < Number.EPSILON; }

console.log(isEqual(0.1 + 0.2, 0.3)); // true ✅ console.log(isEqual(0.1 + 0.7, 0.8)); // true ✅

✅ 이 함수는 두 숫자의 차이가 Number.EPSILON보다 작으면 같은 값으로 판단한다. ✅ 즉, 0.1 + 0.2와 0.3이 같다고 인식하게 된다.

4. Number.EPSILON의 원리

자바스크립트의 부동소수점 연산 방식(IEEE 754)에서 숫자는 64비트(8바이트)로 저장된다. 이 중, • 1비트 → 부호(Sign) • 11비트 → 지수(Exponent) • 52비트 → 가수(Fraction)

이런 방식으로 저장되기 때문에 일부 소수를 정확하게 표현할 수 없다. 예를 들어, 0.1은 2진수로 변환하면 무한 반복되는 값이 된다.

0.1(10진수) = 0.00011001100110011...(2진수)

이러한 이유로 0.1과 같은 값을 정확하게 저장할 수 없어 연산 시 오차가 발생한다. 이때, Number.EPSILON을 이용하면 숫자 비교 시 발생하는 오차를 해결할 수 있다.

5. Number.EPSILON이 실제로 사용되는 사례

✅ 1) Math.abs()와 함께 사용하여 오차 보정

function isSame(a, b) { return Math.abs(a - b) < Number.EPSILON; }

console.log(isSame(0.1 + 0.2, 0.3)); // true console.log(isSame(0.15 + 0.15, 0.3)); // true

👉 두 값의 차이가 Number.EPSILON보다 작으면 같다고 간주한다.

✅ 2) 배열에서 특정 값 찾기 (정확한 소수 비교)

const numbers = [0.1, 0.2, 0.3];

console.log(numbers.includes(0.1 + 0.2)); // false (부동소수점 오차 때문) console.log(numbers.some(n => isSame(n, 0.1 + 0.2))); // true (오차 보정)

👉 includes()는 오차 때문에 false를 반환하지만, isSame()을 활용하면 정확한 비교가 가능하다.

6. Number.EPSILON의 한계

🔹 Number.EPSILON은 아주 작은 값이지만, 모든 부동소수점 오류를 해결하는 것은 아니다. • Number.EPSILON은 1과 1보다 큰 가장 작은 숫자 간의 차이이므로, 더 작은 값들을 비교할 때는 적절하지 않을 수 있다. • 값의 크기에 따라 오차가 다를 수 있다. → 0.1과 0.2의 비교는 Number.EPSILON으로 해결되지만, 더 큰 수(예: 100000000.1과 100000000.2)는 더 큰 오차를 가질 수 있다.

🔹 오차 범위를 조정하는 방법

오차 범위를 조절하려면 비교하는 값의 크기에 따라 EPSILON을 조정해야 한다.

function isAlmostEqual(a, b, epsilon = Number.EPSILON * Math.max(1, Math.abs(a), Math.abs(b))) { return Math.abs(a - b) < epsilon; }

console.log(isAlmostEqual(100000000.1 + 0.2, 100000000.3)); // true console.log(isAlmostEqual(0.1 + 0.2, 0.3)); // true

✅ 큰 숫자일수록 EPSILON을 더 크게 조정하여 비교 정확도를 높인다.

🫡 Number.EPSILON 정리

자바스크립트에서 아주 작은 숫자 차이를 나타내는 값이다. 숫자로 표현하면 0.000000000000000222 (약 2.22 × 10⁻¹⁶)

console.log(Number.EPSILON); // 2.220446049250313e-16

✅ 이 값은 자바스크립트가 표현할 수 있는 가장 작은 부동소수점 차이값이다. ✅ 두 숫자가 거의 같은지 비교할 때 사용한다.

2. Number.EPSILON이 왜 필요해?

자바스크립트에서 소수점 계산을 하면 정확한 값이 안 나올 수 있다!

console.log(0.1 + 0.2); // 0.30000000000000004 ❌ (0.3이 아님!)
console.log(0.1 + 0.7); // 0.7999999999999999 ❌ (0.8이 아님!)

✅ 소수점 연산 시 미세한 오차가 발생한다. ✅ 이 문제를 해결하려면 Number.EPSILON을 사용하면 된다!

3. Number.EPSILON을 활용한 오차 해결 방법

✅ 정확한 소수점 비교 함수

function isEqual(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}

console.log(isEqual(0.1 + 0.2, 0.3)); // true ✅ (정확한 비교 가능!)
console.log(isEqual(0.15 + 0.15, 0.3)); // true ✅

✅ Math.abs(a - b) → 두 숫자의 차이가 Number.EPSILON보다 작으면 같은 값으로 간주한다. ✅ 즉, 0.1 + 0.2를 비교할 때 실제 값이 0.30000000000000004라도 0.3으로 인정해 준다.

4. Number.EPSILON을 실제로 어디에 써?

✅ 배열에서 특정 값 찾을 때 (부동소수점 오차 보정)

const numbers = [0.1, 0.2, 0.3];

console.log(numbers.includes(0.1 + 0.2)); // false ❌ (오차 때문에 찾을 수 없음)
console.log(numbers.some(n => isEqual(n, 0.1 + 0.2))); // true ✅ (오차 보정으로 찾음)

✅ numbers.includes(0.1 + 0.2) → 부동소수점 오차 때문에 false가 나옴. ✅ isEqual()을 사용하면 정확하게 비교할 수 있다!

5. Number.EPSILON이 항상 정답은 아니야!

✅ 큰 숫자 비교할 때는 EPSILON 값을 조정해야 한다.

function isAlmostEqual(a, b) {
  const epsilon = Number.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
  return Math.abs(a - b) < epsilon;
}

console.log(isAlmostEqual(100000000.1 + 0.2, 100000000.3)); // true ✅

✅ 큰 숫자는 Number.EPSILON보다 더 큰 오차가 발생할 수 있다. ✅ 비교하는 숫자의 크기에 따라 EPSILON 값을 조정해야 한다!

✅ 원시 타입(Primitive Type) → 값 자체를 저장하는 타입 ✅ 참조 타입(Reference Type) → 객체(Object), 배열(Array), 함수(Function)처럼 여러 값을 저장하는 복합적인 값

1. 원시 타입 (Primitive Type)

원시 타입은 “단순한 값” 이라고 보면 된다. 이 값들은 한 번 만들어지면 바꿀 수 없다(Immutable).

1) 숫자 (Number)

숫자는 정수, 실수(소수점), 특수 숫자(무한대, NaN)를 포함한다

let num1 = 42;       // 정수
let num2 = 3.14;     // 실수 (소수점 있는 숫자)
let inf = Infinity;  // 무한대
let nan = NaN;       // 숫자가 아닌 값 (Not a Number)

NaN이 나오는 경우

console.log("hello" * 2); // NaN (문자열을 숫자로 곱할 수 없음)

2) 큰 숫자 (BigInt)

Number 타입은 너무 큰 숫자를 못 담는다. 그래서 BigInt 타입이 생겼다. 숫자 뒤에 n을 붙이면 BigInt가 된다.

let bigNumber = 123456789012345678901234567890n;
console.log(bigNumber);

3) 문자열 (String)

문자는 " " (쌍따옴표), ' ' (홑따옴표), ` `` (백틱)으로 감싸면 된다.

let str1 = "안녕!";
let str2 = '자바스크립트';
let str3 = `오늘 날짜는 ${new Date().toLocaleDateString()} 입니다.`;

백틱(``)을 사용하면 변수를 쉽게 넣을 수 있다! (${} (템플릿리터널) 활용)

4) 참/거짓 (Boolean)

참(true) 또는 거짓(false)만 가지는 타입이다.

let isCodingFun = true;
let isTired = false;

조건문에서 많이 사용됨

if (isCodingFun) {
  console.log("코딩은 재미있어!");
} else {
  console.log("코딩이 별로야...");
}

5) 값이 없음 (Undefined)

값을 안 넣은 변수는 undefined가 된다.

let name;
console.log(name); // undefined (아직 값이 없음)

6) 값이 없음 (Null)

null은 “아예 비어 있다” 는 의미다. undefined와 다른 점은 “값을 일부러 비운 것” 이라는 점이다.

let emptyValue = null;
console.log(emptyValue); // null

undefined vs null 차이

• undefined → 아예 값이 없는 상태 (변수 선언만 하고 값 안 넣음) • null → 값을 일부러 비운 상태 (의도적으로 비어 있음)

7) 심볼 (Symbol)

Symbol은 고유한 값(유일한 값) 을 만들 때 사용한다. 객체의 키(key)로 많이 활용된다.

let sym1 = Symbol("id");
let sym2 = Symbol("id");

console.log(sym1 === sym2); // false (항상 서로 다른 값)

2. 참조 타입 (Reference Type)

참조 타입은 여러 개의 값을 묶어서 저장할 수 있는 타입이다. 즉, 변수 하나에 여러 데이터를 저장할 수 있음.

1) 객체 (Object)

객체는 { 키: 값 } 형태로 데이터를 저장한다. 이렇게 하면 관련 있는 데이터를 하나로 묶을 수 있다.

let person = {
  name: "철수",
  age: 25,
  job: "개발자"
};

console.log(person.name); // 철수
console.log(person["age"]); // 25

2) 배열 (Array)

배열은 여러 개의 데이터를 순서대로 저장할 때 사용한다. 배열의 요소는 [ ] 대괄호 안에 넣으면 된다.

let fruits = ["사과", "바나나", "포도"];

console.log(fruits[0]); // 사과
console.log(fruits[1]); // 바나나
console.log(fruits.length); // 3 (배열 길이)

3) 함수 (Function)

자바스크립트에서는 함수도 데이터 타입이다. 즉, 함수도 변수에 저장할 수 있다.

function sayHello() {
  return "안녕하세요!";
}

let greet = sayHello;
console.log(greet()); // "안녕하세요!"

4) 날짜 (Date)

자바스크립트에서 날짜를 다룰 때 사용하는 타입.

let today = new Date();
console.log(today.toLocaleDateString()); // 현재 날짜 출력

5) 정규 표현식 (RegExp)

문자열에서 특정 패턴을 찾을 때 사용!

let pattern = /hello/g;
let text = "hello world! hello!";
console.log(text.match(pattern)); // ["hello", "hello"]

6) 오류 (Error)

자바스크립트에서 오류를 다룰 때 사용!

try {
  throw new Error("문제가 발생했어요!");
} catch (err) {
  console.log(err.message);
}

typeof 연산자로 데이터 타입 확인

console.log(typeof 42); // "number"
console.log(typeof "Hello"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (버그지만 그대로 유지됨!)
console.log(typeof Symbol()); // "symbol"
console.log(typeof {}); // "object"
console.log(typeof []); // "object" (배열도 객체!)
console.log(typeof function() {}); // "function" (특별하게 'function' 반환)

✅ 1) 같은 객체를 가리킴 (Shallow Copy)

let obj1 = { value: 100 };
let obj2 = obj1;

obj2.value = 200;

console.log(obj1.value); // 200 (같은 주소를 공유해서 같이 바뀜!)
console.log(obj2.value); // 200

✅ 2) 독립적인 객체를 만들고 싶다면? (Deep Copy)

객체를 복사할 때 독립적인 새로운 객체를 만들려면 Object.assign() 또는 spread(...)를 사용하면 된다.

let obj1 = { value: 100 };
let obj2 = { ...obj1 }; // 새로운 객체로 복사 (spread 연산자)

obj2.value = 200;

console.log(obj1.value); // 100 (원본은 그대로!)
console.log(obj2.value); // 200

함수 (Function)

함수는 특정한 동작을 실행하는 코드 블록이다. 즉, 어떤 입력을 받아 처리하고, 결과를 반환하는 역할을 한다. 한 번 정의해두면 필요할 때마다 재 사용 할 수 있다.

함수 호출(Function Call)

함수 호출은 정의된 함수를 실행하는 과정이다. 함수를 호출하면 함수 내부의 코드가 실행된다.

1) 기본적인 함수 호출

function greet() {
  console.log("안녕하세요!");
}

greet(); // 실행 결과: "안녕하세요!"

✅ greet(); 를 실행하면 함수 내부의 코드가 실행된다. ✅ 2) 매개변수가 있는 함수 호출

매개변수를 사용하면 입력값에 따라 다르게 동작하는 함수를 만들 수 있다.

function sayHello(name) {
  console.log("안녕하세요, " + name + "님!");
}

sayHello("철수"); // "안녕하세요, 철수님!"
sayHello("영희"); // "안녕하세요, 영희님!"

✅ 함수 호출 시 sayHello("이름") 형태로 값을 전달하면 name에 해당 값이 들어간다. ✅ 3) 반환값이 있는 함수 호출 (return 사용)

return을 사용하면 함수에서 결과 값을 반환할 수 있다.

function add(a, b) {
  return a + b;
}

let result = add(3, 5);
console.log(result); // 8

✅ return이 없으면 함수는 단순히 실행만 하고 끝난다. ✅ return이 있으면 값을 돌려주고, 변수에 저장하거나 다른 연산에 사용할 수 있다.

익명 함수(Anonymous Function)

익명 함수는 이름이 없는 함수이다. 보통 변수에 할당해서 사용하거나, 다른 함수의 매개변수로 전달된다.

1) 변수에 저장하는 익명 함수

let hello = function() {
  console.log("안녕하세요!");
};

hello(); // 실행 결과: "안녕하세요!"

✅ 함수에 이름이 없고, hello 변수에 저장하여 호출할 수 있다.

2) 매개변수가 있는 익명 함수

let add = function(a, b) {
  return a + b;
};

console.log(add(2, 3)); // 5

✅ 일반적인 함수와 동일하게 매개변수를 사용하여 값을 전달할 수 있다.

3) 즉시 실행 함수 (IIFE, Immediately Invoked Function Expression)

익명 함수를 선언하자마자 바로 실행할 수도 있다.

(function() {
  console.log("즉시 실행 함수입니다!");
})();

✅ 함수 선언 후 바로 실행되며, 한 번만 실행되는 용도로 사용된다.

구조 분해 할당 (Destructuring Assignment)

구조 분해 할당은 배열이나 객체의 값을 쉽게 변수에 할당하는 문법이다.

1) 배열에서 구조 분해 할당

const fruits = ["사과", "바나나", "포도"];

// 배열의 값을 각각 변수에 할당
const [first, second, third] = fruits;

console.log(first);  // "사과"
console.log(second); // "바나나"
console.log(third);  // "포도"

배열의 순서대로 변수에 값을 넣어준다.

2) 객체에서 구조 분해 할당

const person = { name: "철수", age: 25 };

// 객체의 키(key) 값을 변수에 할당
const { name, age } = person;

console.log(name); // "철수"
console.log(age);  // 25

객체의 키(key)와 같은 이름의 변수를 만들어 값을 할당한다.

🔹 값 교환하기 (Swap Values)

두 변수의 값을 교환할 때 임시 변수를 사용하지 않고, 구조 분해 할당을 활용할 수 있다.

let a = 1;
let b = 2;

// 구조 분해 할당으로 값 교환
[a, b] = [b, a];

console.log(a); // 2
console.log(b); // 1

[b, a] 형태로 배열을 만들고, 구조 분해 할당을 이용해 값을 바꾼다.

🔹 비구조화 할당 (Destructuring Assignment)

비구조화 할당은 구조 분해 할당과 같은 개념이다.

const user = { id: 1, username: "coding" };

// 객체 비구조화 할당
const { id, username } = user;

console.log(id);       // 1
console.log(username); // "coding"

“비구조화 할당”은 기존 객체의 구조를 벗겨서(해체해서) 변수에 값을 할당하는 것과 같기 때문에, 구조 분해 할당과 같은 개념이다.

🔹 스프레드 연산자 (Spread Operator, ...)

스프레드 연산자는 배열이나 객체의 요소를 펼쳐서(복사해서) 사용할 때 사용된다.

1) 배열에서 사용

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5, 6];

console.log(arr2); // [1, 2, 3, 4, 5, 6]

...arr1을 사용하면 arr1의 모든 요소를 새로운 배열에 복사할 수 있다.

2) 객체에서 사용

const obj1 = { name: "철수", age: 25 };
const obj2 = { ...obj1, job: "개발자" };

console.log(obj2); 
// { name: "철수", age: 25, job: "개발자" }

기존 객체에 새로운 속성을 추가할 때 유용하다.

🔹 배열 내 같은 요소 제거하기 (Remove Duplicates in Array)

배열에서 중복된 요소를 제거하는 방법은 여러 가지가 있다.

• Set을 이용한 중복 제거

const numbers = [1, 2, 2, 3, 4, 4, 5];

// Set 객체를 사용하여 중복 제거
const uniqueNumbers = [...new Set(numbers)];

console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

Set은 중복을 허용하지 않는 자료구조이므로, 이를 활용하면 쉽게 중복을 제거할 수 있다.

🔹 &&와 || 연산자로 조건문 대체하기

조건문을 간결하게 줄이는 방법으로 &&(AND), ||(OR) 연산자를 사용할 수 있다.

1) && 연산자로 조건문 대체하기

const isLoggedIn = true;

// isLoggedIn이 true일 때만 실행
isLoggedIn && console.log("로그인 성공!");

&& 연산자는 앞의 조건이 true일 때만 뒤의 코드를 실행한다.

(조건이 false면 실행되지 않는다.)

2) || 연산자로 기본값 설정

const username = null;

// username이 없으면 "Guest"를 기본값으로 사용
const displayName = username || "Guest";

console.log(displayName); // "Guest"

|| 연산자는 앞의 값이 false일 때(즉, null, undefined, 0, ""일 때) 뒤의 값을 사용한다.

🫡마무리

1. 원시 타입 (Primitive Type)

✅ Number → 정수, 실수, Infinity, NaN 같은 숫자를 저장하는 타입 ✅ BigInt → Number보다 더 큰 정수를 다룰 수 있는 타입 (n을 붙여 사용) ✅ String → 문자 데이터를 저장하는 타입 (", ', ` 사용 가능) ✅ Boolean → true 또는 false 값을 가지는 타입 ✅ Undefined → 변수를 선언했지만, 값을 할당하지 않은 상태 ✅ Null → 의도적으로 값이 비어 있음을 나타내는 타입 ✅ Symbol → 유일한 값을 생성하는 타입 (객체의 key로 활용 가능)

2. 참조 타입 (Reference Type)

✅ Object → 여러 데이터를 key-value 형태로 저장하는 타입 ✅ Array → 여러 값을 순서대로 저장하는 리스트 구조 ✅ Function → 실행 가능한 코드 블록도 변수에 저장할 수 있음 ✅ Date → 날짜와 시간을 다루는 객체 ✅ RegExp → 정규 표현식을 다룰 때 사용하는 객체 ✅ Error → 예외 처리를 위해 사용되는 객체

3. 함수 (Function)

✅ 함수 호출(Function Call) → 함수이름() 형태로 실행 ✅ 매개변수가 있는 함수 → 함수에 값을 전달하여 다르게 동작하도록 설정 ✅ return을 사용하는 함수 → 결과 값을 반환하고, 다른 연산에 활용 가능 ✅ 익명 함수 (Anonymous Function) → 이름이 없는 함수로 변수에 저장하여 사용 ✅ 즉시 실행 함수 (IIFE) → 선언과 동시에 실행되는 함수

4. 구조 분해 할당 (Destructuring Assignment)

✅ 배열 구조 분해 → [a, b] = 배열 형태로 배열 요소를 변수에 할당 ✅ 객체 구조 분해 → { key } = 객체 형태로 객체의 값을 변수에 할당

5. 값 교환하기 (Swap Values)

✅ 구조 분해 할당을 활용해 값 교환 → [a, b] = [b, a]

6. 비구조화 할당 (Destructuring Assignment)

✅ 구조 분해 할당과 같은 개념 → 객체나 배열의 값을 쉽게 변수에 할당

7. 스프레드 연산자 (Spread Operator, ...)

✅ 배열 확장 → ...배열을 사용해 기존 배열을 확장할 수 있음 ✅ 객체 확장 → { ...객체, 추가속성 } 형태로 기존 객체를 복사하면서 새로운 속성 추가

8. 배열 내 같은 요소 제거하기

✅ Set을 활용하여 중복 제거 → [...new Set(배열)]

9. &&와 || 연산자로 조건문 대체하기

✅ && 연산자 → 앞의 값이 true이면 뒤의 코드 실행 (조건 && 실행할 코드) ✅ || 연산자 → 앞의 값이 false이면 기본값 설정 (변수 || 기본값)