Stored Procedure란?

자주 사용하는 SQL 코드 덩어리를 저장해두고 필요할 때마다 호출하여 사용할 수 있는 기능입니다. 프로그래밍의 함수와 비슷한 개념입니다.

Stored Procedure 생성 방법

DBeaver에서 생성:

1. 데이터베이스의 Procedures 메뉴에서 우클릭
2. 새로운 Procedure 생성 선택
3. source 메뉴에서 BEGIN/END 사이에 코드 작성

SQL로 직접 생성:

DROP PROCEDURE IF EXISTS 데이터베이스명.get_all;

DELIMITER $$
CREATE PROCEDURE 데이터베이스명.get_all()
BEGIN
  SELECT * FROM product WHERE 가격 > 5000;
END 
$$
DELIMITER ;

주요 구성 요소:

• DROP PROCEDURE IF EXISTS: 기존 프로시저가 있으면 삭제
• DELIMITER $$: 구분자를 $$로 변경 (내부 ; 때문)
• BEGIN/END: 실행할 코드 블록
• DELIMITER ;: 구분자를 다시 ;로 복원

Stored Procedure 실행

CALL procedure이름();
-- 또는
CALL 데이터베이스명.procedure이름();

성능 및 생산성 향상

성능 측면:

• 캐싱된 실행 계획 재사용으로 약간의 속도 향상
• 하지만 실제 실행 속도는 직접 SQL과 큰 차이 없음

생산성 측면:

1. 코드 재사용: 반복되는 긴 코드를 간단히 호출
2. 팀 협업: 개발자가 아닌 사용자도 복잡한 쿼리 활용 가능
3. 유지보수: 중앙 집중식 코드 관리

변수 (Variables) - 데이터 임시 저장

User Variable (@변수)

세션이 종료될 때까지 유지되는 전역 변수입니다.

-- 변수 생성 및 할당
SET @age = 20;
SELECT @age := 20;  -- 동일한 결과

-- 변수 사용
SELECT @age;

-- 계산과 함께 사용
SET @price = 6000;
SELECT * FROM product WHERE 가격 = @price;

-- 서브쿼리 결과 저장
SET @count = (SELECT COUNT(*) FROM product WHERE 가격 = 5000);

-- 변수 값 증가
SET @age = @age + 1;

Local Variable (DECLARE 변수)

Procedure 내부에서만 사용 가능한 지역 변수입니다.

CREATE PROCEDURE var_test() 
BEGIN 
  DECLARE 변수1 INT;
  DECLARE 변수2 VARCHAR(100);
  DECLARE 변수3 INT DEFAULT 123;  -- 기본값 설정

  SET 변수1 = 10;
  SET 변수1 = 변수1 + 1;
  SELECT 변수1;  -- 결과: 11
END

User Variable vs Local Variable 비교

Parameter - 유연한 Procedure 만들기

입력 Parameter (IN)

Procedure 실행 시 외부에서 값을 전달받을 수 있습니다.

-- 단일 파라미터
CREATE PROCEDURE get_products(price_limit INT)
BEGIN
    SELECT * FROM product WHERE 가격 > price_limit;
END;

-- 사용법
CALL get_products(6000);  -- 6000원 이상 상품 조회
CALL get_products(8000);  -- 8000원 이상 상품 조회

-- 다중 파라미터
CREATE PROCEDURE search_products(price_min INT, name_part VARCHAR(100))
BEGIN
    SELECT * FROM product 
    WHERE 가격 > price_min OR 상품명 LIKE CONCAT('%', name_part, '%');
END;

-- 사용법
CALL search_products(5000, '김치');

출력 Parameter (OUT)

Procedure 내부의 값을 외부로 전달할 수 있습니다.

CREATE PROCEDURE calculate_total(OUT total_price INT)
BEGIN
    SET total_price = (SELECT SUM(가격) FROM product);
END;

-- 사용법
CALL calculate_total(@result);
SELECT @result;  -- 총 가격 출력

날짜/시간 데이터 처리

날짜 데이터 타입

정밀도 설정:

DATETIME(6)  -- 마이크로초(6자리)까지 저장

날짜 조회 및 필터링

기본 날짜 조회:

-- 특정 날짜/시간 이후
SELECT * FROM blog WHERE 발행일 > '2022-03-10 08:24:25';

-- 정확한 날짜/시간
SELECT * FROM blog WHERE 발행일 = '2022-03-10 08:24:25';

특정 날짜의 모든 데이터 조회:

-- 2022년 3월 10일 하루 전체
SELECT * FROM blog 
WHERE 발행일 >= '2022-03-10 00:00:00' 
  AND 발행일 < '2022-03-11 00:00:00';

-- 현재 시간까지의 범위
SELECT * FROM blog 
WHERE 발행일 > '2022-03-10 00:00:00' 
  AND 발행일 <= NOW();

날짜 함수 활용

현재 시간 조회:

SELECT NOW();           -- 현재 날짜와 시간
SELECT NOW(6);          -- 마이크로초까지
SELECT CURDATE();       -- 현재 날짜만

날짜 형식 변경:

SELECT DATE_FORMAT(NOW(), '%Y년 %m월 %d일');
SELECT DATE_FORMAT(NOW(), '%H:%i:%s');

주요 형식 지정자:

• %Y: 4자리 년도, %y: 2자리 년도
• %m: 월(01-12), %d: 일(01-31)
• %H: 시간(00-23), %i: 분(00-59), %s: 초(00-59)

날짜 연산:

-- 1년 추가
SELECT DATE_ADD(NOW(), INTERVAL 1 YEAR);
SELECT NOW() + INTERVAL 1 YEAR;

-- 다양한 간격
SELECT DATE_ADD('2022-01-01', INTERVAL 1 MONTH);
SELECT DATE_ADD('2022-01-01', INTERVAL 7 DAY);

날짜 부분 추출:

SELECT YEAR(NOW());     -- 년도
SELECT MONTH(NOW());    -- 월
SELECT DAY(NOW());      -- 일
SELECT HOUR(NOW());     -- 시간

날짜 데이터 삽입

INSERT INTO blog (제목, 발행일) 
VALUES ('새 글', '2024-01-15 14:30:00');

-- 현재 시간으로 삽입
INSERT INTO blog (제목, 발행일) 
VALUES ('새 글', NOW());

실전 활용 예제

월간 활성 사용자(MAU) 계산

-- 2022년 11월 MAU
SELECT COUNT(*) FROM login_record 
WHERE last_login >= '2022-11-01 00:00:00' 
  AND last_login < '2022-12-01 00:00:00';

조건부 날짜 조회

-- 9월의 짝수일 데이터 조회
SELECT * FROM login_record 
WHERE MONTH(last_login) = 9 
  AND DAY(last_login) % 2 = 0;

복합 Procedure 예제

CREATE PROCEDURE analyze_sales(
    IN start_date DATE,
    IN end_date DATE,
    OUT total_sales INT,
    OUT avg_daily_sales DECIMAL(10,2)
)
BEGIN
    DECLARE day_count INT;

    -- 총 매출 계산
    SELECT SUM(가격) INTO total_sales
    FROM sales s
    JOIN product p ON s.상품id = p.id
    WHERE s.구매날짜 BETWEEN start_date AND end_date;

    -- 일수 계산
    SET day_count = DATEDIFF(end_date, start_date) + 1;

    -- 일평균 매출 계산
    SET avg_daily_sales = total_sales / day_count;
END;

-- 사용법
CALL analyze_sales('2022-01-01', '2022-01-31', @total, @avg);
SELECT @total as 총매출, @avg as 일평균매출;

시간대별 분석 Procedure

CREATE PROCEDURE hourly_analysis(analysis_date DATE)
BEGIN
    SELECT 
        HOUR(구매시간) as 시간대,
        COUNT(*) as 구매건수,
        SUM(가격) as 시간대매출
    FROM sales s
    JOIN product p ON s.상품id = p.id
    WHERE DATE(구매시간) = analysis_date
    GROUP BY HOUR(구매시간)
    ORDER BY 시간대;
END;

CALL hourly_analysis('2022-03-15');

이러한 Stored Procedure, 변수, 날짜 처리 기능들을 조합하면 복잡한 비즈니스 로직도 효율적으로 구현할 수 있으며, 코드의 재사용성과 유지보수성을 크게 향상시킬 수 있습니다.

여러 테이블의 데이터를 함께 출력하는 방법

정규화된 데이터베이스에서는 데이터가 여러 테이블에 분산되어 있어 관련 정보를 함께 조회해야 하는 경우가 많습니다.

예시 테이블 구조

program 테이블

teacher 테이블

기본 다중 테이블 조회

FROM 절에 여러 테이블 지정

-- 여러 테이블 동시 조회
SELECT 프로그램, 가격, 강사, 출신대학
FROM program, teacher;

-- 테이블명.컬럼명 형태로 명시 (권장)
SELECT program.프로그램, program.가격, teacher.강사, teacher.출신대학
FROM program, teacher;

CROSS JOIN의 문제점

조건 없이 여러 테이블을 조회하면 카르테시안 곱(Cartesian Product)이 발생합니다:

CROSS JOIN 결과 예시

• program 테이블 5행 × teacher 테이블 3행 = 15행 출력
• 대부분이 의미 없는 조합

올바른 조회 방법 - WHERE 조건 추가

SELECT program.프로그램, program.가격, teacher.강사, teacher.출신대학
FROM program, teacher
WHERE program.강사id = teacher.id;

올바른 결과

INNER JOIN - 권장되는 문법

INNER JOIN 기본 문법

SELECT 출력할컬럼들
FROM 테이블1 INNER JOIN 테이블2
ON 조건문;

실제 사용 예시

SELECT program.프로그램, program.가격, teacher.강사, teacher.출신대학
FROM program INNER JOIN teacher
ON program.강사id = teacher.id;

INNER JOIN의 장점:

• 의도가 명확히 드러남 ("테이블을 연결한다")
• 가독성이 좋음
• 표준 SQL 문법

3개 이상 테이블 JOIN

-- 방법 1: FROM에 여러 테이블
SELECT *
FROM 테이블1, 테이블2, 테이블3
WHERE 조건1 AND 조건2;

-- 방법 2: 연속된 INNER JOIN (권장)
SELECT *
FROM 테이블1 
INNER JOIN 테이블2 ON 조건1
INNER JOIN 테이블3 ON 조건2;

다양한 JOIN 유형

LEFT JOIN - 왼쪽 테이블 전체 포함

SELECT * 
FROM program 
LEFT JOIN teacher
ON program.강사id = teacher.id;

LEFT JOIN 결과

• 특징: 왼쪽 테이블(program)의 모든 행이 포함됨
• NULL: 매칭되는 오른쪽 테이블 데이터가 없는 경우

RIGHT JOIN - 오른쪽 테이블 전체 포함

SELECT * 
FROM program 
RIGHT JOIN teacher
ON program.강사id = teacher.id;

NULL 값 활용한 분석

-- 매칭되지 않는 데이터 찾기
SELECT * 
FROM program 
LEFT JOIN teacher
ON program.강사id = teacher.id
WHERE teacher.id IS NULL;  -- 강사 정보가 없는 프로그램

JOIN 유형 비교

데이터 삽입 (INSERT)

기본 INSERT 문법

INSERT INTO 테이블명 (컬럼명1, 컬럼명2, ...) VALUES (값1, 값2, ...);

실제 사용 예시

-- 테이블 생성
CREATE TABLE product (
    id INT AUTO_INCREMENT PRIMARY KEY,
    상품명 VARCHAR(100),
    가격 INT
);

-- 데이터 삽입
INSERT INTO product (id, 상품명, 가격) VALUES (1, '김치', 500);

-- AUTO_INCREMENT 컬럼 생략
INSERT INTO product (상품명, 가격) VALUES ('두부', 1000);

-- 모든 컬럼 입력 시 컬럼명 생략 가능
INSERT INTO product VALUES (3, '수박', 1500);

-- 여러 행 동시 삽입
INSERT INTO product VALUES 
    (4, '참외', 2000), 
    (5, '배추', 2500);

다른 테이블 데이터 복사

-- SELECT 결과를 다른 테이블에 삽입
INSERT INTO product (id, 상품명, 가격)
SELECT id, 상품명, 가격 FROM product2;

-- 테이블 전체 복사 (MySQL)
CREATE TABLE 새테이블 SELECT * FROM 기존테이블;

-- 임시 테이블 생성
CREATE TEMPORARY TABLE 임시테이블 SELECT * FROM 기존테이블;

데이터 수정 (UPDATE)

기본 UPDATE 문법

UPDATE 테이블명 
SET 컬럼1 = 값, 컬럼2 = 값
WHERE 조건식;

실제 사용 예시

-- 특정 행 수정
UPDATE product
SET 가격 = 5000, 상품명 = '단무지'
WHERE id = 1;

-- 기존 값 활용한 수정
UPDATE product
SET 가격 = 가격 + 100  -- 기존 가격에 100원 추가
WHERE id = 1;

-- 조건부 수정 (IF 함수 활용)
UPDATE user_sales 
SET email = IF(first_name = 'Solly', 'admin@test.com', 'test@test.com') 
WHERE email = '';

JOIN과 함께 사용하는 UPDATE

UPDATE A INNER JOIN B 
ON 조인조건
SET A.컬럼 = 값, B.컬럼 = 값
WHERE 조건식;

데이터 삭제 (DELETE)

기본 DELETE 문법

DELETE FROM 테이블명 WHERE 조건식;

실제 사용 예시

-- 특정 조건의 행 삭제
DELETE FROM product WHERE id = 5;

-- NULL 값을 가진 행 삭제
DELETE FROM user_sales WHERE sales IS NULL;

JOIN과 함께 사용하는 DELETE

DELETE A 
FROM A INNER JOIN B 
ON 조인조건
WHERE 조건식;

-- A 테이블에서만 삭제: DELETE A
-- B 테이블에서만 삭제: DELETE B  
-- 양쪽 모두 삭제: DELETE A, B

중요한 주의사항:

• WHERE 조건 빼먹으면 모든 행이 삭제됨
• Foreign Key 제약이 있는 데이터는 삭제 시 오류 발생
• 삭제 전 반드시 백업 고려

UNION - 결과 합치기

UNION 기본 문법

SELECT 컬럼1, 컬럼2 FROM 테이블1
UNION
SELECT 컬럼1, 컬럼2 FROM 테이블2;

실제 사용 예시

-- 두 테이블의 모든 데이터 합치기
SELECT * FROM stock
UNION
SELECT * FROM stock2;

-- 같은 테이블의 다른 조건 결과 합치기
SELECT * FROM stock WHERE id = 1
UNION
SELECT * FROM stock WHERE id = 2;

UNION vs UNION ALL

-- UNION: 중복 제거
SELECT * FROM stock
UNION
SELECT * FROM stock2;

-- UNION ALL: 중복 포함
SELECT * FROM stock
UNION ALL
SELECT * FROM stock2;

UNION 사용 조건:

• 컬럼 개수가 동일해야 함
• 데이터 타입이 호환되어야 함

JOIN vs UNION 비교:

• JOIN: 테이블을 좌우로 결합 (컬럼 확장)
• UNION: 테이블을 상하로 결합 (행 확장)

VIEW - 가상 테이블

VIEW 개념

• 자주 사용하는 복잡한 SELECT 문을 저장해둔 가상 테이블
• 실제 데이터를 저장하지 않고 쿼리만 저장
• 테이블처럼 사용 가능

VIEW 생성

CREATE VIEW 뷰이름 AS
SELECT 컬럼1, 컬럼2, ...
FROM 테이블명
WHERE 조건;

-- 실제 예시
CREATE VIEW sales_summary AS
SELECT s.id, s.구매날짜, p.상품명, p.가격, u.고객명
FROM sales s
INNER JOIN product p ON s.상품id = p.id
INNER JOIN user_table u ON s.고객번호 = u.id;

VIEW 활용

-- VIEW를 테이블처럼 사용
SELECT * FROM sales_summary;
SELECT * FROM sales_summary WHERE 가격 > 10000;

-- VIEW 기반 추가 집계
SELECT 구매날짜, SUM(가격) as 일별매출
FROM sales_summary
GROUP BY 구매날짜;

VIEW의 장점:

1. 재사용성: 복잡한 JOIN 쿼리를 간단히 재사용
2. 보안: 필요한 컬럼만 노출하여 데이터 보안 강화
3. 용량 절약: 실제 데이터 복사 없이 가상으로 제공
4. 실험용: 테이블 구조 변경 전 테스트 용도

실전 예제

매출 분석 종합 예시

-- 1. 기본 매출 조회 (3개 테이블 JOIN)
SELECT s.id, s.구매날짜, p.상품명, p.가격, u.고객명
FROM sales s
INNER JOIN product p ON s.상품id = p.id
INNER JOIN user_table u ON s.고객번호 = u.id;

-- 2. 날짜별 매출 집계
SELECT 구매날짜, SUM(가격) as 일별매출
FROM sales s
INNER JOIN product p ON s.상품id = p.id
GROUP BY 구매날짜
ORDER BY 구매날짜;

-- 3. 매출에 없는 상품 찾기 (LEFT JOIN 활용)
SELECT p.*
FROM product p
LEFT JOIN sales s ON p.id = s.상품id
WHERE s.상품id IS NULL;

-- 4. 고객별 구매 내역과 총액
SELECT u.고객명, COUNT(*) as 구매횟수, SUM(p.가격) as 총구매액
FROM sales s
INNER JOIN product p ON s.상품id = p.id
INNER JOIN user_table u ON s.고객번호 = u.id
GROUP BY u.id, u.고객명
ORDER BY 총구매액 DESC;

이러한 JOIN과 데이터 조작 기법들을 마스터하면 복잡한 비즈니스 요구사항도 효율적으로 처리할 수 있습니다.

데이터베이스 생성과 삭제

-- 데이터베이스 생성
CREATE DATABASE 데이터베이스이름;

-- 데이터베이스 삭제 (되돌릴 수 없음!)
DROP DATABASE 데이터베이스이름;

테이블 생성

테이블을 만들 때는 컬럼명과 데이터 타입을 지정해야 합니다.

-- 기본 테이블 생성
CREATE TABLE 테이블명 (
    컬럼1이름 datatype,
    컬럼2이름 datatype,
    컬럼3이름 datatype
    -- 주의: 마지막 줄에는 콤마(,) 금지!
);

-- 실제 예시
CREATE TABLE new_table (
    id INT,
    이름 VARCHAR(100),
    나이 INT
);

기본값 설정

CREATE TABLE new_table2 (
    id INT,
    이름 VARCHAR(100) DEFAULT '홍길동',  -- 기본값 설정
    나이 INT
);

• 데이터가 입력되지 않을 때 자동으로 채워질 기본값을 설정할 수 있습니다.

테이블 삭제

DROP TABLE 테이블명;  -- 되돌릴 수 없음!

컬럼 관리 (ALTER TABLE)

컬럼 추가

ALTER TABLE 테이블명
ADD 컬럼명 VARCHAR(100);

-- 기본값과 함께 추가
ALTER TABLE 테이블명
ADD 컬럼명 INT DEFAULT 0;

컬럼 데이터 타입 변경

ALTER TABLE 테이블명
MODIFY COLUMN 컬럼명 datatype;

-- 예시
ALTER TABLE member 
MODIFY COLUMN 나이 BIGINT;

주의사항: 이미 문자 데이터가 있는 컬럼을 숫자 타입으로 변경하는 것은 불가능

컬럼 삭제

ALTER TABLE 테이블명
DROP COLUMN 컬럼명;

제약조건 (Constraints)

1. NOT NULL - 필수 입력 설정

CREATE TABLE new_table (
    id INT NOT NULL,        -- NULL 값 입력 금지
    이름 VARCHAR(100) NOT NULL,
    나이 INT
);

• 해당 컬럼에 데이터를 반드시 입력해야 함
• 빈 값으로 두면 저장이 거부됨

2. UNIQUE - 중복 값 방지

-- 단일 컬럼에 UNIQUE 설정
CREATE TABLE new_table (
    id INT UNIQUE,          -- 모든 값이 달라야 함
    이름 VARCHAR(100),
    나이 INT
);

-- 복수 컬럼 조합으로 UNIQUE 설정
CREATE TABLE new_table (
    id INT,
    이름 VARCHAR(100),
    나이 INT,
    UNIQUE(이름, 나이)      -- 이름+나이 조합이 중복되면 안됨
);

UNIQUE 조합 예시: | id | 이름 | 나이 | |---|---|---| | 1 | aaa | 20 | | 2 | aaa | 21 | ← 허용 (조합이 다름) | 3 | aaa | 20 | ← 거부 (조합이 중복)

3. CHECK - 값의 범위나 조건 제한

CREATE TABLE new_table (
    id INT,
    이름 VARCHAR(100),
    나이 INT CHECK (나이 > 0),      -- 양수만 입력 가능
    성별 VARCHAR(10) CHECK (성별 IN ('남', '여'))  -- 특정 값만 허용
);

4. PRIMARY KEY - 기본 키 설정

CREATE TABLE new_table (
    id INT PRIMARY KEY,     -- 자동으로 NOT NULL, UNIQUE 포함
    이름 VARCHAR(100),
    나이 INT
);

PRIMARY KEY의 역할:

• 각 행을 고유하게 식별하는 역할
• NOT NULL과 UNIQUE 제약이 자동으로 적용
• 테이블당 하나만 설정 가능

5. AUTO_INCREMENT - 자동 증가

-- MySQL 방식
CREATE TABLE new_table (
    id INT AUTO_INCREMENT PRIMARY KEY,  -- 1, 2, 3... 자동 증가
    이름 VARCHAR(100),
    나이 INT
);

-- Oracle/PostgreSQL 표준 방식
CREATE TABLE new_table (
    id NUMBER GENERATED BY DEFAULT ALWAYS AS IDENTITY PRIMARY KEY,
    이름 VARCHAR(100)
);

6. 제약조건 명명과 관리

CREATE TABLE new_table (
    id INT,
    이름 VARCHAR(100),
    나이 INT,
    CONSTRAINT pk_new_table PRIMARY KEY (id),           -- 기본키 제약
    CONSTRAINT chk_age CHECK(나이 > 10),                -- 나이 체크 제약
    CONSTRAINT uk_name UNIQUE(이름)                     -- 이름 유일성 제약
);

기존 테이블에 제약조건 추가:

ALTER TABLE 테이블명 MODIFY 컬럼명 INT NOT NULL;

데이터베이스 정규화 (Normalization)

정규화의 목적

데이터 중복을 줄이고 무결성을 보장하며, 수정/삭제 시 발생할 수 있는 문제를 방지하기 위한 과정입니다.

제1정규형 (1NF) - 원자값 보장

문제 상황

체육센터 수강등록 시스템에서 한 회원이 여러 프로그램을 신청하는 경우:

제1정규화 해결

하나의 셀에는 하나의 값만 저장하도록 분리:

장점:

• 데이터 검색, 수정, 삭제가 용이해짐
• 성능 문제 해결
• 추가 컬럼 확장이 쉬워짐

제2정규형 (2NF) - 부분 종속성 제거

문제 상황

복합 기본키에서 일부 컬럼에만 종속되는 속성이 있는 경우:

문제점: '가격'은 '프로그램'에만 의존하므로, 헬스 가격 변경 시 모든 헬스 수강생 행을 수정해야 함

제2정규화 해결

부분 종속성이 있는 컬럼을 별도 테이블로 분리:

수강등록현황 테이블

프로그램 테이블

부분 종속성 판단 연습

문제 1: 책대여내역 테이블에서 책가격 컬럼

• 복합 기본키: (회원아이디 + 책이름 + 날짜)
• 책가격: '책이름'에만 종속 → 이동 필요

문제 2: 회원등급 컬럼

• 회원등급: '회원아이디'에만 종속 → 이동 필요

문제 3: 반납여부 컬럼

• 반납여부: 복합키 전체에 종속 → 이동 불필요

제3정규형 (3NF) - 이행적 종속성 제거

문제 상황

기본키가 아닌 컬럼에 종속되는 컬럼이 있는 경우

체육센터 프로그램 테이블

문제점: '출신대학'은 '프로그램'(기본키)이 아닌 '강사'에 종속됨

제3정규화 해결

이행적 종속성이 있는 컬럼을 별도 테이블로 분리:

체육센터 프로그램 테이블

강사정보 테이블

Foreign Key (외래키) 관리

Foreign Key의 개념

다른 테이블의 기본키를 참조하는 컬럼으로, 테이블 간의 관계를 명확하게 설정합니다.

개선된 테이블 설계

프로그램 테이블 (Primary Key와 Foreign Key 적용)

강사정보 테이블

Foreign Key 생성 방법

테이블 생성 시 설정

CREATE TABLE program (
    id INT PRIMARY KEY,
    프로그램 VARCHAR(100),
    가격 INT,
    강사id INT REFERENCES teacher(id)  -- Foreign Key 설정
);

-- 또는 CONSTRAINT 사용
CREATE TABLE program (
    id INT PRIMARY KEY,
    프로그램 VARCHAR(100),
    가격 INT,
    강사id INT,
    CONSTRAINT fk_teacher FOREIGN KEY (강사id) REFERENCES teacher(id)
);

기존 테이블에 추가:

ALTER TABLE program ADD 
CONSTRAINT fk_teacher FOREIGN KEY (강사id) REFERENCES teacher(id);

Foreign Key의 장점

1. 참조 무결성 보장: 존재하지 않는 강사ID 입력 방지
2. 삭제 방지: 참조되고 있는 강사 데이터 삭제 차단
3. 관계 시각화: DBeaver 등에서 테이블 관계를 화살표로 표시

정규화 실습 예제

쇼핑몰 구매내역 정규화

원본 테이블

정규화 후

1. 구매내역 테이블 (복합키: 구매자+상품명+수량+날짜)

2. 회원정보 테이블

3. 상품정보 테이블

4. 카테고리정보 테이블 (제3정규화)

이러한 정규화를 통해 데이터 중복을 제거하고, 수정 시 일관성을 보장하며, 데이터베이스의 효율성을 높일 수 있습니다.

서브쿼리란?

SELECT 쿼리 안에 다른 SELECT 쿼리를 넣는 문법으로, 복잡한 조건을 한 번에 처리할 수 있게 해줍니다.

기본 예제: 평균보다 높은 사용금액 조회

-- 1단계: 평균 구하기
SELECT AVG(사용금액) FROM card;  -- 결과: 245000

-- 2단계: 평균보다 높은 값 조회
SELECT * FROM card WHERE 사용금액 > 245000;

-- 서브쿼리로 한번에 처리
SELECT * FROM card WHERE 사용금액 > 
  (SELECT AVG(사용금액) FROM card);

서브쿼리 사용 규칙

1. 괄호 필수: 서브쿼리는 반드시 ( ) 괄호로 감싸야 함
2. 단일 값 반환: 대부분의 경우 하나의 값만 반환해야 함
3. 데이터 위치: 문자나 숫자가 들어갈 곳에만 사용 가능

다양한 위치에서 서브쿼리 사용

WHERE 절에서 사용

-- 평균 사용금액보다 높은 고객 조회
SELECT * FROM card 
WHERE 사용금액 > (SELECT AVG(사용금액) FROM card);

SELECT 절에서 사용

-- 각 고객의 사용금액과 평균 사용금액 함께 출력
SELECT 고객명, 사용금액, (SELECT AVG(사용금액) FROM card) AS 평균금액
FROM card;

-- 평균과의 차이 계산
SELECT 고객명, 사용금액, 
       사용금액 - (SELECT AVG(사용금액) FROM card) AS 평균대비차이
FROM card;

IN 절에서 사용

-- 블랙리스트 테이블 생성 후 해당 고객들의 사용금액 조회
SELECT 사용금액 FROM card 
WHERE 고객명 IN (SELECT 이름 FROM blacklist);

실무 활용 예제

-- 고객등급이 '패밀리'인 사람들의 평균 연체횟수보다 연체횟수가 높은 사람 수
SELECT COUNT(*) FROM card 
WHERE 연체횟수 > (
  SELECT AVG(연체횟수) FROM card WHERE 고객등급 = '패밀리'
);

GROUP BY - 그룹화를 통한 집계

GROUP BY 기본 문법

같은 값을 가진 행들을 그룹으로 묶어서 집계 함수를 적용할 때 사용합니다.

-- 고객등급별로 그룹화
SELECT 고객등급 FROM card GROUP BY 고객등급;

-- 고객등급별 고객 수 계산
SELECT 고객등급, COUNT(고객명) FROM card GROUP BY 고객등급;

-- 고객등급별 평균 사용금액
SELECT 고객등급, AVG(사용금액) FROM card GROUP BY 고객등급;

집계 함수와 GROUP BY 조합

-- 고객등급별 다양한 통계
SELECT 고객등급,
       COUNT(*) AS 고객수,
       AVG(사용금액) AS 평균사용금액,
       MAX(사용금액) AS 최대사용금액,
       MIN(사용금액) AS 최소사용금액,
       SUM(사용금액) AS 총사용금액
FROM card 
GROUP BY 고객등급;

HAVING - GROUP BY 결과 필터링

GROUP BY로 그룹화된 결과를 필터링할 때 사용합니다.

-- 고객 수가 2명 이상인 등급만 조회
SELECT 고객등급, COUNT(*) AS 고객수
FROM card 
GROUP BY 고객등급 
HAVING COUNT(*) >= 2;

-- VIP 등급만 필터링
SELECT 고객등급, COUNT(고객명) FROM card 
GROUP BY 고객등급 
HAVING 고객등급 = 'vip';

WHERE vs HAVING 차이점

• WHERE: 원본 테이블 데이터를 필터링 (GROUP BY 전에 실행)
• HAVING: GROUP BY 결과를 필터링 (GROUP BY 후에 실행)

-- WHERE와 HAVING 함께 사용
SELECT 고객등급, COUNT(고객명) FROM card 
WHERE 연체횟수 = 0           -- 원본 데이터 필터링
GROUP BY 고객등급 
HAVING 고객등급 = 'vip';     -- 그룹화 결과 필터링

SQL 실행 순서

SELECT 고객등급, AVG(사용금액)  -- 5. 최종 결과 선택
FROM card                      -- 1. 테이블 선택
WHERE 연체횟수 = 0            -- 2. 원본 데이터 필터링
GROUP BY 고객등급             -- 3. 그룹화
HAVING AVG(사용금액) > 200000 -- 4. 그룹 결과 필터링
ORDER BY 고객등급;           -- 6. 정렬

조건부 값 처리: IF와 CASE

IF 함수

두 가지 경우만 처리할 때 사용하는 간단한 조건문입니다.

-- 기본 문법
IF(조건식, 조건이_참일때_값, 조건이_거짓일때_값)

-- 사용금액이 20만원 이상이면 '우수', 미만이면 '거지'
SELECT 고객명, 사용금액, 
       IF(사용금액 > 200000, '우수', '거지') AS 등급
FROM card;

-- 연체 여부 확인
SELECT 고객명, 연체횟수,
       IF(연체횟수 = 0, '정상', '연체') AS 상태
FROM card;

CASE 문법

세 가지 이상의 경우를 처리할 때 사용하는 확장된 조건문입니다.

-- 기본 문법
CASE 
  WHEN 조건식1 THEN 값1
  WHEN 조건식2 THEN 값2
  WHEN 조건식3 THEN 값3
  ELSE 기본값
END

-- 사용금액에 따른 등급 분류
SELECT 고객명, 사용금액,
CASE 
  WHEN 사용금액 >= 300000 THEN 'vip'
  WHEN 사용금액 >= 200000 THEN '로열'
  WHEN 사용금액 >= 100000 THEN '준수'
  ELSE '그지'
END AS 신규등급
FROM card;

집계 함수와 CASE 조합

-- 등급별 점수 합계 (vip=3점, 로열=2점, 패밀리=1점)
SELECT SUM(
  CASE
    WHEN 고객등급 = 'vip' THEN 3 
    WHEN 고객등급 = '로열' THEN 2 
    ELSE 1
  END
) AS 총점수
FROM card;

-- 조건별 집계
SELECT 
  SUM(CASE WHEN 사용금액 >= 300000 THEN 1 ELSE 0 END) AS 고액고객수,
  SUM(CASE WHEN 연체횟수 > 0 THEN 1 ELSE 0 END) AS 연체고객수
FROM card;

실전 활용 예제

문제 1: 장부 조작하기

사용금액 30만원 이상은 50% 증액, 미만은 10% 증액하여 총합 계산

SELECT SUM(
  CASE 
    WHEN 사용금액 >= 300000 THEN 사용금액 * 1.5
    ELSE 사용금액 * 1.1
  END
) AS 조작된총합
FROM card;

문제 2: 등급 변동 대상자 찾기

현재 등급과 새로운 등급 기준이 다른 고객들만 조회

SELECT 고객명, 사용금액, 고객등급,
CASE 
  WHEN 사용금액 >= 300000 THEN 'vip'
  WHEN 사용금액 >= 200000 THEN '로열'
  ELSE '패밀리'
END AS 신규등급
FROM card
WHERE 고객등급 != CASE 
  WHEN 사용금액 >= 300000 THEN 'vip'
  WHEN 사용금액 >= 200000 THEN '로열'
  ELSE '패밀리'
END;

문제 3: 연체횟수별 고객 분포

-- 연체횟수별 고객 수 (1명인 경우 제외)
SELECT 연체횟수, COUNT(*) AS 고객수
FROM card 
GROUP BY 연체횟수 
HAVING COUNT(*) > 1
ORDER BY 연체횟수;

문제 4: 등급별 사용금액 격차

-- 등급별 최대/최소 사용금액 비율
SELECT 고객등급, 
       MAX(사용금액) AS 최대금액,
       MIN(사용금액) AS 최소금액,
       ROUND(MAX(사용금액) / MIN(사용금액), 2) AS 격차비율
FROM card 
GROUP BY 고객등급 
ORDER BY 고객등급;

고급 활용 팁

서브쿼리 최적화

-- 비효율적: 매번 서브쿼리 실행
SELECT *, (SELECT AVG(사용금액) FROM card) FROM card;

-- 효율적: 변수나 임시 테이블 활용 고려
-- (실제로는 대부분의 DBMS가 자동 최적화)

GROUP BY와 ORDER BY 조합

-- 등급별 평균 사용금액을 높은 순으로 정렬
SELECT 고객등급, AVG(사용금액) AS 평균사용금액
FROM card 
GROUP BY 고객등급 
ORDER BY 평균사용금액 DESC;

복잡한 조건의 CASE 문

-- 여러 컬럼을 고려한 등급 산정
SELECT 고객명,
CASE 
  WHEN 사용금액 >= 300000 AND 연체횟수 = 0 THEN 'VIP'
  WHEN 사용금액 >= 200000 AND 연체횟수 <= 1 THEN '우수'
  WHEN 연체횟수 > 3 THEN '주의'
  ELSE '일반'
END AS 종합등급
FROM card;

이러한 기능들을 조합하면 복잡한 비즈니스 로직을 SQL로 구현할 수 있으며, 데이터 분석과 보고서 작성에 매우 유용합니다.

기본 LIKE 문법

특정 단어가 포함된 데이터를 검색할 때 사용하는 문법입니다.

-- 정확히 일치하는 경우
SELECT * FROM product WHERE 상품명 LIKE '소파';

-- 패턴 검색 (% 와일드카드 사용)
SELECT * FROM product WHERE 상품명 LIKE '%소파%';

와일드카드 종류

% (퍼센트) - 0개 이상의 아무 문자

-- '소파'가 포함된 모든 상품
SELECT * FROM product WHERE 상품명 LIKE '%소파%';

-- '소파'로 시작하는 상품
SELECT * FROM product WHERE 상품명 LIKE '소파%';

-- '소파'로 끝나는 상품  
SELECT * FROM product WHERE 상품명 LIKE '%소파';

_ (언더스코어) - 정확히 1개의 아무 문자

-- '아무글자 2개 + 소파'와 일치하는 상품
SELECT * FROM product WHERE 상품명 LIKE '__소파';

LIKE 사용 시 주의사항

• 성능 저하: % 기호를 많이 사용하면 인덱스 활용이 어려워 속도가 느려질 수 있음
• CHAR 타입: 고정 길이로 공백이 자동 추가되어 예상과 다른 결과가 나올 수 있음
• 가능하면 =, >, < 등의 연산자 우선 사용 권장

복합 조건 검색

-- '소파' 또는 'chair'가 포함된 상품
SELECT * FROM product 
WHERE 상품명 LIKE '%소파%' OR 상품명 LIKE '%chair%';

-- '소파'는 포함하지만 '나무'는 포함하지 않는 상품
SELECT * FROM product 
WHERE 상품명 LIKE '%소파%' AND NOT 상품명 LIKE '%나무%';

-- 'Green'으로 시작해서 'chair'로 끝나는 상품
SELECT * FROM product WHERE 상품명 LIKE 'Green%chair';

집계 함수 (Aggregate Functions)

기본 집계 함수

숫자 데이터의 통계를 계산할 때 사용하는 함수들입니다.

-- 최댓값
SELECT MAX(사용금액) FROM card;

-- 최솟값  
SELECT MIN(사용금액) FROM card;

-- 평균값
SELECT AVG(연체횟수) FROM card;

-- 합계
SELECT SUM(사용금액) FROM card;

-- 개수 (행의 수)
SELECT COUNT(사용금액) FROM card;
SELECT COUNT(*) FROM card;  -- 같은 결과

AS를 이용한 컬럼명 변경

-- 컬럼명을 더 읽기 쉽게 변경
SELECT MAX(사용금액) AS 최대사용금액 FROM card;

-- 여러 집계 함수 동시 사용
SELECT MAX(결제횟수), MIN(결제횟수) FROM card;

조건부 집계

특정 조건을 만족하는 데이터만으로 통계를 계산할 수 있습니다.

-- VIP 고객의 평균 사용금액
SELECT AVG(사용금액) FROM card WHERE 고객등급 = 'vip';

-- VIP 고객의 평균 결제횟수와 사용금액 총합
SELECT AVG(결제횟수), SUM(사용금액) 
FROM card WHERE 고객등급 = 'vip';

-- 연체횟수 1회 이하인 고객 수
SELECT COUNT(연체횟수) FROM card WHERE 연체횟수 <= 1;

DISTINCT와 집계 함수

중복을 제거한 후 집계를 수행할 수 있습니다.

-- 중복 제거 후 출력
SELECT DISTINCT 연체횟수 FROM card;

-- 중복 제거 후 평균 계산
SELECT AVG(DISTINCT 연체횟수) FROM card;

LIMIT을 이용한 대안

큰 데이터셋에서 MAX/MIN 대신 정렬과 LIMIT을 사용할 수 있습니다.

-- MAX() 대신 정렬 + LIMIT 사용
SELECT * FROM card ORDER BY 사용금액 DESC LIMIT 1;

-- MIN() 대신 정렬 + LIMIT 사용  
SELECT * FROM card ORDER BY 사용금액 ASC LIMIT 1;

사칙연산과 컬럼 계산

숫자 컬럼의 사칙연산

컬럼 값에 직접 연산을 적용할 수 있습니다.

-- 부가세 제외한 사용금액 (10% 할인)
SELECT 사용금액 * 0.9 FROM card;

-- 컬럼명 변경과 함께 사용
SELECT 사용금액 * 0.9 AS 부가세제외, 연체횟수 + 100 FROM card;

사용 가능한 연산자

• + : 덧셈
• - : 뺄셈
• * : 곱셈
• / : 나눗셈

컬럼 간 연산

서로 다른 컬럼 값들을 연산할 수 있습니다.

-- 결제당 평균 사용금액 계산
SELECT 사용금액 / 결제횟수 FROM card;

-- 여러 컬럼 조합 연산
SELECT 사용금액, 결제횟수, 사용금액 / 결제횟수 AS 평균결제금액 FROM card;

문자열 처리 함수

CONCAT - 문자열 합치기

여러 문자열을 연결하여 하나로 만드는 함수입니다.

-- 고객명과 등급 합치기
SELECT CONCAT(고객명, 고객등급) FROM card;

-- 중간에 텍스트 추가
SELECT CONCAT(고객명, ' is ', 고객등급) FROM card;

-- 숫자도 문자로 변환하여 합치기
SELECT CONCAT(고객명, ' used ', 사용금액) FROM card;

DBMS별 차이점

-- MySQL/MariaDB
SELECT CONCAT(고객명, ' is ', 고객등급) FROM card;

-- PostgreSQL/Oracle  
SELECT 고객명 || ' is ' || 고객등급 FROM card;

문자열 조작 함수들

TRIM - 공백 제거

-- 좌우 공백 제거
SELECT TRIM(컬럼명) FROM 테이블명;

REPLACE - 문자 교체

-- '서울'을 '경기'로 모두 교체
SELECT REPLACE('서울에사는 서울맨', '서울', '경기');

-- 모든 공백 제거
SELECT REPLACE(컬럼명, ' ', '') FROM 테이블명;

SUBSTR - 문자 추출

-- 3번째부터 2글자 추출
SELECT SUBSTR('abcdef', 3, 2);  -- 결과: 'cd'

-- 휴대폰 번호 뒷자리 4글자
SELECT SUBSTR(번호, 10, 4) FROM 테이블명;

RIGHT/LEFT - 좌우에서 문자 추출

-- 오른쪽에서 4글자 추출
SELECT RIGHT(번호, 4) FROM 테이블명;

INSERT - 문자 일부 교체

-- 1번째부터 4글자를 'hello'로 교체
SELECT INSERT('test@naver.com', 1, 4, 'hello');  -- 결과: 'hello@naver.com'

수학 함수

최댓값/최솟값 비교

-- 여러 값 중 최댓값
SELECT GREATEST(5, 3, 2, 1, 4);  -- 결과: 5

-- 여러 값 중 최솟값  
SELECT LEAST(5, 3, 2, 1, 4);     -- 결과: 1

소수점 처리

-- 내림 (소수점 버림)
SELECT FLOOR(10.1);  -- 결과: 10
SELECT FLOOR(10.9);  -- 결과: 10

-- 올림
SELECT CEIL(10.1);   -- 결과: 11
SELECT CEIL(10.9);   -- 결과: 11

-- 반올림 (지정 자릿수까지)
SELECT ROUND(10.777, 2);    -- 결과: 10.78

-- 내림 (지정 자릿수까지)  
SELECT TRUNCATE(10.777, 2); -- 결과: 10.77

기타 수학 함수

-- 거듭제곱
SELECT POWER(4, 2);  -- 결과: 16 (4의 2승)

-- 절댓값
SELECT ABS(-100);    -- 결과: 100

실전 활용 예제

복합 쿼리 예제

-- VIP 고객의 할인된 평균 사용금액
SELECT AVG(사용금액 * 0.9) AS VIP할인평균금액 
FROM card 
WHERE 고객등급 = 'vip';

-- 고객 정보를 보기 좋게 포맷팅
SELECT CONCAT(고객명, ' (', 고객등급, ') - ', 사용금액, '원') AS 고객정보
FROM card;

-- 사용금액이 높은 상위 5명
SELECT * FROM card 
ORDER BY 사용금액 DESC 
LIMIT 5;

데이터 정제 예제

-- 연체 없는 고객들의 통계
SELECT 
    COUNT(*) AS 고객수,
    AVG(사용금액) AS 평균사용금액,
    SUM(사용금액) AS 총사용금액
FROM card 
WHERE 연체횟수 = 0;

-- 전화번호 마스킹 처리
SELECT 
    고객명,
    CONCAT(SUBSTR(번호, 1, 3), '-****-', RIGHT(번호, 4)) AS 마스킹번호
FROM card;

함수 사용 시 팁

1. 성능 고려: 함수 사용 시 인덱스 활용이 어려울 수 있으므로 대용량 데이터에서는 주의
2. DBMS별 차이: MySQL, PostgreSQL, Oracle 등에서 함수명이나 문법이 다를 수 있음
3. 실무 활용: 모든 함수를 외우지 말고 필요할 때 검색하여 사용하는 것이 효율적
4. 데이터 검증: 함수 적용 전후 결과를 반드시 확인하여 의도한 대로 작동하는지 검증

macOS 설치

방법 1: 설치 프로그램 사용 (권장)

1. https://dev.mysql.com/downloads/mysql/ 접속
2. MySQL Server Community Edition macOS 버전 다운로드
   • M1 이상 프로세서: ARM 버전 선택
   • Intel 프로세서: x86 버전 선택
3. 설치 과정에서 MySQL root 계정 비밀번호 설정 (반드시 기억!)

방법 2: Homebrew 사용

brew install mysql

환경 변수 설정 (macOS)

1. 터미널 종류 확인 후 설정 파일 열기

# zsh 사용 시
open ~/.zshrc

# bash 사용 시  
open ~/.bash_profile

2. PATH 추가

export PATH="$PATH:/usr/local/mysql/bin/"

• MySQL 설치 경로가 다를 경우 해당 경로로 수정

3. 터미널 재시작 후 MySQL 접속

mysql -u root -p

• root 계정 비밀번호 입력하여 MySQL 서버 실행

DBeaver 설치 및 연결

DBeaver 설치

1. 구글에서 "DBeaver" 검색하여 공식 사이트 접속
2. 운영체제에 맞는 버전 다운로드
   • M1 Mac: Apple Silicon 버전
   • Intel Mac/Windows: 해당 버전

MySQL 연결 설정

1. DBeaver 실행 후 "새 데이터베이스 연결" 클릭
2. MySQL 선택
3. 연결 정보 입력:
   • Host: localhost (로컬 설치 시)
   • Username: root
   • Password: MySQL 설치 시 설정한 비밀번호
4. "연결 테스트" 후 연결 완료

자주 발생하는 문제 해결

Windows 환경

MySQL Workbench Local Instance 시작 실패

1. 윈도우 검색 → "환경 변수 편집"
2. Path 변수에 C:\Windows\System32 추가

DBeaver MySQL 연결 실패

1. 윈도우 검색 → "서비스"
2. MYSQL80 서비스 찾아서 우클릭 → 시작
3. MySQL Workbench에서도 서버 실행 상태 확인

macOS 환경

# 터미널에서 MySQL 서버 실행 여부 확인
mysql -u root -p

Database와 Table 생성

Database 생성

-- DBeaver에서 Databases 우클릭 → Create New Database
-- 또는 SQL로 생성
CREATE DATABASE mart;

Table 생성과 Column 설정

-- product 테이블 생성 예시
CREATE TABLE product (
    번호 INT,
    상품명 VARCHAR(100),
    카테고리 VARCHAR(50),
    가격 INT
);

Column 설정 시 고려사항

• Data Type: 저장할 데이터의 종류에 맞게 선택
• 용량: 예상되는 최대 크기보다 여유있게 설정
• 제약조건: NULL 허용 여부, 기본값 등

MySQL Data Types

문자형 데이터

사용 팁

• 일반적인 문자 저장: VARCHAR 사용
• 긴 글 저장: MEDIUMTEXT 사용
• VARCHAR(300) 설정 후 10자만 저장해도 10자+1byte만 차지

숫자형 데이터

사용 팁

• 일반적인 정수: INT 사용
• 양수만 저장: UNSIGNED 옵션 추가 (범위가 2배로 확장)
• 정확한 소수점 계산: DECIMAL 사용 (금융 데이터 등)

날짜/시간형 데이터

사용 팁

• 일반적인 날짜/시간 저장: DATETIME 사용
• 현재 시간 자동 기록: TIMESTAMP 간혹 사용

기본 SQL 문법

SELECT 문법 (데이터 조회)

기본 조회

-- 모든 컬럼 조회
SELECT * FROM 테이블명;

-- 특정 컬럼만 조회
SELECT 컬럼명 FROM 테이블명;

-- 여러 컬럼 조회
SELECT 컬럼명1, 컬럼명2 FROM 테이블명;

-- 다른 데이터베이스의 테이블 조회
SELECT * FROM 데이터베이스명.테이블명;

ORDER BY (정렬)

기본 정렬

-- 오름차순 정렬 (ASC는 생략 가능)
SELECT * FROM product ORDER BY 가격 ASC;

-- 내림차순 정렬
SELECT * FROM product ORDER BY 가격 DESC;

-- 여러 컬럼 기준 정렬
SELECT * FROM product ORDER BY 카테고리 ASC, 가격 DESC;

-- 컬럼 번호로 정렬 (3번째 컬럼 기준)
SELECT * FROM product ORDER BY 3 DESC;

정렬 순서

• ASC (오름차순): A→Z, 1→9
• DESC (내림차순): Z→A, 9→1

WHERE (조건 필터링)

기본 조건

-- 문자 조건 (따옴표 필수)
SELECT * FROM product WHERE 카테고리 = '가구';

-- 숫자 조건 (따옴표 불필요)
SELECT * FROM product WHERE 가격 > 50000;

-- 범위 조건
SELECT * FROM product WHERE 가격 BETWEEN 5000 AND 8000;

비교 연산자

• = : 같음
• != : 같지 않음
• >, < : 크다, 작다
• >=, <= : 크거나 같다, 작거나 같다

복합 조건 (AND, OR, NOT)

AND 조건 (모든 조건 만족)

SELECT * FROM product 
WHERE 카테고리 = '가구' AND 가격 = 5000;

OR 조건 (하나 이상 조건 만족)

SELECT * FROM product 
WHERE 카테고리 = '가구' OR 가격 = 5000;

NOT 조건 (조건 제외)

SELECT * FROM product 
WHERE NOT 카테고리 = '가구';

괄호를 이용한 조건 그룹화

SELECT * FROM product 
WHERE (카테고리 = '가구' OR 카테고리 = '옷') AND 가격 = 5000;

IN 문법 (여러 값 중 일치)

OR 조건을 IN으로 간단히 표현

-- 기존 방식 (OR 여러 개)
SELECT * FROM product 
WHERE 카테고리 = '신발' OR 카테고리 = '가전' OR 카테고리 = '식품';

-- IN 사용 (더 간단)
SELECT * FROM product 
WHERE 카테고리 IN ('신발', '가전', '식품');

-- NOT IN (제외)
SELECT * FROM product 
WHERE 상품명 NOT IN ('셔츠', '반팔티', '운동화');

IN 사용 조건

• 같은 컬럼에서 여러 값 중 하나와 일치하는 경우
• 다른 컬럼 간의 OR 조건에는 사용 불가

실습 예제

기본 조회 실습

-- 1. 재고가 20 이하인 상품을 상품명 가나다 순으로 조회
SELECT * FROM product 
WHERE 재고 <= 20 
ORDER BY 상품명;

-- 2. 가격이 3000원 미만이거나 6000원 초과인 상품 조회
SELECT * FROM product 
WHERE 가격 < 3000 OR 가격 > 6000;

-- 3. 카테고리가 '옷'이 아니면서 가격이 5000원인 상품 조회
SELECT * FROM product 
WHERE 카테고리 != '옷' AND 가격 = 5000;

CSV 파일 불러오기

1. DBeaver에서 테이블 우클릭 → "데이터 가져오기"
2. "CSV에서 가져오기" 선택
3. 한글 데이터의 경우 인코딩을 EUC-KR로 설정
4. 파일명과 동일한 테이블 생성하여 데이터 입력

주요 문법 정리

• SELECT FROM: 데이터 조회의 기본 ("셀프"로 기억)
• ORDER BY: 정렬 (ASC/DESC)
• WHERE: 조건 필터링
• AND/OR/NOT: 복합 조건
• IN: 여러 값 중 일치 조건
• BETWEEN: 범위 조건

이러한 기본 문법들을 조합하면 복잡한 데이터 조회와 분석이 가능합니다.

기본 흐름

1. 사용자가 메시지 작성 후 전송
2. 서버가 메시지를 받아서 같은 채팅방의 다른 사용자들에게 전달
3. 모든 사용자가 실시간으로 메시지 확인

Room 개념 활용

• 전체 사용자가 아닌 특정 채팅방(Room) 사용자들에게만 메시지 전송
• 채팅방별로 독립적인 대화 공간 구성

채팅 기능 구현 단계

1. 채팅방 입장 시 Room 조인

클라이언트에서 서버에 Room 입장 요청

<!-- chatDetail.ejs -->
<script>
  const socket = io()
  socket.emit('ask-join', '<%= result._id %>')
</script>

• 채팅방 상세페이지 접속 시 자동으로 해당 채팅방 Room에 입장 요청
• 채팅방의 고유 ID(_id)를 Room 이름으로 사용

서버에서 Room 조인 처리

// server.js
socket.on('ask-join', async (data) => {
  socket.join(data)
})

• 클라이언트 요청을 받아 해당 Room에 사용자 추가
• 이제 같은 Room의 사용자들끼리만 메시지 송수신 가능

보안 강화 (선택사항)

socket.on('ask-join', async (data) => {
  // 현재 로그인된 사용자 정보 확인
  let currentUser = socket.request.session.passport.user.id

  // DB에서 해당 채팅방에 권한이 있는지 확인
  let chatRoom = await db.collection('chatroom').findOne({
    _id: new ObjectId(data),
    member: new ObjectId(currentUser)
  })

  if (chatRoom) {
    socket.join(data)
  }
})

2. 메시지 전송 기능

클라이언트에서 메시지 전송

<script>
  document.querySelector('.chat-button').addEventListener('click', function () {
    let 작성한거 = document.querySelector('.chat-input').value
    socket.emit('message-send', { 
      room: '<%= result._id %>', 
      msg: 작성한거 
    })
  })
</script>

• 전송 버튼 클릭 시 메시지 내용과 채팅방 ID를 함께 서버로 전송
• Object 형태로 여러 데이터를 한번에 전달

서버에서 메시지 분배

// server.js
socket.on('message-send', async (data) => {
  console.log('유저가 보낸거 : ', data) // { room: ~~, msg: ~~~ }
  io.to(data.room).emit('message-broadcast', data.msg)
})

• io.to(room이름): 특정 Room의 모든 사용자에게 메시지 전송
• 메시지를 보낸 사용자를 포함한 모든 Room 멤버가 수신

3. 메시지 수신 및 화면 표시

클라이언트에서 메시지 수신 처리

<!-- chatDetail.ejs -->
<script>
  socket.on('message-broadcast', (data) => {
    document.querySelector('.chat-screen')
      .insertAdjacentHTML('beforeend', `<div class="chat-box"><span>${data}</span></div>`)
  })
</script>

• insertAdjacentHTML(): 기존 HTML에 새로운 요소 추가
• beforeend: 지정된 요소의 마지막 자식으로 추가
• 실시간으로 채팅 화면에 새 메시지가 표시됨

채팅 내용 영구 저장

문제점: 새로고침 시 채팅 내용이 모두 사라짐 해결책: 채팅 메시지를 DB에 저장하고 페이지 로드 시 불러오기

메시지 DB 저장

socket.on('message-send', async (data) => {
  // DB에 채팅 메시지 저장
  await db.collection('chatMessage').insertOne({
    parentRoom: new ObjectId(data.room),
    content: data.msg,
    who: new ObjectId(socket.request.session.passport.user.id),
    timestamp: new Date()
  })

  // 실시간으로 다른 사용자들에게 전송
  io.to(data.room).emit('message-broadcast', data.msg)
})

페이지 로드 시 기존 채팅 불러오기

app.get('/chat/detail/:id', async (요청, 응답) => {
  let chatRoom = await db.collection('chatroom').findOne({
    _id: new ObjectId(요청.params.id)
  })

  let messages = await db.collection('chatMessage').find({
    parentRoom: new ObjectId(요청.params.id)
  }).toArray()

  응답.render('chatDetail.ejs', {
    result: chatRoom,
    messages: messages
  })
})

Socket.io 고급 설정

DB Adapter 사용

• 웹소켓 연결 정보가 메모리에만 저장되어 서버 재시작 시 모든 연결이 끊어짐
• MongoDB Adapter를 사용하면 연결 정보를 DB에 안전하게 저장

// MongoDB Adapter 설정 예시
const { MongoStore } = require('@socket.io/mongo-adapter');

io.adapter(new MongoStore({
  uri: 'mongodb://localhost:27017/myapp'
}));

Server Sent Events (SSE) 실시간 업데이트

SSE 기본 개념

• 기존 HTTP: 1회 요청 → 1회 응답 → 연결 종료
• SSE: 연결을 유지하며 서버에서 클라이언트로 지속적인 데이터 전송

SSE 서버 설정

app.get('/stream/list', (요청, 응답) => {
  응답.writeHead(200, {
    "Connection": "keep-alive",
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
  });

  응답.write('event: msg\n');
  응답.write('data: 바보\n\n');
});

주요 헤더 설명

• Connection: keep-alive: 연결 지속 유지
• Content-Type: text/event-stream: SSE 형식임을 명시
• Cache-Control: no-cache: 캐싱 방지

클라이언트 SSE 연결

<script>
  let eventSource = new EventSource('/stream/list')
  eventSource.addEventListener('msg', function (e){
    console.log(e.data);
  });
</script>

MongoDB Change Stream 활용

Change Stream 기본 설정

let 찾을문서 = [
  { $match: { operationType: 'insert' } }
]

const changeStream = db.collection('post').watch(찾을문서)

changeStream.on('change', (result) => {
  console.log(result)
  console.log('새 글:', result.fullDocument)
});

주요 기능

• operationType: insert, update, delete 등 작업 유형 필터링
• result.fullDocument: 변경된 문서의 전체 내용
• 실시간으로 DB 변화 감지 및 처리

실시간 게시물 업데이트

app.get('/stream/post', (요청, 응답) => {
  응답.writeHead(200, {
    "Connection": "keep-alive",
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
  })

  const 찾을문서 = [
    { $match: { operationType: 'insert' } }
  ]

  let changeStream = db.collection('post').watch(찾을문서)
  changeStream.on('change', (result) => {
    응답.write('event: msg\n')
    응답.write(`data: ${JSON.stringify(result.fullDocument)}\n\n`)
  })
});

클라이언트에서 실시간 업데이트 처리

<script>
  let eventSource = new EventSource('/stream/post')
  eventSource.addEventListener('msg', function (e){
    let 가져온거 = JSON.parse(e.data)
    document.querySelector('.white-bg')
      .insertAdjacentHTML('afterbegin', 
        `<div class="list-box"><h4>${가져온거.title}</h4></div>`
      )
  })
</script>

성능 최적화

let changeStream

connectDB.then((client) => {
  db = client.db('forum')

  // Change Stream을 한 번만 생성하여 성능 향상
  changeStream = db.collection('post').watch([
    { $match: { operationType: 'insert' } }
  ])

  server.listen(process.env.PORT, () => {
    console.log('서버 실행중')
  })
})

고급 채팅 기능 구현

추가 구현 아이디어

1. 채팅 메시지 DB 저장 및 불러오기

• 메시지를 chatMessage 컬렉션에 저장
• 채팅방 입장 시 기존 메시지 불러와서 표시

2. 발신자별 메시지 스타일 구분

// 내가 보낸 메시지 우측 정렬
if (message.who === currentUserId) {
  messageHTML = `<div class="chat-box mine"><span>${message.content}</span></div>`
} else {
  messageHTML = `<div class="chat-box"><span>${message.content}</span></div>`
}

3. 채팅방 접근 권한 검증

• 로그인하지 않은 사용자 접근 차단
• 채팅방 멤버가 아닌 사용자 접근 차단
• Socket 연결 시와 페이지 접속 시 모두 검증

4. 실시간 타이핑 표시

// 타이핑 중임을 다른 사용자에게 알림
socket.emit('typing', { room: roomId, user: username })
socket.broadcast.to(roomId).emit('user-typing', username)

이러한 기능들을 통해 완전한 실시간 채팅 시스템을 구축할 수 있습니다.

Node.js 서버 생성

const express = require('express');
const path = require('path');
const app = express();

app.listen(8080, function () {
  console.log('listening on 8080')
});

설치 과정

1. Node.js 설치
2. 작업폴더 생성 후 에디터로 오픈
3. server.js 파일 생성
4. 터미널에서 npm init -y 입력
5. npm install express 입력
6. nodemon server.js 또는 node server.js로 서버 실행

React의 역할과 특징

React가 필요한 이유

• SPA(Single Page Application): 새로고침 없이 페이지 전환이 가능한 앱처럼 부드러운 웹사이트 제작
• 기존 방식: 페이지 이동마다 전체 페이지를 새로 불러옴
• React 방식: JavaScript로 페이지 내용만 교체하여 부드러운 사용자 경험 제공

React 프로젝트 생성

npx create-react-app 프로젝트명
cd 프로젝트명
npm run start  # 개발 서버 실행
npm run build  # 배포용 파일 생성

React와 Node.js 서버 연동

폴더 구조 예시

프로젝트 폴더/
├── server.js
└── react-project/
    └── build/
        ├── index.html
        ├── static/
        └── ...

서버에서 React 파일 제공

// server.js
app.use(express.static(path.join(__dirname, 'react-project/build')));

app.get('/', function (요청, 응답) {
  응답.sendFile(path.join(__dirname, '/react-project/build/index.html'));
});

정적 파일 제공 설정

• express.static(): CSS, JS, 이미지 등 정적 파일들을 자동으로 제공
• React 빌드 폴더의 모든 파일에 접근 가능하게 만드는 설정

라우팅 처리

React 라우터 사용 시 주의사항

• 브라우저 URL 직접 입력 시 서버로 요청이 전달됨
• React 라우터가 처리하지 못하는 상황 발생

React 라우팅 전권 위임

// 모든 경로를 React가 처리하도록 설정 (가장 하단에 배치)
app.get('*', function (요청, 응답) {
  응답.sendFile(path.join(__dirname, '/react-project/build/index.html'));
});

데이터 통신 방식

Server-side Rendering vs Client-side Rendering

Server-side Rendering

1. 서버에서 DB 데이터 조회
2. HTML에 데이터 삽입
3. 완성된 HTML을 클라이언트에 전송

Client-side Rendering (React 방식)

1. React에서 서버에 AJAX 요청으로 데이터 요청
2. 서버가 JSON 형태로 데이터만 전송
3. React가 받은 데이터로 동적으로 HTML 생성

React-서버 통신 설정

// server.js 상단에 추가
app.use(express.json());
var cors = require('cors');
app.use(cors());

설치 필요

npm install cors

• express.json(): 클라이언트가 보낸 JSON 데이터 파싱
• cors: 다른 도메인 간의 AJAX 요청 허용

개발 환경과 배포

개발 시 권장 방식

• React: npm run start로 별도 서버 실행
• Node.js: nodemon server.js로 별도 서버 실행
• 각각 다른 포트에서 동시 실행

React에서 서버 통신

// 전체 URL 명시
fetch('http://localhost:8080/api/data')

// 또는 package.json에 proxy 설정
"proxy": "http://localhost:8080"

배포 시

• npm run build로 최종 빌드 파일 생성
• 빌드된 파일을 서버에서 정적 파일로 제공

서브디렉토리 배포

여러 앱을 다른 경로에서 제공

// server.js
app.use('/', express.static(path.join(__dirname, 'public')))
app.use('/react', express.static(path.join(__dirname, 'react-project/build')))

app.get('/', function(요청, 응답){
  응답.sendFile(path.join(__dirname, 'public/main.html'))
}) 

app.get('/react', function(요청, 응답){
  응답.sendFile(path.join(__dirname, 'react-project/build/index.html'))
})

React 프로젝트 설정

// react-project/package.json
{
  "homepage": "/react",
  "version": "0.1.0"
}

회원 기능이 포함된 게시판 구현

글 발행 시 작성자 정보 저장

app.post('/add', upload.single('img1'), async (요청, 응답) => {
  await db.collection('post').insertOne({
    title: 요청.body.title,
    content: 요청.body.content,
    user: 요청.user._id,           // 현재 로그인 유저 ID
    username: 요청.user.username   // 현재 로그인 유저명
  })
})

비정규화 vs 정규화

정규화 방식 (관계형 DB)

• 사용자 정보는 별도 테이블에 저장
• 게시글에는 사용자 ID만 저장
• 필요시 JOIN으로 데이터 결합
• 장점: 데이터 정확성, 단점: 조회 속도 느림

비정규화 방식 (MongoDB 권장)

• 게시글에 사용자명도 함께 저장
• 데이터 중복 허용
• 장점: 조회 속도 빠름, 단점: 데이터 불일치 가능성

권한 기반 기능 구현

본인 글만 삭제 가능

app.delete('/delete', async (요청, 응답) => {
  await db.collection('post').deleteOne({
    _id: new ObjectId(요청.query.docid),
    user: 요청.user._id  // 현재 로그인 유저와 작성자가 일치하는 경우만
  })
  응답.send('삭제완료')
})

추가 구현 아이디어

1. 본인 글만 수정 가능: 삭제와 동일한 방식으로 조건 추가
2. 본인 글에만 삭제 버튼 표시: EJS에서 조건문으로 버튼 노출 제어
3. 삭제 성공 시에만 UI 업데이트: AJAX 응답 처리로 성공 여부 확인

댓글 시스템 설계

데이터 저장 방식 비교

방식 1: 게시글 내 배열로 저장

{
  title: '게시글 제목',
  content: '게시글 내용',
  comments: ['댓글1', '댓글2', '댓글3']
}

• 단점: 댓글 개별 수정/삭제 어려움, 16MB 용량 제한, 부분 조회 불가

방식 2: 별도 컬렉션으로 관리

// comment 컬렉션
{
  content: '댓글 내용',
  writerId: ObjectId('작성자ID'),
  writer: '작성자명',
  parentId: ObjectId('부모게시글ID')
}

• 장점: 개별 수정/삭제 용이, 용량 제한 없음, 필요한 댓글만 조회 가능

댓글 기능 구현

1. 댓글 UI 생성

<!-- detail.ejs -->
<div class="detail-bg">
  <h4><%= result.title %></h4>
  <p><%= result.content %></p>
  <hr style="margin-top: 60px">

  <!-- 댓글 목록 -->
  <% for (let i = 0; i < result2.length; i++) { %>
    <p><strong><%= result2[i].writer %></strong> <%= result2[i].content %></p>
  <% } %>

  <!-- 댓글 작성 폼 -->
  <form action="/comment" method="POST">
    <input name="content" placeholder="댓글을 입력하세요">
    <input name="parentId" value="<%= result._id %>" style="display: none">
    <button type="submit">댓글작성</button>
  </form>
</div>

2. 댓글 저장 API

app.post('/comment', async (요청, 응답) => {
  let result = await db.collection('comment').insertOne({
    content: 요청.body.content,
    writerId: new ObjectId(요청.user._id),
    writer: 요청.user.username,
    parentId: new ObjectId(요청.body.parentId)
  })

  응답.redirect('back')  // 이전 페이지로 이동
})

3. 댓글과 함께 상세페이지 표시

app.get('/detail/:id', async (요청, 응답) => {
  let result = await db.collection('post').findOne({
    _id: new ObjectId(요청.params.id)
  })
  let result2 = await db.collection('comment').find({
    parentId: new ObjectId(요청.params.id)
  }).toArray()

  응답.render('detail.ejs', {result: result, result2: result2})
})

고급 기능 추가

• AJAX 댓글: 새로고침 없이 댓글 추가
• 실시간 업데이트: WebSocket을 활용한 실시간 댓글 반영
• 댓글 페이지네이션: 댓글이 많을 때 페이지 단위로 로딩

기본 흐름

1. 검색 UI 생성 → 사용자가 검색어 입력
2. 서버에서 DB 검색 → 검색어가 포함된 게시물 조회
3. 결과를 EJS로 전송 → 검색 결과 페이지 표시

1. 검색 UI 만들기

HTML 구조

<!-- list.ejs -->
<input class="search">
<button class="search-send">검색</button>

CSS 스타일링

.search {
  margin-left: 20px;
  padding: 5px;
}
.search-send {
  padding: 6px 10px;
  background: lightgray;
  border: none;
  border-radius: 5px;
  vertical-align: middle;
}

JavaScript로 검색 요청

<!-- list.ejs 하단 -->
<script>
  document.querySelector('.search-send').addEventListener('click', function(){
    let 입력한거 = document.querySelector('.search').value
    location.href = '/search?val=' + 입력한거
  })
</script>

• location.href: 페이지 이동과 동시에 GET 요청 전송
• Query String: URL에 검색어를 파라미터로 전달

2. 서버에서 검색 처리

기본 검색 (정확히 일치하는 제목)

app.get('/search', async (요청, 응답) => {
  let result = await db.collection('post').find({title: 요청.query.val}).toArray()
  응답.render('search.ejs', { 글목록: result })
})

정규식을 활용한 부분 검색

app.get('/search', async (요청, 응답) => {
  let result = await db.collection('post').find({
    title: { $regex: 요청.query.val }
  }).toArray()
  응답.render('search.ejs', { 글목록: result })
})

• $regex 연산자: 특정 문자를 포함하는 모든 결과 검색
• 단점: 모든 문서를 하나씩 검사하므로 속도가 느림

Database 검색 최적화

일반적인 검색 방식의 문제점

• DB가 모든 문서를 하나씩 검사
• 문서가 많을수록 검색 속도 급격히 저하
• 1억 개 문서가 있으면 1억 개 모두 확인

Index의 필요성

• Binary Search: 정렬된 데이터에서 반씩 나누어 검색
• Index: 정렬된 컬렉션 복사본으로 빠른 검색 지원

Index 만들기와 활용

MongoDB에서 Index 생성

1. Collection → Indexes → Create Index
2. 필드명과 데이터 타입 설정
   • 문자: "title": "text"
   • 숫자: "title": 1

Text Index 활용한 검색

db.collection().find({
  $text: { $search: '안녕' }
}).toArray()

성능 확인

// 성능 비교
db.collection().find({title: '안녕'}).explain('executionStats')
db.collection().find({$text: {$search: '안녕'}}).explain('executionStats')

• COLLSCAN: 전체 컬렉션 스캔 (느림)
• Index 사용: 특정 문서만 검사 (빠름)

Index의 단점

1. 용량 증가: 컬렉션을 복사하여 저장하므로 용량 2배
2. 수정 시 부담: 문서 추가/수정/삭제 시 Index도 함께 수정
3. 정확한 단어만 검색: 한국어 조사나 어미 변화 검색 불가

Search Index (Full Text Search)

동작 원리

1. 전처리: 불용어, 조사 제거 (은/는/이/가/을/를 등)
2. 단어 추출 및 정렬: 의미있는 단어들만 정렬하여 저장
3. 문서 위치 기록: 각 단어가 어떤 문서에 있는지 매핑
4. 점수 계산: 검색 정확도에 따른 Score 부여

Search Index 생성

1. Collection → Search Indexes → Create Index
2. Analyzer: lucene.korean 선택 (한국어 불용어 제거)
3. Dynamic Mapping: 끄기 (수동으로 필드 선택)
4. Field Mapping: 검색할 필드 지정 (예: title)

서버에서 Search Index 활용

app.get('/search', async (요청, 응답) => {
  let 검색조건 = [
    {
      $search: {
        index: '사용할 인덱스 이름',
        text: { 
          query: 요청.query.val, 
          path: 'title' 
        }
      }
    }
  ]
  let result = await db.collection('post').aggregate(검색조건).toArray()
  응답.render('search.ejs', { 글목록: result })
})

고급 검색 옵션

다양한 검색 조건 조합

let 검색조건 = [
  {
    $search: {
      index: '사용할 인덱스 이름',
      text: { query: '검색어', path: '검색할 필드이름' }
    }
  },
  { $sort: { _id: 1 } },        // 정렬 (기본값: score 순)
  { $limit: 10 },               // 결과 개수 제한
  { $skip: 5 },                 // 앞의 5개 건너뛰기
  { $project: { 제목: 1, _id: 0 } }  // 특정 필드만 반환
]

주요 연산자 설명

• $sort: 검색 결과 정렬 (기본적으로 relevance score 순)
• $limit: 결과 개수 제한 (페이지네이션에 유용)
• $skip: 지정된 개수만큼 건너뛰기
• $project: 반환할 필드 선택 (1: 포함, 0: 제외)

검색 결과 페이지네이션 예시

// 첫 번째 페이지: 3개씩, skip 0
{ $skip: 0 }, { $limit: 3 }

// 두 번째 페이지: 3개씩, skip 3  
{ $skip: 3 }, { $limit: 3 }

// 세 번째 페이지: 3개씩, skip 6
{ $skip: 6 }, { $limit: 3 }

Search Index의 장점

• 자동 불용어 제거: 한국어 조사, 어미 자동 처리
• 유연한 검색: '안녕' 검색 시 '안녕하세요', '안녕하십니까' 모두 검색
• 자동 점수 계산: 검색 정확도에 따른 자동 순위 매김
• 빠른 성능: 대용량 데이터에서도 빠른 검색 속도

기본 개념

• 많은 데이터를 여러 페이지로 나누어 보여주는 기능
• DB 부담과 브라우저 성능 최적화를 위해 필요

URL 구조 설계

/list/1  → 1~5번째 글
/list/2  → 6~10번째 글  
/list/3  → 11~15번째 글

기본 구현 (하드코딩)

app.get('/list/1', async (요청, 응답) => {
  let result = await db.collection('post').find().skip(0).limit(5).toArray()
  응답.render('list.ejs', { 글목록 : result })
})

URL 파라미터 활용

app.get('/list/:id', async (요청, 응답) => {
  let result = await db.collection('post').find()
    .skip((요청.params.id - 1) * 5)
    .limit(5)
    .toArray()
  응답.render('list.ejs', { 글목록 : result })
})

MongoDB 쿼리 메소드

• .limit(5) : 최대 5개 문서만 가져오기
• .skip(5) : 앞의 5개 문서 건너뛰기
• .toArray() : 결과를 배열로 변환

skip() 방식의 한계

• 큰 숫자(100만 이상) skip 시 성능 저하
• 문서를 하나씩 세어가며 처리하기 때문

성능 최적화된 Pagination

_id 기반 방식

await db.collection('post').find({
  _id: { $gt: 마지막게시물_id }
}).limit(5).toArray()

장점과 단점

• 장점: 매우 빠른 성능 (_id 기반 검색은 DB가 가장 빠르게 처리)
• 단점: 순차적 탐색만 가능, 특정 페이지로 점프 불가

다음 버튼 구현

// 서버 코드
app.get('/list/next/:id', async (요청, 응답) => {
  let result = await db.collection('post').find({
    _id: { $gt: new ObjectId(요청.params.id) }
  }).limit(5).toArray()
  응답.render('list.ejs', { 글목록 : result })
})

<!-- EJS 템플릿 -->
<a href="/list/next/<%= 글목록[글목록.length - 1]._id %>">다음</a>

Auto Increment 구현

• MongoDB는 기본 auto increment 미지원
• Counter 컬렉션 활용하여 구현
• Trigger 기능 사용 권장

Session 기반 회원 인증

기본 동작 원리

회원가입

1. 유저가 아이디/비번 입력
2. 서버가 DB에 저장

로그인

1. 유저가 로그인 시도
2. DB의 정보와 대조 확인
3. 성공 시 세션 생성 및 쿠키 발급

인증이 필요한 기능

1. 유저가 요청 시 쿠키 자동 전송
2. 서버가 세션 확인 후 서비스 제공

입장권(세션) 저장 방식

• 브라우저 쿠키에 자동 저장
• GET/POST 요청 시 자동으로 함께 전송

Session vs JWT 비교

Session 방식

• DB에 세션 정보 저장
• 매 요청마다 DB 조회 필요
• 장점: 엄격한 사용자 검증 가능
• 단점: DB 부담 증가

JWT(Token) 방식

• 사용자 정보를 암호화하여 토큰에 저장
• DB 조회 없이 토큰 검증
• 장점: DB 부담 적음, 확장성 좋음
• 단점: 토큰 탈취 시 강제 로그아웃 어려움

Passport 라이브러리 설정

설치

npm install express-session passport passport-local

기본 설정

const session = require('express-session')
const passport = require('passport')
const LocalStrategy = require('passport-local')

app.use(passport.initialize())
app.use(session({
  secret: '암호화에 쓸 비번',
  resave: false,
  saveUninitialized: false
}))
app.use(passport.session())

로그인 검증 로직

passport.use(new LocalStrategy(async (입력한아이디, 입력한비번, cb) => {
  let result = await db.collection('user').findOne({ username: 입력한아이디 })
  if (!result) {
    return cb(null, false, { message: '아이디 DB에 없음' })
  }
  if (result.password == 입력한비번) {
    return cb(null, result)
  } else {
    return cb(null, false, { message: '비번불일치' })
  }
}))

로그인 API

app.post('/login', async (요청, 응답, next) => {
  passport.authenticate('local', (error, user, info) => {
    if (error) return 응답.status(500).json(error)
    if (!user) return 응답.status(401).json(info.message)
    요청.logIn(user, (err) => {
      if (err) return next(err)
      응답.redirect('/')
    })
  })(요청, 응답, next)
})

세션 생성

passport.serializeUser((user, done) => {
  process.nextTick(() => {
    done(null, { id: user._id, username: user.username })
  })
})

세션 검증

passport.deserializeUser(async (user, done) => {
  let result = await db.collection('user').findOne({
    _id: new ObjectId(user.id)
  })
  delete result.password
  process.nextTick(() => {
    return done(null, result)
  })
})

세션 유효기간 설정

app.use(session({
  secret: '암호화에 쓸 비번',
  resave: false,
  saveUninitialized: false,
  cookie: { maxAge: 60 * 60 * 1000 } // 1시간
}))

로그인 상태 확인

• API 내에서 요청.user로 현재 로그인된 사용자 정보 확인 가능
• 브라우저 개발자도구 → Application → Cookies에서 세션 쿠키 확인

삼항연산자 기본 개념

JavaScript에서 사용하는 조건부 연산자를 TypeScript 타입에서도 활용 가능합니다.

// JavaScript 삼항연산자
조건문 ? 참일때실행할코드 : 거짓일때실행할코드
3 > 1 ? console.log('맞아요') : console.log('아님')

TypeScript 조건부 타입

type Age<T> = T extends string ? string : unknown;

let age: Age<string>;   // string 타입
let age2: Age<number>;  // unknown 타입

핵심: extends 키워드로 조건을 만들고, 삼항연산자로 결과 타입을 지정합니다.

실용적인 예제

type FirstItem<T> = T extends any[] ? T[0] : any;

let age1: FirstItem<string[]>;  // string 타입
let age2: FirstItem<number>;    // any 타입

2. infer 키워드

기본 문법

조건부 타입에서 타입을 추출하여 변수로 사용할 수 있는 키워드입니다.

type Person<T> = T extends infer R ? R : unknown;
type 새타입 = Person<string>;  // string 타입

배열 타입 추출

type 타입추출<T> = T extends (infer R)[] ? R : unknown;
type NewType = 타입추출<boolean[]>;  // boolean 타입

함수 Return 타입 추출

type 타입추출<T> = T extends (() => infer R) ? R : unknown;
type NewType = 타입추출<() => number>;  // number 타입

참고: ReturnType<> 내장 타입으로도 함수의 return 타입 추출 가능합니다.

3. declare 키워드와 외부 파일 연동

declare 키워드 사용법

외부 JavaScript 파일의 변수를 TypeScript에서 사용할 때 타입 에러를 방지합니다.

// data.js
var a = 10;
var b = {name: 'kim'};

// index.ts
declare let a: number;
console.log(a + 1);  // 에러 없이 사용 가능

특징:

• declare가 붙은 코드는 JavaScript로 변환되지 않음
• 컴파일러에게 힌트를 주는 역할

Ambient Module

TypeScript의 특별한 기능으로, import/export 없이도 같은 폴더의 타입을 전역으로 사용 가능합니다.

// data.ts
type Age = number;
let 나이: Age = 20;

// index.ts (import 없이 사용 가능)
console.log(나이 + 1);   // 가능
let 철수: Age = 30;      // 가능

Global 모듈 만들기

// 로컬 모듈에서 전역 타입 선언
declare global {
  type Dog = string;
}

4. d.ts 파일 활용

d.ts 파일이란?

• Definition의 약자로 타입 정의만 저장하는 파일
• JavaScript로 컴파일되지 않음
• 타입 정의 전용 파일

타입 정의 파일 만들기

// types.d.ts
export type Age = number;
export type multiply = (x: number, y: number) => number;
export interface Person { name: string }

자동 생성 설정

// tsconfig.json
{
  "compilerOptions": {
    "declaration": true
  }
}

이 설정으로 .ts 파일 저장 시 자동으로 .d.ts 파일이 생성됩니다.

외부 라이브러리 타입 설치

npm install --save @types/jquery

5. implements 키워드

기본 사용법

클래스가 특정 인터페이스의 구조를 갖고 있는지 확인하는 키워드입니다.

interface CarType {
  model: string;
  price: number;
}

class Car implements CarType {
  model: string;
  price: number = 1000;
  constructor(a: string) {
    this.model = a;
  }
}

implements vs extends

• implements: 구조 확인만 (타입 할당 안됨)
• extends: 상속 (속성과 메서드 복사)

class Car implements CarType {
  model;  // any 타입 (implements는 타입 할당 안함)
  // ...
}

6. Index Signatures

기본 문법

객체의 모든 속성에 대한 타입을 한 번에 지정하는 방법입니다.

interface StringOnly {
  [key: string]: string;
}

let obj: StringOnly = {
  name: 'kim',
  age: '20',        // 모든 값이 string이어야 함
  location: 'seoul'
};

다른 속성과 함께 사용

interface StringOnly {
  age: string;                    // 특정 속성 지정
  [key: string]: string;          // 나머지 모든 속성
}

숫자 키 사용

interface StringOnly {
  [key: number]: string;
}

let obj: StringOnly = {
  0: 'kim',
  1: '20',
  2: 'seoul'
};

Recursive Index Signatures

중첩된 객체를 위한 재귀적 타입 정의입니다.

interface MyType {
  'font-size': MyType | number;
}

let obj: MyType = {
  'font-size': {
    'font-size': {
      'font-size': 14
    }
  }
};

7. keyof 연산자와 Mapped Types

keyof 연산자

객체 타입의 모든 키를 union type으로 추출합니다.

interface Person {
  age: number;
  name: string;
}

type PersonKeys = keyof Person;  // "age" | "name"

Mapped Types

기존 타입의 모든 속성을 다른 타입으로 변환하는 타입 변환기입니다.

type Car = {
  color: boolean;
  model: boolean;
  price: boolean | number;
};

type TypeChanger<MyType> = {
  [key in keyof MyType]: string;
};

type 새로운타입 = TypeChanger<Car>;
// { color: string; model: string; price: string; }

범용 타입 변환기

type TypeChanger<MyType, T> = {
  [key in keyof MyType]: T;
};

type NewBus = TypeChanger<Bus, boolean>;    // 모든 속성이 boolean
type NewBus2 = TypeChanger<Bus, string[]>;  // 모든 속성이 string[]

8. 실무 예제

숙제 1: 조건부 타입

type Age<T> = T extends [string, ...any] ? T[0] : unknown;

let age1: Age<[string, number]>;   // string
let age2: Age<[boolean, number]>;  // unknown

숙제 2: infer로 함수 파라미터 추출

type 타입뽑기<T> = T extends (x: infer R) => any ? R : any;
type a = 타입뽑기<(x: number) => void>;  // number

숙제 3: Index Signatures 활용

// 자동차 정보 타입
interface CarInfo {
  [key: string]: string | number;
}

// 중첩 객체 타입
interface MyType {
  'font-size': number;
  [key: string]: number | MyType;
}

숙제 4: Mapped Types 활용

// Bus 타입 변환
type Bus = {
  color: string;
  model: boolean;
  price: number;
};

type TypeChanger<MyType> = {
  [key in keyof MyType]: string | number;
};

type NewBus = TypeChanger<Bus>;

정리

조건부 타입 & infer

• 목적: 타입 파라미터에 따라 다른 타입 반환
• 방법: extends와 삼항연산자, infer로 타입 추출

declare & d.ts

• 목적: 외부 JavaScript 파일과의 연동, 타입 정의 분리
• 방법: declare로 타입 힌트, .d.ts로 타입 정의 파일

Index Signatures & Mapped Types

• 목적: 동적 객체 타입 정의, 타입 변환
• 방법: [key: type]: type 문법, keyof와 in 연산자

새 프로젝트 생성

npx create-react-app 프로젝트명 --template typescript

기존 프로젝트에 TypeScript 추가

npm install --save typescript @types/node @types/react @types/react-dom @types/jest

핵심: 컴포넌트 파일은 .tsx 확장자 사용 (JSX 문법 지원)

2. React에서 TypeScript 사용법

JSX 타입 지정

let 박스: JSX.Element = <div></div>;
let 버튼: JSX.Element = <button></button>;

함수 컴포넌트 타입 지정

type AppProps = {
  name: string;
};

function App(props: AppProps): JSX.Element {
  return <div>{props.name}</div>;
}

Props로 JSX 전달하기

type ContainerProps = {
  a: JSX.IntrinsicElements['h4'];
};

function Container(props: ContainerProps) {
  return <div>{props.a}</div>;
}

// 사용법
<Container a={<h4>안녕</h4>} />

State 타입 지정

const [user, setUser] = useState<string | null>('kim');

Type Assertion 주의사항

// React에서는 <> 대신 as 사용
let code: any = 123;
let employeeCode = code as number;  // ✅ 올바름
let employeeCode2 = <number>code;   // ❌ React에서 금지

3. Tuple 타입

기본 문법

배열의 각 위치별로 정확한 타입 지정

let 멍멍이: [string, boolean];
멍멍이 = ['dog', true];  // ✅ 올바름
멍멍이 = [true, 'dog'];  // ❌ 순서 틀림

Rest Parameter와 Tuple

function 함수(...x: [string, number]) {
  console.log(x);
}

함수('kim', 123);        // ✅ 가능
함수('kim', 123, 456);   // ❌ 에러

옵션 요소 (뒤에서만 가능)

type Num = [number, number?, number?];
let 변수1: Num = [10];
let 변수2: Num = [10, 20];
let 변수3: Num = [10, 20, 30];

Spread 연산자와 Tuple

let arr = [1, 2, 3];
let arr2: [number, number, ...number[]] = [4, 5, ...arr];

4. Redux TypeScript 설정

Redux를 사용하는 이유

1. 중앙 집중식 state 관리 - props 없이도 state 공유 가능
2. 안전한 state 수정 - reducer 함수로 수정 방법을 미리 정의하여 버그 방지

설치

npm install redux react-redux
npm install @reduxjs/toolkit  # 신규 방식 사용시

5. 전통 방식 Redux + TypeScript

Store 설정

import { Provider } from 'react-redux';
import { createStore } from 'redux';

interface Counter {
  count: number;
}

const 초기값: Counter = { count: 0 };

function reducer(state = 초기값, action: {type: string}) {
  if (action.type === '증가') {
    return { count: state.count + 1 };
  } else if (action.type === '감소') {
    return { count: state.count - 1 };
  } else {
    return state;
  }
}

const store = createStore(reducer);

// Store 타입 export
export type RootState = ReturnType<typeof store.getState>;

컴포넌트에서 사용

import { useDispatch, useSelector } from 'react-redux';
import { Dispatch } from 'redux';
import { RootState } from './index';

function App() {
  const 꺼내온거 = useSelector((state: RootState) => state);
  const dispatch: Dispatch = useDispatch();

  return (
    <div>
      {꺼내온거.count}
      <button onClick={() => dispatch({type: '증가'})}>
        버튼
      </button>
    </div>
  );
}

6. 신규 방식 Redux Toolkit + TypeScript

Store 설정

import { createSlice, configureStore, PayloadAction } from '@reduxjs/toolkit';

const 초기값 = { count: 0, user: 'kim' };

const counterSlice = createSlice({
  name: 'counter',
  initialState: 초기값,
  reducers: {
    increment(state) {
      state.count += 1;
    },
    decrement(state) {
      state.count -= 1;
    },
    incrementByAmount(state, action: PayloadAction<number>) {
      state.count += action.payload;
    }
  }
});

const store = configureStore({
  reducer: {
    counter1: counterSlice.reducer
  }
});

export type RootState = ReturnType<typeof store.getState>;
export const { increment, decrement, incrementByAmount } = counterSlice.actions;

컴포넌트에서 사용

import { useDispatch, useSelector } from 'react-redux';
import { RootState, increment } from './index';

function App() {
  const 꺼내온거 = useSelector((state: RootState) => state);
  const dispatch = useDispatch();

  return (
    <div>
      {꺼내온거.counter1.count}
      <button onClick={() => dispatch(increment())}>
        버튼
      </button>
    </div>
  );
}

7. 실무 예제

숙제 1: 음식 정보 Tuple

let 음식: [string, number, boolean] = ['동서녹차', 4000, true];

숙제 2: 가변 길이 Tuple

let arr: [string, number, ...boolean[]] = ['동서녹차', 4000, true, false, true];

숙제 3: Rest Parameter + Tuple

function 함수(...rest: [string, boolean, ...(number | string)[]]) {
  // 첫째는 문자, 둘째는 boolean, 나머지는 숫자 또는 문자
}

함수('a', true, 6, 3, '1', 4);

숙제 4: 문자/숫자 분류기

function 함수(...rest: (string | number)[]): [string[], number[]] {
  let result: [string[], number[]] = [[], []];

  rest.forEach((a) => {
    if (typeof a === 'string') {
      result[0].push(a);
    } else {
      result[1].push(a);
    }
  });

  return result;
}

// 사용 예시
함수('b', 5, 6, 8, 'a');  // [['b', 'a'], [5, 6, 8]]

정리

React + TypeScript 핵심

• 파일 확장자: .tsx 사용
• JSX 타입: JSX.Element
• Props/State: 명확한 타입 지정
• Assertion: as 키워드만 사용

Redux + TypeScript 핵심

• Store 타입: RootState export로 재사용
• Action 타입: PayloadAction<T> 사용 (신규 방식)
• 전통 vs 신규: 코드 길이와 복잡도 차이

변수와 함수 내보내기/가져오기

a.ts (내보내는 파일)

export var 이름 = 'kim';
export var 나이 = 30;

b.ts (가져오는 파일)

import {이름, 나이} from './a';
console.log(이름);  // 'kim'

핵심 규칙:

• export: 다른 파일에서 사용할 수 있도록 내보내기
• import: 다른 파일에서 내보낸 것을 가져오기
• 파일 경로는 ./로 시작 (현재 경로)
• .ts 확장자는 생략

전체 가져오기

import * from './a';  // a.ts의 모든 export를 가져옴
console.log(이름);
console.log(나이);

타입 내보내기/가져오기

a.ts

export type Name = string | boolean;
export type Age = (a: number) => number;

b.ts

import {Name, Age} from './a';

let 이름: Name = 'kim';
let 함수: Age = (a) => { return a + 10 };

로컬 타입: export를 붙이지 않으면 해당 파일에서만 사용 가능

2. Namespace (구버전 방식)

기본 문법

타입스크립트 1.5 이전에 사용되던 방식. 타입명 중복을 방지

a.ts

namespace MyNamespace {
  export interface PersonInterface { age: number };
  export type NameType = number | string;
}

b.ts

/// <reference path="./a.ts" />

let 이름: MyNamespace.NameType = '민수';
let 나이: MyNamespace.PersonInterface = { age: 10 };

특징:

• /// <reference path=""/> 태그로 파일 연결
• 네임스페이스명.타입명 형식으로 사용
• 타입명 중복 문제 해결

Generic 타입

1. Generic이 필요한 이유

문제 상황

function 함수(x: unknown[]) {
  return x[0];  // return 타입이 unknown
}

let a = 함수([4, 2]);
console.log(a + 1);  // 에러! unknown 타입이라 연산 불가

문제점: TypeScript는 타입을 자동으로 변경해주지 않음

2. Generic 기본 문법

함수에 Generic 적용

function 함수<MyType>(x: MyType[]): MyType {
  return x[0];
}

let a = 함수<number>([4, 2]);     // a는 number 타입
let b = 함수<string>(['kim', 'park']);  // b는 string 타입

동작 원리:

• <MyType>: 타입 파라미터 정의
• 함수<number>(): 사용 시 타입 지정
• MyType 자리에 입력한 타입이 대입됨

타입 추론

let a = 함수([4, 2]);  // <number> 생략 가능, 자동으로 타입 추론

3. Generic 제약 조건 (Constraints)

extends로 타입 제한

function 함수<MyType extends number>(x: MyType) {
  return x - 1;  // number 타입만 허용하므로 연산 가능
}

let a = 함수<number>(100);  // 성공

커스텀 타입으로 제한

interface lengthCheck {
  length: number;
}

function 함수<MyType extends lengthCheck>(x: MyType) {
  return x.length;  // length 속성이 있는 타입만 허용
}

let a = 함수<string>('hello');    // 성공 (string에 length 있음)
let b = 함수<number>(1234);       // 에러 (number에 length 없음)

4. 다양한 활용법

Class에서 Generic

class Person<T> {
  name: T;
  constructor(a: T) {
    this.name = a;
  }
}

let a = new Person<string>('어쩌구');  // name이 string 타입

Type에서 Generic

type Age<MyType> = MyType;

5. 실무 예제

숙제 1: 문자/배열 길이 측정 함수

function 함수<MyType extends string | string[]>(x: MyType) {
  console.log(x.length);
}

함수<string>('hello');           // 5 출력
함수<string[]>(['kim', 'park']); // 2 출력

숙제 2: JSON 파싱 함수

interface Animal {
  name: string;
  age: number;
}

function 함수<Type>(x: string): Type {
  return JSON.parse(x);
}

let data = '{"name": "dog", "age": 1}';
let result = 함수<Animal>(data);  // Animal 타입으로 변환

숙제 3: 타입 중복 해결 (Namespace)

namespace GoodDog {
  export type Dog = string;
}

namespace BadDog {
  export interface Dog { name: string };
}

let dog1: GoodDog.Dog = 'bark';
let dog2: BadDog.Dog = { name: 'paw' };

정리

Import/Export

• 목적: 파일 간 코드 재사용
• 방법: export로 내보내고 import로 가져오기
• 타입도 동일하게 적용 가능

Generic

• 목적: 타입을 파라미터처럼 전달하여 재사용성 높이기
• 방법: <타입파라미터> 문법 사용
• 제약: extends로 허용할 타입 범위 제한 가능

1. public, private 키워드

public 키워드

• 클래스 속성을 어디서든 접근하고 수정 가능하게 만듦
• 기본값이므로 생략해도 동일하게 작동

class User {
  public name: string;

  constructor() {
    this.name = 'kim';
  }
}

let 유저1 = new User();
유저1.name = 'park';  // 가능

private 키워드

• 클래스 내부에서만 접근하고 수정 가능
• 자식 객체에서도 접근 불가능

class User {
  public name: string;
  private familyName: string;

  constructor() {
    this.name = 'kim';
    let hello = this.familyName + '안뇽';  // 가능 (클래스 내부)
  }
}

let 유저1 = new User();
유저1.name = 'park';        // 가능
유저1.familyName = '456';   // 에러 (외부 접근 불가)

private 속성 수정하기

외부에서 private 속성을 수정하려면 클래스 내부에 함수를 만들어 간접 접근

class User {
  private familyName: string;

  changeSecret() {
    this.familyName = 'park';  // 클래스 내부에서 수정
  }
}

let 유저1 = new User();
유저1.changeSecret();  // 함수를 통한 간접 수정

활용법: 중요한 데이터를 실수로 수정하는 것을 방지하고, 안전장치를 추가한 개발 가능

2. Constructor 단축 문법

public/private 키워드를 constructor 파라미터에 붙이면 필드 선언과 할당을 동시에 처리

// 기존 방식
class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

// 단축 문법
class Person {
  constructor(public name: string) {
    // this.name = name 자동 생성
  }
}

3. protected 키워드

private와 비슷하지만 extends로 상속받은 클래스에서도 사용 가능

class User {
  protected x = 10;
}

class NewUser extends User {
  doThis() {
    this.x = 20;  // protected라서 가능 (private이면 에러)
  }
}

• private: 해당 클래스에서만 사용
• protected: 해당 클래스 + 상속받은 클래스에서 사용

4. static 키워드

속성이나 메서드를 클래스 자체에 부여 (인스턴스가 아닌)

class User {
  static x = 10;  // 클래스에 직접 부여
  y = 20;         // 인스턴스에 부여
}

let john = new User();
john.x;   // 불가능
User.x;   // 가능 (10)
john.y;   // 가능 (20)

static 활용 예시

클래스의 기본 설정값이나 공통 데이터 저장용

class User {
  static skill = 'js';
  intro = User.skill + ' 전문가입니다';
}

// 설정 변경
User.skill = 'python';
let 민수 = new User();  // 'python 전문가입니다'

키워드 조합 사용

class User {
  private static x = 10;     // 클래스 내부에서만 접근 가능한 static
  public static y = 20;      // 어디서든 접근 가능한 static
  protected z = 30;          // 상속 클래스에서도 사용 가능
}

5. 실무 활용 예시

숙제 1: 키워드 특징 정리

class User {
  private static x = 10;    // User 클래스에서만 접근, 수정 가능
  public static y = 20;     // 어디서든 User.y로 접근, 수정 가능
  protected z = 30;         // 클래스 내부 + 상속 클래스에서 사용 가능
}

숙제 2: static 메서드 만들기

class User {
  private static x = 10;
  public static y = 20;

  static addOne(param: number) {
    User.x += param;  // static 속성은 클래스명.속성으로 접근
  }

  static printX() {
    console.log(User.x);
  }
}

User.addOne(3);
User.printX();  // 13

숙제 3: DOM 조작 클래스

class Square {
  constructor(
    public width: number, 
    public height: number, 
    public color: string
  ) {}

  draw() {
    let randomPos = Math.random() * 400;  // 0~400px 랜덤 위치

    let square = `<div style="
      position: relative;
      top: ${randomPos}px;
      left: ${randomPos}px;
      width: ${this.width}px;
      height: ${this.height}px;
      background: ${this.color}
    "></div>`;

    document.body.insertAdjacentHTML('beforeend', square);
  }
}

let 네모 = new Square(30, 30, 'red');
네모.draw();  // 랜덤 위치에 빨간 사각형 생성

정리

핵심: 각 키워드는 데이터 보안과 코드 구조화를 위한 도구들입니다

&& 연산자의 특별한 기능

• falsy 값: null, undefined, NaN, false 등
• 동작 원리: 첫 번째 falsy 값을 반환하거나, 모두 truthy면 마지막 값 반환

1 && null && 3          // null 반환
undefined && '안녕' && 100  // undefined 반환

실무 활용법

function printAll(strs: string | undefined) {
  if (strs && typeof strs === "string") {  
    console.log(strs);
  } 
}

// 또는 더 간단하게
if (변수 != null) {
  // null과 undefined 모두 걸러냄
}

2. in 연산자로 Object Narrowing

서로 다른 속성을 가진 객체들을 구분할 때 사용

type Fish = { swim: string };
type Bird = { fly: string };

function 함수(animal: Fish | Bird) {
  if ("swim" in animal) {
    return animal.swim;  // Fish 타입으로 narrowing
  }
  return animal.fly;     // Bird 타입으로 narrowing
}

핵심: 배타적인 속성(서로 겹치지 않는 속성)이 있어야 narrowing 가능

3. instanceof로 Class 객체 구분

클래스로 생성된 객체들을 구분할 때 사용

let 날짜 = new Date();
if (날짜 instanceof Date) {
  console.log('Date 객체입니다');
}

4. Literal Type을 활용한 Narrowing

가장 실용적인 방법으로, 각 타입에 고유한 literal 값을 부여

type Car = {
  wheel: '4개',
  color: string
}

type Bike = {
  wheel: '2개', 
  color: string
}

function 함수(x: Car | Bike) {
  if (x.wheel === '4개') {
    console.log('차량: ' + x.color);
  } else {
    console.log('바이크: ' + x.color);
  }
}

장점: 비슷한 구조의 객체들도 쉽게 구분 가능

Rest 파라미터 & Destructuring

Rest 파라미터 기본 개념

개수가 정해지지 않은 파라미터를 받을 때 사용

function 전부더하기(...a: number[]) {
  console.log(a);  // 배열로 받아짐
}

전부더하기(1, 2, 3, 4, 5);  // [1, 2, 3, 4, 5]

주의사항:

• 다른 파라미터 뒤에만 올 수 있음
• 항상 배열 형태로 전달됨

Spread vs Rest 구분

// Spread: 배열/객체 펼치기
let arr = [3, 4, 5];
let arr2 = [1, 2, ...arr];  // [1, 2, 3, 4, 5]

// Rest: 파라미터 여러 개 받기  
function func(...params) { }

Destructuring 문법

객체 Destructuring

let { student, age } = { student: true, age: 20 };

배열 Destructuring

let [a, b] = ['안녕', 100];

함수 파라미터에서 Destructuring

// 객체 파라미터
type UserType = {
  user: string,
  comment: number[],
  admin: boolean
}

function 함수({user, comment, admin}: UserType): void {
  console.log(user, comment, admin);
}

// 배열 파라미터
type 어레이 = (number | string | boolean)[];

function 함수2([a, b, c]: 어레이) {
  console.log(a, b, c);
}

Never Type 완벽 이해

Never Type 기본 조건

함수에 never 타입을 사용하려면:

1. 절대 return하지 않음
2. 함수 실행이 끝나지 않음 (endpoint가 없음)

Never Type 사용 예시

무한 루프

function 함수(): never {
  while (true) {
    console.log(123);
  }
}

에러 발생

function 함수(): never {
  throw new Error('에러메세지');
}

Never가 자동으로 나타나는 경우

1. 잘못된 Narrowing

function 함수(parameter: string) {
  if (typeof parameter === "string") {
    parameter + 1;
  } else {
    parameter;  // never 타입이 됨 (있을 수 없는 경우)
  }
}

2. 함수 표현식 vs 함수 선언문

// 함수 선언문 → void 타입
function 함수1() {
  throw new Error();
}

// 함수 표현식 → never 타입  
let 함수2 = function() {
  throw new Error();
}

3. Strict 모드에서 빈 배열

let arr = [];  // strict 모드에서 never[] 타입

실무에서는?

Never 타입은 직접 사용할 일이 거의 없음. 주로 코드 오류 감지용으로 자동 등장하므로, never가 보이면 코드를 점검해봅시다.

기본 개념

긴 타입 정의를 변수처럼 저장하여 재사용하는 기능

기본 사용법

// 기본 Type Alias
type Animal = string | number | undefined
let 동물: Animal = 'cat'

// 복잡한 Union 타입을 간단하게
type StringOrNumber = string | number
let value: StringOrNumber = 123

Object 타입 저장

type 사람 = {
  name: string,
  age: number,
}

let teacher: 사람 = { name: 'john', age: 20 }

// Type Alias 없이 쓰면
let teacher: {
  name: string,
  age: number,
} = { name: 'john', age: 20 }  // 복잡하고 가독성 떨어짐

readonly 속성

type Girlfriend = {
  readonly name: string,
  age: number
}

let 여친: Girlfriend = {
  name: '엠버',
  age: 25
}

여친.name = '유라'  // 에러! readonly 속성
여친.age = 26       // 정상

선택적 속성 (Optional Properties)

type Square = {
  color?: string,    // 선택적 속성
  width: number,     // 필수 속성
}

let 네모1: Square = { width: 100 }              // 정상
let 네모2: Square = { color: 'red', width: 100 } // 정상

중요: color?는 color: string | undefined와 동일

Type Aliases 확장

Union으로 합치기

type Name = string
type Age = number
type Person = Name | Age  // string | number

let info: Person = 'kim'  // 정상
info = 25                 // 정상

Intersection으로 합치기 (&)

type PositionX = { x: number }
type PositionY = { y: number }
type XandY = PositionX & PositionY  // { x: number, y: number }

let 좌표: XandY = { x: 1, y: 2 }

복합 확장

type BasicInfo = { name: string, age: number }
type ContactInfo = { phone: string, email: string }
type UserInfo = BasicInfo & ContactInfo & { isActive: boolean }

let user: UserInfo = {
  name: 'kim',
  age: 25,
  phone: '010-1234-5678',
  email: 'kim@email.com',
  isActive: true
}

Type Aliases 제한사항

type Name = string
type Name = number  // 에러! 재정의 불가능

Type Narrowing (타입 좁히기)

문제 상황

function 내함수(x: number | string) {
  return x + 1  // 에러! Union 타입에서는 연산 불가
}

typeof를 사용한 Narrowing

function 내함수(x: number | string) {
  if (typeof x === 'number') {
    return x + 1        // x는 number 타입
  } else if (typeof x === 'string') {
    return x + '1'      // x는 string 타입
  } else {
    return 0            // 모든 경우 처리 (권장)
  }
}

다양한 Narrowing 방법

// 1. typeof 사용
function checkType(x: string | number) {
  if (typeof x === 'string') {
    return x.toUpperCase()  // string 메서드 사용 가능
  }
  return x * 2  // number 연산 가능
}

// 2. in 연산자 사용
type Dog = { bark: string }
type Cat = { meow: string }

function makeSound(animal: Dog | Cat) {
  if ('bark' in animal) {
    console.log(animal.bark)  // Dog 타입
  } else {
    console.log(animal.meow)  // Cat 타입
  }
}

// 3. instanceof 사용
function processDate(date: Date | string) {
  if (date instanceof Date) {
    return date.getFullYear()  // Date 메서드 사용 가능
  }
  return new Date(date).getFullYear()
}

// 4. Array.isArray() 사용
function processValue(value: string | string[]) {
  if (Array.isArray(value)) {
    return value.join(', ')    // 배열 메서드 사용 가능
  }
  return value.toUpperCase()   // 문자열 메서드 사용 가능
}

Type Assertion (타입 단언)

기본 사용법

function 내함수(x: number | string) {
  return (x as number) + 1
}

console.log(내함수(123))  // 124
console.log(내함수('123'))  // '1231' (문자열 연결)

Type Assertion 특징

1. 타입 강제 변환: Union 타입을 특정 타입으로 단언
2. 컴파일 타임만 적용: 실제 런타임 동작은 변경되지 않음
3. 제한적 사용: 관련 있는 타입끼리만 단언 가능

안전한 사용 예시

// DOM 요소 타입 단언
let button = document.querySelector('#btn') as HTMLButtonElement
button.disabled = true  // HTMLButtonElement 메서드 사용 가능

// API 응답 타입 단언
let response = JSON.parse('{"name":"kim","age":25}') as {name: string, age: number}
console.log(response.name)  // 타입 안전

Type Assertion vs Narrowing

// Narrowing (권장)
function safeAdd(x: number | string) {
  if (typeof x === 'number') {
    return x + 1
  }
  return parseFloat(x) + 1
}

// Assertion (주의해서 사용)
function riskyAdd(x: number | string) {
  return (x as number) + 1
}

Literal Types (리터럴 타입)

기본 개념

특정 값만 가질 수 있도록 제한하는 타입

문자열 Literal Type

let john: '대머리' = '대머리'
let kim: '솔로' = '솔로'

// john = '기혼'  // 에러! '대머리'만 가능

Union Literal Type

type Direction = 'left' | 'right' | 'up' | 'down'
let 방향: Direction = 'left'

type Status = 'loading' | 'success' | 'error'
let 현재상태: Status = 'loading'

숫자 Literal Type

type DiceNumber = 1 | 2 | 3 | 4 | 5 | 6
let 주사위: DiceNumber = 3

function rollDice(): DiceNumber {
  return Math.floor(Math.random() * 6) + 1 as DiceNumber
}

함수에서 Literal Type 활용

// 매개변수와 반환값 모두 Literal Type
function 가위바위보(choice: '가위' | '바위' | '보'): ('가위' | '바위' | '보')[] {
  return ['가위', '바위', '보']
}

// 템플릿 리터럴 타입 (고급)
type Theme = 'light' | 'dark'
type Color = 'red' | 'blue' | 'green'
type ThemedColor = `${Theme}-${Color}`  // 'light-red' | 'light-blue' | ... 등

as const 문법

문제 상황

var 자료 = {
  name: 'kim'
}

function 내함수(a: 'kim') {
  console.log(a)
}

내함수(자료.name)  // 에러! string 타입을 'kim' 타입에 할당 불가

as const로 해결

var 자료 = {
  name: 'kim'
} as const

function 내함수(a: 'kim') {
  console.log(a)
}

내함수(자료.name)  // 정상! 자료.name은 'kim' 타입

as const 효과

1. Literal 타입 적용: 값 자체가 타입이 됨
2. readonly 적용: 모든 속성이 변경 불가능

const config = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3
} as const

// config.apiUrl = 'other'  // 에러! readonly 속성

type ApiUrl = typeof config.apiUrl  // 'https://api.example.com' 타입

배열에서 as const

const colors = ['red', 'green', 'blue'] as const
type Color = typeof colors[number]  // 'red' | 'green' | 'blue'

function setColor(color: Color) {
  console.log(color)
}

setColor('red')    // 정상
setColor('yellow') // 에러!

실전 예제

예제 1: 데이터 클리닝 함수

function 클리닝함수(a: (number | string)[]): number[] {
  let 클리닝완료된거: number[] = []

  a.forEach((b) => {
    if (typeof b === 'string') {
      클리닝완료된거.push(parseFloat(b))
    } else {
      클리닝완료된거.push(b)
    }
  })

  return 클리닝완료된거
}

console.log(클리닝함수([123, '456', 789, '012']))  // [123, 456, 789, 12]

예제 2: 선생님 과목 조회 함수

type Teacher = {
  subject: string | string[]
}

function 마지막과목찾기(teacher: Teacher): string {
  if (typeof teacher.subject === 'string') {
    return teacher.subject
  } else if (Array.isArray(teacher.subject)) {
    return teacher.subject[teacher.subject.length - 1]
  } else {
    return '과목 없음'
  }
}

let 철수쌤 = { subject: 'math' }
let 영희쌤 = { subject: ['science', 'english'] }
let 민수쌤 = { subject: ['science', 'art', 'korean'] }

console.log(마지막과목찾기(철수쌤))  // 'math'
console.log(마지막과목찾기(영희쌤))  // 'english'
console.log(마지막과목찾기(민수쌤))  // 'korean'

예제 3: 사용자 타입 확장

// 기본 사용자 정보
type User = {
  name: string,
  email?: string,
  phone: string
}

// 성인 여부 추가
type Adult = {
  adult: boolean
}

// 두 타입 결합
type NewUser = User & Adult

let 회원가입정보: NewUser = {
  name: 'kim',
  adult: false,
  phone: '010-1234-5678'
  // email은 선택사항이므로 생략 가능
}

고급 패턴

1. 조건부 타입 활용

type ApiResponse<T> = {
  success: true,
  data: T
} | {
  success: false,
  error: string
}

function handleResponse<T>(response: ApiResponse<T>): T | null {
  if (response.success) {
    return response.data  // 타입 안전
  } else {
    console.error(response.error)
    return null
  }
}

2. Discriminated Union

type Shape = 
  | { kind: 'circle', radius: number }
  | { kind: 'square', size: number }
  | { kind: 'rectangle', width: number, height: number }

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2
    case 'square':
      return shape.size ** 2
    case 'rectangle':
      return shape.width * shape.height
    default:
      // 모든 케이스를 처리했는지 컴파일 타임에 확인
      const exhaustiveCheck: never = shape
      throw new Error(`Unhandled shape: ${exhaustiveCheck}`)
  }
}

3. Type Guard 함수

function isString(value: unknown): value is string {
  return typeof value === 'string'
}

function isNumber(value: unknown): value is number {
  return typeof value === 'number'
}

function processValue(value: unknown) {
  if (isString(value)) {
    console.log(value.toUpperCase())  // string 메서드 사용 가능
  } else if (isNumber(value)) {
    console.log(value.toFixed(2))     // number 메서드 사용 가능
  }
}

모범 사례 및 팁

1. Type Alias 네이밍

// 좋은 예
type UserProfile = { name: string, age: number }
type ApiResponse<T> = { data: T, status: number }
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE'

// 피해야 할 예
type user = { name: string, age: number }  // 소문자 시작
type Data = any  // 너무 일반적

2. Union vs Intersection 선택

// Union (OR): 여러 타입 중 하나
type StringOrNumber = string | number

// Intersection (AND): 모든 타입 속성 포함
type UserWithProfile = User & Profile

3. Narrowing vs Assertion 선택

// Narrowing 선호 (안전)
function processId(id: string | number) {
  if (typeof id === 'string') {
    return id.toUpperCase()
  }
  return id.toString()
}

// Assertion 최소화 (위험)
function processId(id: string | number) {
  return (id as string).toUpperCase()  // 런타임 에러 가능성
}

실전 체크리스트

Type Aliases

• 복잡한 타입을 Type Alias로 분리
• 의미 있는 이름으로 명명
• readonly와 선택적 속성 적절히 활용
• Intersection으로 타입 확장

Type Narrowing

• Union 타입 사용 시 적절한 타입 가드 구현
• typeof, in, instanceof 등 적절한 방법 선택
• 모든 케이스 처리 확인

Type Assertion

• 최소한으로 사용
• 타입 안전성이 확실할 때만 사용
• DOM 조작이나 외부 라이브러리 사용 시 활용

Literal Types

• 제한된 값만 허용해야 하는 경우 활용
• 상수나 설정값에 활용
• as const로 불변 객체 생성

결제 시스템 개요

• PG사 연동: 직접 결제 처리 X, 전문 업체 활용
• 결제 대행사: 다날, 이니시스, KG이니시스 등
• 통합 솔루션: 포트원(구 아임포트) 활용 권장

포트원(PortOne) 결제 구현

1. 포트원 설정

// 포트원 라이브러리 로드
<script src="https://cdn.iamport.kr/v1/iamport.js"></script>

// 초기화
const IMP = window.IMP;
IMP.init('imp_code'); // 발급받은 가맹점 식별코드

2. 결제 요청

// 결제 요청 함수
function requestPay() {
  IMP.request_pay({
    pg: "html5_inicis",              // PG사 코드
    pay_method: "card",              // 결제 방법
    merchant_uid: "order_" + new Date().getTime(), // 주문번호
    name: "상품명",                   // 상품명
    amount: 1000,                    // 결제 금액
    buyer_email: "buyer@example.com", // 구매자 이메일
    buyer_name: "구매자명",           // 구매자 이름
    buyer_tel: "010-1234-5678",      // 구매자 전화번호
    buyer_addr: "서울특별시",         // 구매자 주소
    buyer_postcode: "123-456"        // 구매자 우편번호
  }, function(rsp) {
    if (rsp.success) {
      // 결제 성공시
      fetch('/payment/complete', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          imp_uid: rsp.imp_uid,        // 결제 고유번호
          merchant_uid: rsp.merchant_uid, // 주문번호
          amount: rsp.paid_amount      // 결제 금액
        })
      })
      .then(response => response.json())
      .then(data => {
        if (data.success) {
          alert('결제가 완료되었습니다.');
          location.href = '/payment/success';
        }
      });
    } else {
      // 결제 실패시
      alert('결제에 실패하였습니다. ' + rsp.error_msg);
    }
  });
}

3. 서버에서 결제 검증

// 결제 완료 API
app.post('/payment/complete', async (요청, 응답) => {
  try {
    const { imp_uid, merchant_uid, amount } = 요청.body;

    // 포트원에서 결제 정보 조회 (결제 검증)
    const getToken = await fetch('https://api.iamport.kr/users/getToken', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        imp_key: 'your_api_key',
        imp_secret: 'your_api_secret'
      })
    });

    const { access_token } = await getToken.json();

    // 결제 정보 조회
    const getPaymentData = await fetch(`https://api.iamport.kr/payments/${imp_uid}`, {
      headers: { 'Authorization': access_token }
    });

    const paymentData = await getPaymentData.json();
    const { amount: paidAmount, status } = paymentData.response;

    // 결제 금액 및 상태 검증
    if (paidAmount === amount && status === 'paid') {
      // DB에 결제 정보 저장
      await db.collection('payments').insertOne({
        imp_uid: imp_uid,
        merchant_uid: merchant_uid,
        amount: amount,
        status: 'completed',
        user_id: 요청.user._id,
        created_at: new Date()
      });

      응답.json({ success: true, message: '결제가 완료되었습니다.' });
    } else {
      응답.json({ success: false, message: '결제 검증 실패' });
    }
  } catch (error) {
    console.error('결제 처리 오류:', error);
    응답.status(500).json({ success: false, message: '서버 오류' });
  }
});

해외 결제 솔루션

Stripe 결제 구현

// Stripe 라이브러리 로드
<script src="https://js.stripe.com/v3/"></script>

// Stripe 초기화
const stripe = Stripe('pk_test_your_publishable_key');

// 결제 요청
async function createPayment() {
  const response = await fetch('/create-payment-intent', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ amount: 1000 }) // 금액 (센트 단위)
  });

  const { client_secret } = await response.json();

  const result = await stripe.confirmCardPayment(client_secret, {
    payment_method: {
      card: cardElement,
      billing_details: {
        name: 'Customer Name'
      }
    }
  });

  if (result.error) {
    console.error(result.error.message);
  } else {
    console.log('결제 성공!');
  }
}

PayPal 결제 구현

// PayPal 버튼 생성
paypal.Buttons({
  createOrder: function(data, actions) {
    return actions.order.create({
      purchase_units: [{
        amount: {
          value: '10.00'
        }
      }]
    });
  },
  onApprove: function(data, actions) {
    return actions.order.capture().then(function(details) {
      alert('결제가 완료되었습니다. ' + details.payer.name.given_name);
    });
  }
}).render('#paypal-button-container');

리치 텍스트 에디터 구현

에디터의 역할

• WYSIWYG: What You See Is What You Get
• 기능: 텍스트 서식, 이미지 삽입, 링크 생성 등
• 데이터 변환: 사용자 입력 → HTML/JSON 형태로 변환

Quill.js 에디터 구현

1. 기본 설정

<!-- Quill 라이브러리 로드 -->
<link href="https://cdn.quilljs.com/1.3.6/quill.snow.css" rel="stylesheet">
<script src="https://cdn.quilljs.com/1.3.6/quill.min.js"></script>

<!-- 에디터 컨테이너 -->
<div id="editor">
  <p>여기에 내용을 입력하세요...</p>
</div>

2. 에디터 초기화

// Quill 에디터 초기화
const quill = new Quill('#editor', {
  theme: 'snow',
  modules: {
    toolbar: [
      [{ 'header': [1, 2, 3, false] }],
      ['bold', 'italic', 'underline', 'strike'],
      [{ 'color': [] }, { 'background': [] }],
      [{ 'list': 'ordered'}, { 'list': 'bullet' }],
      [{ 'indent': '-1'}, { 'indent': '+1' }],
      ['link', 'image', 'video'],
      ['clean']
    ]
  }
});

// 내용 가져오기
function getEditorContent() {
  const htmlContent = quill.root.innerHTML;
  const deltaContent = quill.getContents();

  return {
    html: htmlContent,
    delta: deltaContent
  };
}

// 폼 제출시 에디터 내용 포함
document.querySelector('form').addEventListener('submit', function(e) {
  const content = getEditorContent();

  // 숨겨진 input에 내용 저장
  document.querySelector('input[name="content"]').value = content.html;
  document.querySelector('input[name="contentDelta"]').value = JSON.stringify(content.delta);
});

3. 서버에서 에디터 데이터 처리

app.post('/add-post', async (요청, 응답) => {
  try {
    const { title, content, contentDelta } = 요청.body;

    // HTML 내용 검증 및 정제 (XSS 방지)
    const cleanContent = sanitizeHtml(content, {
      allowedTags: ['h1', 'h2', 'h3', 'p', 'br', 'strong', 'em', 'u', 'ol', 'ul', 'li', 'a', 'img'],
      allowedAttributes: {
        'a': ['href'],
        'img': ['src', 'alt']
      }
    });

    await db.collection('posts').insertOne({
      title: title,
      content: cleanContent,
      contentDelta: JSON.parse(contentDelta),
      author: 요청.user._id,
      createdAt: new Date()
    });

    응답.redirect('/posts');
  } catch (error) {
    console.error('게시글 저장 오류:', error);
    응답.status(500).send('서버 오류');
  }
});

Toast UI Editor 구현

1. 기본 설정

<!-- Toast UI Editor 라이브러리 -->
<link rel="stylesheet" href="https://uicdn.toast.com/editor/latest/toastui-editor.min.css" />
<script src="https://uicdn.toast.com/editor/latest/toastui-editor-all.min.js"></script>

<!-- 에디터 컨테이너 -->
<div id="editor"></div>

2. 에디터 초기화

// Toast UI Editor 초기화
const editor = new toastui.Editor({
  el: document.querySelector('#editor'),
  height: '500px',
  initialEditType: 'wysiwyg',
  previewStyle: 'vertical',
  placeholder: '내용을 입력하세요...',
  hooks: {
    addImageBlobHook: (blob, callback) => {
      // 이미지 업로드 처리
      uploadImage(blob).then(imageUrl => {
        callback(imageUrl, 'alt text');
      });
    }
  }
});

// 내용 가져오기
function getEditorContent() {
  const htmlContent = editor.getHTML();
  const markdownContent = editor.getMarkdown();

  return {
    html: htmlContent,
    markdown: markdownContent
  };
}

// 이미지 업로드 함수
async function uploadImage(blob) {
  const formData = new FormData();
  formData.append('image', blob);

  const response = await fetch('/upload-image', {
    method: 'POST',
    body: formData
  });

  const result = await response.json();
  return result.imageUrl;
}

에디터 보안 처리

HTML 검증 및 정제

// HTML 정제 라이브러리 설치
npm install sanitize-html

// 서버에서 HTML 정제
const sanitizeHtml = require('sanitize-html');

function sanitizeContent(content) {
  return sanitizeHtml(content, {
    allowedTags: [
      'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
      'p', 'br', 'hr',
      'strong', 'em', 'u', 's', 'sup', 'sub',
      'ol', 'ul', 'li',
      'a', 'img',
      'blockquote', 'code', 'pre',
      'table', 'thead', 'tbody', 'tr', 'th', 'td'
    ],
    allowedAttributes: {
      'a': ['href', 'target'],
      'img': ['src', 'alt', 'width', 'height'],
      'table': ['border', 'cellpadding', 'cellspacing'],
      'td': ['colspan', 'rowspan'],
      'th': ['colspan', 'rowspan']
    },
    allowedSchemes: ['http', 'https', 'mailto']
  });
}

파일 업로드 에디터 연동

이미지 업로드 서버 구현

const multer = require('multer');
const path = require('path');

// 파일 저장 설정
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/editor-images/');
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, 'image-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({ 
  storage: storage,
  limits: { fileSize: 5 * 1024 * 1024 }, // 5MB 제한
  fileFilter: function (req, file, cb) {
    // 이미지 파일만 허용
    if (file.mimetype.startsWith('image/')) {
      cb(null, true);
    } else {
      cb(new Error('이미지 파일만 업로드 가능합니다.'));
    }
  }
});

// 이미지 업로드 API
app.post('/upload-image', upload.single('image'), (요청, 응답) => {
  if (!요청.file) {
    return 응답.status(400).json({ error: '파일이 업로드되지 않았습니다.' });
  }

  const imageUrl = `/uploads/editor-images/${요청.file.filename}`;
  응답.json({ imageUrl: imageUrl });
});

// 정적 파일 서빙
app.use('/uploads', express.static('uploads'));

에디터 고급 기능

1. 자동 저장 기능

let autoSaveInterval;

function startAutoSave() {
  autoSaveInterval = setInterval(() => {
    const content = getEditorContent();
    const postId = getCurrentPostId();

    fetch('/auto-save', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        postId: postId,
        content: content.html,
        contentDelta: content.delta
      })
    })
    .then(response => response.json())
    .then(data => {
      if (data.success) {
        showAutoSaveIndicator();
      }
    });
  }, 30000); // 30초마다 자동 저장
}

function showAutoSaveIndicator() {
  const indicator = document.querySelector('#auto-save-indicator');
  indicator.textContent = '자동 저장됨 ' + new Date().toLocaleTimeString();
  indicator.style.opacity = '1';

  setTimeout(() => {
    indicator.style.opacity = '0';
  }, 3000);
}

2. 글자 수 제한

// Quill 에디터 글자 수 제한
quill.on('text-change', function() {
  const text = quill.getText();
  const maxLength = 10000;

  if (text.length > maxLength) {
    quill.deleteText(maxLength, text.length);
    alert(`최대 ${maxLength}자까지 입력 가능합니다.`);
  }

  // 글자 수 표시
  document.querySelector('#char-count').textContent = 
    `${text.length} / ${maxLength}`;
});

3. 에디터 테마 커스터마이징

/* Quill 에디터 커스텀 스타일 */
.ql-editor {
  min-height: 300px;
  font-size: 16px;
  line-height: 1.6;
}

.ql-toolbar {
  border-top: 1px solid #ccc;
  border-left: 1px solid #ccc;
  border-right: 1px solid #ccc;
}

.ql-container {
  border-bottom: 1px solid #ccc;
  border-left: 1px solid #ccc;
  border-right: 1px solid #ccc;
}

/* 다크 테마 */
.dark-theme .ql-editor {
  background-color: #2d3748;
  color: #e2e8f0;
}

.dark-theme .ql-toolbar {
  background-color: #4a5568;
  border-color: #718096;
}

실전 통합 예시

완전한 게시글 작성 폼

<form id="post-form" method="POST" action="/posts">
  <div class="form-group">
    <label for="title">제목</label>
    <input type="text" id="title" name="title" required>
  </div>

  <div class="form-group">
    <label for="category">카테고리</label>
    <select id="category" name="category">
      <option value="notice">공지사항</option>
      <option value="free">자유게시판</option>
      <option value="qna">Q&A</option>
    </select>
  </div>

  <div class="form-group">
    <label>내용</label>
    <div id="editor"></div>
    <input type="hidden" name="content" id="content-input">
    <input type="hidden" name="contentDelta" id="content-delta-input">
  </div>

  <div class="form-group">
    <div id="char-count">0 / 10000</div>
    <div id="auto-save-indicator"></div>
  </div>

  <div class="form-actions">
    <button type="button" onclick="saveDraft()">임시저장</button>
    <button type="submit">발행하기</button>
  </div>
</form>

<script>
// 에디터 초기화
const quill = new Quill('#editor', {
  theme: 'snow',
  modules: {
    toolbar: [
      [{ 'header': [1, 2, 3, false] }],
      ['bold', 'italic', 'underline'],
      [{ 'color': [] }, { 'background': [] }],
      [{ 'list': 'ordered'}, { 'list': 'bullet' }],
      ['link', 'image'],
      ['clean']
    ]
  }
});

// 폼 제출 처리
document.getElementById('post-form').addEventListener('submit', function(e) {
  const content = quill.root.innerHTML;
  const delta = quill.getContents();

  document.getElementById('content-input').value = content;
  document.getElementById('content-delta-input').value = JSON.stringify(delta);
});

// 자동 저장 시작
startAutoSave();
</script>

결제 및 에디터 비교표

결제 솔루션 비교

에디터 라이브러리 비교

실전 체크리스트

결제 기능

• PG사 계약 및 테스트 계정 발급
• 결제 라이브러리 연동
• 결제 검증 로직 구현
• 결제 내역 DB 저장
• 환불 처리 로직

에디터 기능

• 에디터 라이브러리 선택 및 연동
• 이미지 업로드 기능
• HTML 보안 처리
• 자동 저장 기능
• 반응형 디자인

보안 고려사항

• XSS 공격 방지
• 파일 업로드 보안
• 결제 데이터 암호화
• API 보안 인증

🎯 Admin Dashboard 실습 개요

관리자 페이지(Admin Dashboard)는 웹 개발에서 자주 만들게 되는 실무 프로젝트입니다. Bootstrap 5와 Font Awesome 5를 활용하여 효율적으로 제작해보겠습니다.

필요한 준비물

• Bootstrap 5 CDN 또는 다운로드
• Font Awesome 5 아이콘 라이브러리
• 커스텀 CSS 파일

🔝 1. 상단 네비게이션 바 제작

기본 구조

<nav class="navbar navbar-expand-lg navbar-light bg-light">
  <div class="container-fluid">
    <button class="navbar-toggler ms-auto" type="button" data-bs-toggle="collapse" data-bs-target="#navbar">
      <span class="navbar-toggler-icon"></span>
    </button>

    <div class="collapse navbar-collapse" id="navbar">
      <!-- 검색창 -->
      <form class="d-flex">
        <input class="form-control me-2 input-animation" type="search" placeholder="Search">
        <button class="btn btn-outline-secondary" type="submit">Search</button>
      </form>

      <!-- 우측 메뉴 -->
      <ul class="navbar-nav ms-auto mb-2 mb-lg-0">
        <li class="nav-item">
          <a class="nav-link position-relative" href="#">
            <span class="badge bg-danger notification-badge">5</span>
            <i class="fas fa-bell"></i>
          </a>
        </li>
        <li class="nav-item">
          <a class="nav-link" href="#">
            <i class="fas fa-envelope me-1"></i>
          </a>
        </li>
        <li class="nav-item">
          <a class="nav-link" href="#">Minny Park</a>
        </li>
      </ul>
    </div>
  </div>
</nav>

Bootstrap 유틸리티 클래스 활용

정렬 클래스:

• ms-auto: margin-start auto (오른쪽 정렬)
• me-auto: margin-end auto (왼쪽 정렬)
• d-flex: display flex
• justify-content-between: 양쪽 끝으로 정렬

알림 배지 스타일링

.nav-link {
  position: relative;
}

.notification-badge {
  position: absolute;
  top: -2px;
  left: 15px;
  font-size: 0.7rem;
  padding: 2px 6px;
  border-radius: 50%;
}

검색창 애니메이션

.input-animation {
  width: 150px;
  transition: width 0.8s ease;
}

.input-animation:focus {
  width: 300px;
  outline: none;
  box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
}

📊 2. Summary 카드 섹션

그리드 레이아웃

<div class="container">
  <h4 class="my-4">Dashboard</h4>
  <div class="row g-4">
    <div class="col-lg-3 col-md-6">
      <div class="summary-card earnings">
        <div class="card">
          <div class="card-body d-flex justify-content-between align-items-center">
            <div>
              <p class="card-text text-muted mb-1">Earnings (Monthly)</p>
              <h4 class="fw-bold text-primary">$40,000</h4>
            </div>
            <div class="icon-wrapper">
              <i class="fas fa-calendar fa-2x text-primary"></i>
            </div>
          </div>
        </div>
      </div>
    </div>

    <div class="col-lg-3 col-md-6">
      <div class="summary-card revenue">
        <div class="card border-left-success">
          <div class="card-body d-flex justify-content-between align-items-center">
            <div>
              <p class="card-text text-muted mb-1">Revenue (Annual)</p>
              <h4 class="fw-bold text-success">$215,000</h4>
            </div>
            <div class="icon-wrapper">
              <i class="fas fa-dollar-sign fa-2x text-success"></i>
            </div>
          </div>
        </div>
      </div>
    </div>

    <div class="col-lg-3 col-md-6">
      <div class="summary-card tasks">
        <div class="card border-left-info">
          <div class="card-body d-flex justify-content-between align-items-center">
            <div>
              <p class="card-text text-muted mb-1">Tasks</p>
              <h4 class="fw-bold text-info">50%</h4>
            </div>
            <div class="icon-wrapper">
              <i class="fas fa-clipboard-list fa-2x text-info"></i>
            </div>
          </div>
        </div>
      </div>
    </div>

    <div class="col-lg-3 col-md-6">
      <div class="summary-card requests">
        <div class="card border-left-warning">
          <div class="card-body d-flex justify-content-between align-items-center">
            <div>
              <p class="card-text text-muted mb-1">Pending Requests</p>
              <h4 class="fw-bold text-warning">18</h4>
            </div>
            <div class="icon-wrapper">
              <i class="fas fa-comments fa-2x text-warning"></i>
            </div>
          </div>
        </div>
      </div>
    </div>
  </div>
</div>

카드 커스텀 스타일

.summary-card .card {
  border: none;
  box-shadow: 0 0.15rem 1.75rem 0 rgba(58, 59, 69, 0.15);
  transition: all 0.3s ease;
}

.summary-card .card:hover {
  transform: translateY(-5px);
  box-shadow: 0 0.25rem 2rem 0 rgba(58, 59, 69, 0.2);
}

.border-left-success {
  border-left: 4px solid #1cc88a !important;
}

.border-left-info {
  border-left: 4px solid #36b9cc !important;
}

.border-left-warning {
  border-left: 4px solid #f6c23e !important;
}

.icon-wrapper {
  opacity: 0.7;
}

📈 3. 차트 & 태스크 섹션

레이아웃 구조

<div class="container mt-5">
  <div class="row">
    <!-- 차트 영역 -->
    <div class="col-lg-8">
      <div class="card">
        <div class="card-header d-flex justify-content-between align-items-center">
          <h6 class="fw-bold text-primary mb-0">Earnings Overview</h6>
          <div class="dropdown">
            <button class="btn btn-sm btn-outline-secondary dropdown-toggle" type="button" data-bs-toggle="dropdown">
              Monthly
            </button>
            <ul class="dropdown-menu">
              <li><a class="dropdown-item" href="#">Daily</a></li>
              <li><a class="dropdown-item" href="#">Weekly</a></li>
              <li><a class="dropdown-item" href="#">Monthly</a></li>
            </ul>
          </div>
        </div>
        <div class="card-body">
          <canvas id="myChart" width="400" height="200"></canvas>
        </div>
      </div>
    </div>

    <!-- 태스크 리스트 영역 -->
    <div class="col-lg-4">
      <div class="card">
        <div class="card-header">
          <h6 class="fw-bold text-primary mb-0">Tasks</h6>
        </div>
        <div class="card-body">
          <div class="task-item">
            <div class="form-check">
              <input class="form-check-input" type="checkbox" id="task1">
              <label class="form-check-label" for="task1">
                Design new landing page
              </label>
            </div>
            <small class="text-muted">Due: 2024-01-15</small>
          </div>

          <div class="task-item">
            <div class="form-check">
              <input class="form-check-input" type="checkbox" id="task2" checked>
              <label class="form-check-label text-muted" for="task2">
                <s>Update user documentation</s>
              </label>
            </div>
            <small class="text-muted">Completed</small>
          </div>

          <div class="task-item">
            <div class="form-check">
              <input class="form-check-input" type="checkbox" id="task3">
              <label class="form-check-label" for="task3">
                Fix mobile responsive issues
              </label>
            </div>
            <small class="text-danger">Overdue</small>
          </div>
        </div>
      </div>
    </div>
  </div>
</div>

태스크 아이템 스타일

.task-item {
  padding: 12px 0;
  border-bottom: 1px solid #eaecf4;
}

.task-item:last-child {
  border-bottom: none;
}

.task-item .form-check-label {
  font-weight: 500;
  cursor: pointer;
}

.task-item small {
  display: block;
  margin-top: 4px;
}

🎨 4. 슬라이딩 사이드바

HTML 구조

<body>
  <!-- 사이드바 -->
  <div class="sidebar">
    <div class="sidebar-header p-3">
      <h5 class="text-white mb-0">
        <i class="fas fa-tachometer-alt me-2"></i>
        <span class="sidebar-text">Admin</span>
      </h5>
    </div>

    <div class="sidebar-menu">
      <div class="menu-item">
        <i class="fas fa-home"></i>
        <span class="sidebar-text">Dashboard</span>
      </div>
      <div class="menu-item">
        <i class="fas fa-users"></i>
        <span class="sidebar-text">Users</span>
      </div>
      <div class="menu-item">
        <i class="fas fa-chart-bar"></i>
        <span class="sidebar-text">Analytics</span>
      </div>
      <div class="menu-item">
        <i class="fas fa-cog"></i>
        <span class="sidebar-text">Settings</span>
      </div>
    </div>
  </div>

  <!-- 메인 컨텐츠 -->
  <div class="main-content">
    <!-- 여기에 네비게이션과 대시보드 내용 -->
  </div>
</body>

사이드바 스타일 & 애니메이션

.sidebar {
  width: 200px;
  height: 100vh;
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  position: fixed;
  left: 0;
  top: 0;
  z-index: 1000;
  transition: all 0.5s ease;
  transform: translateX(-150px);
  overflow: hidden;
}

.sidebar:hover {
  transform: translateX(0);
}

.sidebar-header {
  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
}

.menu-item {
  padding: 15px 20px;
  color: rgba(255, 255, 255, 0.8);
  cursor: pointer;
  transition: all 0.3s ease;
  display: flex;
  align-items: center;
  border-bottom: 1px solid rgba(255, 255, 255, 0.05);
}

.menu-item:hover {
  background: rgba(255, 255, 255, 0.1);
  color: white;
  padding-left: 30px;
}

.menu-item i {
  width: 20px;
  margin-right: 15px;
  transition: all 0.5s ease;
  transform: translateX(120px);
}

.sidebar:hover .menu-item i {
  transform: translateX(0);
}

.sidebar-text {
  transition: all 0.5s ease;
  opacity: 0;
  transform: translateX(20px);
}

.sidebar:hover .sidebar-text {
  opacity: 1;
  transform: translateX(0);
}

.main-content {
  margin-left: 50px;
  transition: margin-left 0.5s ease;
  min-height: 100vh;
  background: #f8f9fc;
}

.sidebar:hover ~ .main-content {
  margin-left: 200px;
}

🔄 3D Transform 기초

3D 회전축 이해

.demo-box {
  width: 100px;
  height: 100px;
  background: #007bff;
  margin: 50px;
  transition: transform 0.5s ease;
}

/* X축 회전 (가로축 중심) */
.rotate-x:hover {
  transform: rotateX(180deg);
}

/* Y축 회전 (세로축 중심) */
.rotate-y:hover {
  transform: rotateY(180deg);
}

/* Z축 회전 (화면 수직축 중심) */
.rotate-z:hover {
  transform: rotateZ(180deg);
}

/* 복합 회전 */
.rotate-combo:hover {
  transform: rotateX(45deg) rotateY(45deg) rotateZ(45deg);
}

축 설명

• X축 (가로): 좌우로 그어진 가상의 선을 중심으로 회전
• Y축 (세로): 위아래로 그어진 가상의 선을 중심으로 회전
• Z축 (깊이): 화면을 뚫고 나오는 가상의 선을 중심으로 회전

🃏 3D Flip 카드 제작

HTML 구조

<div class="flip-container">
  <div class="flip-outer">
    <div class="flip-inner">
      <div class="front">
        <img src="profile.jpg" alt="Profile">
      </div>
      <div class="back">
        <div class="back-content">
          <h4>개발자 김철용</h4>
          <p>Frontend Developer</p>
          <p>React, Vue, Angular</p>
          <div class="social-links">
            <a href="#"><i class="fab fa-github"></i></a>
            <a href="#"><i class="fab fa-linkedin"></i></a>
            <a href="#"><i class="fab fa-twitter"></i></a>
          </div>
        </div>
      </div>
    </div>
  </div>
</div>

CSS 스타일링

.flip-container {
  perspective: 1000px;
  display: inline-block;
  margin: 20px;
}

.flip-outer {
  width: 300px;
  height: 300px;
}

.flip-inner {
  width: 100%;
  height: 100%;
  position: relative;
  transition: transform 0.8s ease;
  transform-style: preserve-3d;
  cursor: pointer;
}

.flip-inner:hover {
  transform: rotateY(180deg);
}

.front,
.back {
  width: 100%;
  height: 100%;
  position: absolute;
  backface-visibility: hidden;
  border-radius: 15px;
  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
  overflow: hidden;
}

.front {
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  display: flex;
  align-items: center;
  justify-content: center;
}

.front img {
  width: 80%;
  height: 80%;
  object-fit: cover;
  border-radius: 50%;
  border: 5px solid white;
}

.back {
  background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
  transform: rotateY(180deg);
  display: flex;
  align-items: center;
  justify-content: center;
  color: white;
  text-align: center;
}

.back-content h4 {
  font-size: 1.5rem;
  margin-bottom: 10px;
  font-weight: bold;
}

.back-content p {
  margin-bottom: 8px;
  opacity: 0.9;
}

.social-links {
  margin-top: 20px;
}

.social-links a {
  color: white;
  font-size: 1.5rem;
  margin: 0 10px;
  transition: transform 0.3s ease;
}

.social-links a:hover {
  transform: scale(1.2);
}

핵심 속성 설명

transform-style: preserve-3d

• 3D 변환을 자식 요소에도 적용
• 없으면 평면적으로 보임

backface-visibility: hidden

• 뒷면이 보이지 않도록 설정
• 카드 뒤집기 효과의 핵심

perspective

• 3D 효과의 깊이감 설정
• 값이 클수록 멀리서 보는 효과

🎨 고급 3D 효과

다중 카드 그리드

<div class="card-grid">
  <div class="flip-container">
    <div class="flip-outer">
      <div class="flip-inner">
        <div class="front team-card">
          <img src="team1.jpg" alt="Team Member 1">
          <h5>Alice Johnson</h5>
        </div>
        <div class="back">
          <div class="back-content">
            <h4>Alice Johnson</h4>
            <p>UI/UX Designer</p>
            <p>5년 경력</p>
            <p>Figma, Sketch, Adobe XD</p>
          </div>
        </div>
      </div>
    </div>
  </div>

  <!-- 더 많은 카드들... -->
</div>

.card-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 30px;
  padding: 40px;
  max-width: 1200px;
  margin: 0 auto;
}

.team-card {
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  padding: 30px;
  text-align: center;
  color: white;
}

.team-card img {
  width: 120px;
  height: 120px;
  border-radius: 50%;
  margin-bottom: 20px;
  border: 4px solid white;
}

.team-card h5 {
  margin: 0;
  font-weight: 600;
}

호버 시 전체 그리드 효과

.card-grid:hover .flip-container:not(:hover) {
  opacity: 0.7;
  transform: scale(0.95);
}

.flip-container {
  transition: all 0.3s ease;
}

📱 반응형 대응

모바일 최적화

@media (max-width: 768px) {
  .sidebar {
    width: 100%;
    height: auto;
    position: static;
    transform: none;
  }

  .sidebar:hover {
    transform: none;
  }

  .main-content {
    margin-left: 0;
  }

  .flip-outer {
    width: 250px;
    height: 250px;
  }

  .card-grid {
    grid-template-columns: 1fr;
    padding: 20px;
  }

  .input-animation:focus {
    width: 200px;
  }
}

@media (max-width: 480px) {
  .flip-outer {
    width: 200px;
    height: 200px;
  }

  .summary-card .card-body {
    flex-direction: column;
    text-align: center;
  }

  .icon-wrapper {
    margin-top: 15px;
  }
}

💡 실무 팁

성능 최적화

/* GPU 가속 활용 */
.flip-inner {
  will-change: transform;
}

/* 애니메이션 완료 후 will-change 제거 */
.flip-inner.animation-complete {
  will-change: auto;
}

접근성 고려

<!-- 키보드 네비게이션 지원 -->
<div class="flip-inner" tabindex="0" role="button" aria-label="프로필 카드 뒤집기">
  <!-- 카드 내용 -->
</div>

.flip-inner:focus {
  outline: 3px solid #007bff;
  outline-offset: 2px;
}

.flip-inner:focus,
.flip-inner:hover {
  transform: rotateY(180deg);
}

브라우저 호환성

/* 구형 브라우저 대응 */
.flip-inner {
  -webkit-transform-style: preserve-3d;
  -moz-transform-style: preserve-3d;
  transform-style: preserve-3d;

  -webkit-transition: transform 0.8s ease;
  -moz-transition: transform 0.8s ease;
  transition: transform 0.8s ease;
}

.front,
.back {
  -webkit-backface-visibility: hidden;
  -moz-backface-visibility: hidden;
  backface-visibility: hidden;
}

Admin Dashboard와 인상적인 3D Flip 카드를 만들어보았습니다

브라우저 호환성

참고: caniuse.com에서 정확한 호환성 정보 확인 가능

Grid 기본 개념

CSS Grid는 격자(Grid) 기반 레이아웃 시스템으로, 복잡한 2차원 레이아웃을 쉽게 구현할 수 있습니다.

📐 기본 Grid 레이아웃

간단한 Grid 생성

<div class="grid-container">
  <div class="item">1</div>
  <div class="item">2</div>
  <div class="item">3</div>
  <div class="item">4</div>
  <div class="item">5</div>
  <div class="item">6</div>
</div>

.grid-container {
  display: grid;
  grid-template-columns: 1fr 1fr 1fr 1fr;  /* 4개 컬럼 */
  grid-template-rows: 100px 100px 100px;   /* 3개 행 */
  grid-gap: 10px;                         /* 간격 */
  padding: 20px;
}

.item {
  background: #007bff;
  color: white;
  display: flex;
  align-items: center;
  justify-content: center;
  font-size: 1.5rem;
}

Grid 단위 설명

.grid-example {
  display: grid;

  /* 다양한 단위 사용 */
  grid-template-columns: 
    200px          /* 고정 크기 */
    1fr            /* 비율 (1배) */
    2fr            /* 비율 (2배) */
    minmax(100px, 300px)  /* 최소/최대 크기 */
    auto;          /* 내용에 맞춤 */

  /* repeat 함수 사용 */
  grid-template-columns: repeat(4, 1fr);      /* 1fr을 4번 반복 */
  grid-template-columns: repeat(3, 200px);    /* 200px을 3번 반복 */
  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); /* 반응형 */
}

🎯 Grid 레이아웃 방법 1: 아이템 크기 조정

그리드 라인 기반 배치

<div class="layout-container">
  <div class="header">헤더</div>
  <div class="sidebar">사이드바</div>
  <div class="main">메인 컨텐츠</div>
  <div class="footer">푸터</div>
</div>

.layout-container {
  display: grid;
  grid-template-columns: repeat(4, 1fr);
  grid-template-rows: 80px 400px 80px;
  grid-gap: 10px;
  min-height: 100vh;
}

.header {
  grid-column: 1 / 5;  /* 컬럼 1번 라인부터 5번 라인까지 */
  background: #333;
  color: white;
}

.sidebar {
  grid-column: 1 / 2;  /* 컬럼 1번 라인부터 2번 라인까지 */
  grid-row: 2 / 3;     /* 행 2번 라인부터 3번 라인까지 */
  background: #f8f9fa;
}

.main {
  grid-column: 2 / 5;  /* 컬럼 2번 라인부터 5번 라인까지 */
  grid-row: 2 / 3;
  background: white;
  padding: 20px;
}

.footer {
  grid-column: 1 / 5;
  background: #6c757d;
  color: white;
}

그리드 라인 번호 이해

  1   2   3   4   5  ← 세로 라인 번호
1 ┌───┬───┬───┬───┐
  │   │   │   │   │
2 ├───┼───┼───┼───┤
  │   │   │   │   │
3 ├───┼───┼───┼───┤
  │   │   │   │   │
4 └───┴───┴───┴───┘
  ↑ 가로 라인 번호

단축 속성

.item {
  /* 기본 방식 */
  grid-column-start: 1;
  grid-column-end: 3;
  grid-row-start: 1;
  grid-row-end: 2;

  /* 단축 속성 */
  grid-column: 1 / 3;
  grid-row: 1 / 2;

  /* span 키워드 사용 */
  grid-column: span 2;  /* 2칸 차지 */
  grid-row: span 1;     /* 1칸 차지 */
}

🏷️ Grid 레이아웃 방법 2: 영역 이름 지정

Grid Areas 사용

<div class="page-layout">
  <header class="page-header">헤더</header>
  <aside class="page-sidebar">사이드바</aside>
  <main class="page-main">메인 컨텐츠</main>
  <footer class="page-footer">푸터</footer>
</div>

.page-layout {
  display: grid;
  grid-template-columns: 200px 1fr 200px;
  grid-template-rows: 80px 1fr 60px;
  grid-template-areas: 
    "header  header  header"
    "sidebar main    aside"
    "footer  footer  footer";
  min-height: 100vh;
  grid-gap: 10px;
}

.page-header {
  grid-area: header;
  background: #007bff;
  color: white;
}

.page-sidebar {
  grid-area: sidebar;
  background: #f8f9fa;
}

.page-main {
  grid-area: main;
  background: white;
  padding: 20px;
}

.page-footer {
  grid-area: footer;
  background: #6c757d;
  color: white;
}

빈 공간 표시

.grid-with-gaps {
  grid-template-areas: 
    "header header header header"
    "sidebar main main ."        /* . = 빈 공간 */
    "sidebar main main ."
    "footer footer footer footer";
}

📱 반응형 Grid 레이아웃

기본 반응형 패턴

.responsive-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
  grid-gap: 20px;
  padding: 20px;
}

/* 수동 반응형 */
@media (max-width: 768px) {
  .page-layout {
    grid-template-columns: 1fr;
    grid-template-areas: 
      "header"
      "main"
      "sidebar"
      "footer";
  }
}

@media (min-width: 769px) and (max-width: 1024px) {
  .page-layout {
    grid-template-columns: 150px 1fr;
    grid-template-areas: 
      "header header"
      "sidebar main"
      "footer footer";
  }
}

🖼️ 실전 예제: 이미지 갤러리

HTML 구조

<div class="gallery-grid">
  <div class="gallery-item featured">
    <img src="https://picsum.photos/600/400?random=1" alt="Featured Image">
  </div>
  <div class="gallery-item">
    <img src="https://picsum.photos/300/300?random=2" alt="Image 2">
  </div>
  <div class="gallery-item">
    <img src="https://picsum.photos/300/300?random=3" alt="Image 3">
  </div>
  <div class="gallery-item">
    <img src="https://picsum.photos/300/300?random=4" alt="Image 4">
  </div>
  <div class="gallery-item">
    <img src="https://picsum.photos/300/300?random=5" alt="Image 5">
  </div>
  <div class="gallery-item">
    <img src="https://picsum.photos/300/300?random=6" alt="Image 6">
  </div>
</div>

CSS 스타일

.gallery-grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-auto-rows: 200px;
  grid-gap: 15px;
  max-width: 800px;
  margin: 0 auto;
  padding: 20px;
}

.gallery-item {
  background: #f8f9fa;
  border-radius: 8px;
  overflow: hidden;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
  transition: transform 0.3s ease;
}

.gallery-item:hover {
  transform: translateY(-5px);
}

.gallery-item img {
  width: 100%;
  height: 100%;
  object-fit: cover;
  display: block;
}

/* 첫 번째 이미지를 2x2로 확대 */
.gallery-item.featured {
  grid-column: 1 / 3;
  grid-row: 1 / 3;
}

/* 반응형 */
@media (max-width: 768px) {
  .gallery-grid {
    grid-template-columns: 1fr;
    grid-auto-rows: 250px;
  }

  .gallery-item.featured {
    grid-column: 1 / 2;
    grid-row: 1 / 2;
  }
}

@media (min-width: 769px) and (max-width: 1024px) {
  .gallery-grid {
    grid-template-columns: repeat(2, 1fr);
  }

  .gallery-item.featured {
    grid-column: 1 / 3;
    grid-row: 1 / 2;
  }
}

🏢 실전 예제: 블로그 레이아웃

<div class="blog-layout">
  <header class="blog-header">
    <h1>My Blog</h1>
    <nav>Navigation Menu</nav>
  </header>
  <aside class="blog-sidebar">
    <h3>Sidebar</h3>
    <ul>
      <li>Recent Posts</li>
      <li>Categories</li>
      <li>Archives</li>
    </ul>
  </aside>
  <main class="blog-content">
    <article>
      <h2>Blog Post Title</h2>
      <p>Blog post content goes here...</p>
    </article>
  </main>
  <footer class="blog-footer">
    <p>&copy; 2024 My Blog. All rights reserved.</p>
  </footer>
</div>

.blog-layout {
  display: grid;
  grid-template-columns: 250px 1fr;
  grid-template-rows: auto 1fr auto;
  grid-template-areas: 
    "header header"
    "sidebar content"
    "footer footer";
  min-height: 100vh;
  grid-gap: 20px;
  padding: 20px;
}

.blog-header {
  grid-area: header;
  background: #343a40;
  color: white;
  padding: 20px;
  border-radius: 8px;
}

.blog-sidebar {
  grid-area: sidebar;
  background: #f8f9fa;
  padding: 20px;
  border-radius: 8px;
}

.blog-content {
  grid-area: content;
  background: white;
  padding: 30px;
  border-radius: 8px;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.blog-footer {
  grid-area: footer;
  background: #6c757d;
  color: white;
  padding: 15px;
  border-radius: 8px;
  text-align: center;
}

/* 태블릿 */
@media (max-width: 1024px) {
  .blog-layout {
    grid-template-columns: 200px 1fr;
  }
}

/* 모바일 */
@media (max-width: 768px) {
  .blog-layout {
    grid-template-columns: 1fr;
    grid-template-areas: 
      "header"
      "content"
      "sidebar"
      "footer";
  }
}

📌 Position Sticky

기본 개념

position: sticky는 스크롤 기반 고정 요소를 만드는 속성입니다.

브라우저 지원

기본 사용법

<body style="height: 3000px; background: #f0f0f0;">
  <div class="content-section">
    <div class="sticky-sidebar">
      <img src="product.jpg" alt="Product Image">
    </div>
    <div class="main-text">
      <h2>Product Description</h2>
      <p>Long product description that requires scrolling...</p>
      <!-- 많은 텍스트 내용 -->
    </div>
  </div>
</body>

.content-section {
  background: white;
  max-width: 1200px;
  margin: 100px auto;
  padding: 40px;
  display: flex;
  gap: 40px;
  min-height: 2000px; /* 스크롤 가능하도록 */
}

.sticky-sidebar {
  flex: 0 0 400px;
  position: sticky;
  top: 20px;          /* viewport 상단에서 20px 위치에 고정 */
  height: fit-content;
}

.sticky-sidebar img {
  width: 100%;
  border-radius: 8px;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
}

.main-text {
  flex: 1;
  line-height: 1.8;
}

Sticky 동작 원리

1. 일반 상태: 요소가 원래 위치에 있음
2. 스크롤 시: 지정된 위치(top, bottom 등)에 도달하면 고정
3. 부모 범위: 부모 요소를 벗어나면 다시 일반 요소로 동작

고급 Sticky 예제

네비게이션 메뉴

<header class="main-header">
  <h1>Website Header</h1>
</header>

<nav class="sticky-nav">
  <ul>
    <li><a href="#home">Home</a></li>
    <li><a href="#about">About</a></li>
    <li><a href="#services">Services</a></li>
    <li><a href="#contact">Contact</a></li>
  </ul>
</nav>

<main class="main-content">
  <!-- 페이지 내용 -->
</main>

.main-header {
  background: #343a40;
  color: white;
  padding: 60px 20px;
  text-align: center;
}

.sticky-nav {
  position: sticky;
  top: 0;
  background: white;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
  z-index: 100;
}

.sticky-nav ul {
  display: flex;
  list-style: none;
  margin: 0;
  padding: 0;
  max-width: 1200px;
  margin: 0 auto;
}

.sticky-nav li {
  flex: 1;
}

.sticky-nav a {
  display: block;
  padding: 20px;
  text-decoration: none;
  color: #333;
  text-align: center;
  transition: background 0.3s ease;
}

.sticky-nav a:hover {
  background: #f8f9fa;
}

.main-content {
  max-width: 1200px;
  margin: 0 auto;
  padding: 40px 20px;
  min-height: 2000px;
}

사이드바 목차

<div class="article-layout">
  <aside class="table-of-contents">
    <h3>목차</h3>
    <ul>
      <li><a href="#section1">섹션 1</a></li>
      <li><a href="#section2">섹션 2</a></li>
      <li><a href="#section3">섹션 3</a></li>
      <li><a href="#section4">섹션 4</a></li>
    </ul>
  </aside>

  <article class="article-content">
    <section id="section1">
      <h2>섹션 1</h2>
      <p>섹션 1의 내용...</p>
    </section>
    <!-- 더 많은 섹션들 -->
  </article>
</div>

.article-layout {
  display: grid;
  grid-template-columns: 250px 1fr;
  gap: 40px;
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
}

.table-of-contents {
  position: sticky;
  top: 20px;
  height: fit-content;
  background: #f8f9fa;
  padding: 20px;
  border-radius: 8px;
  border: 1px solid #e9ecef;
}

.table-of-contents h3 {
  margin-top: 0;
  color: #495057;
}

.table-of-contents ul {
  list-style: none;
  padding: 0;
}

.table-of-contents li {
  margin-bottom: 8px;
}

.table-of-contents a {
  color: #007bff;
  text-decoration: none;
  padding: 8px 0;
  display: block;
  border-radius: 4px;
  padding-left: 12px;
  transition: all 0.3s ease;
}

.table-of-contents a:hover {
  background: #e9ecef;
  color: #0056b3;
}

.article-content {
  line-height: 1.8;
}

.article-content section {
  margin-bottom: 60px;
  min-height: 600px;
}

@media (max-width: 768px) {
  .article-layout {
    grid-template-columns: 1fr;
  }

  .table-of-contents {
    position: static;
    order: -1;
  }
}

🎯 Grid vs Flexbox 비교

언제 Grid를 사용할까?

/* Grid가 적합한 경우 */
.grid-suitable {
  /* 2차원 레이아웃 (행과 열 모두 제어) */
  display: grid;
  grid-template-areas: 
    "header header header"
    "sidebar main aside"
    "footer footer footer";
}

/* Flexbox가 적합한 경우 */
.flex-suitable {
  /* 1차원 레이아웃 (한 방향만 제어) */
  display: flex;
  justify-content: space-between;
  align-items: center;
}

특징 비교

💡 실무 팁

Grid 네이밍 규칙

.layout-grid {
  grid-template-areas: 
    "header header header"
    "nav main aside"
    "footer footer footer";
}

/* 명확한 이름 사용 */
.page-header { grid-area: header; }
.page-nav { grid-area: nav; }
.page-main { grid-area: main; }
.page-aside { grid-area: aside; }
.page-footer { grid-area: footer; }

성능 최적화

/* 불필요한 재계산 방지 */
.grid-container {
  contain: layout style;
}

/* 이미지 최적화 */
.grid-item img {
  object-fit: cover;
  width: 100%;
  height: 100%;
}

접근성 고려

/* 스크린 리더를 위한 순서 유지 */
.accessible-grid {
  display: grid;
  grid-template-areas: 
    "header"
    "main"
    "sidebar"
    "footer";
}

@media (min-width: 768px) {
  .accessible-grid {
    grid-template-areas: 
      "header header"
      "sidebar main"
      "footer footer";
  }
}

CSS Grid와 Position Sticky을 활용하여 반응형인 웹 레이아웃을 구현할 수 있습니다

기본 비디오 삽입

<video>
  <source src="video/sample.mp4" type="video/mp4">
  <source src="video/sample.webm" type="video/webm">
  <source src="video/sample.ogg" type="video/ogg">
  브라우저가 비디오를 지원하지 않습니다.
</video>

멀티 포맷 지원: 여러 형식을 제공하면 브라우저가 최적화된 포맷을 자동 선택

비디오 속성

<video 
  autoplay 
  muted 
  loop 
  controls
  poster="thumbnail.jpg" 
  preload="metadata"
  width="800" 
  height="450"
>
  <source src="video.mp4" type="video/mp4">
</video>

Preload 옵션

<!-- 전체 비디오 미리 다운로드 -->
<video preload="auto">
  <source src="video.mp4">
</video>

<!-- 메타데이터만 미리 로드 (권장) -->
<video preload="metadata">
  <source src="video.mp4">
</video>

<!-- 사용자가 재생할 때까지 로드하지 않음 -->
<video preload="none">
  <source src="video.mp4">
</video>

📺 배경 비디오 구현

HTML 구조

<div class="video-box">
  <video class="video-container" autoplay muted loop>
    <source src="video/background.mp4" type="video/mp4">
    <source src="video/background.webm" type="video/webm">
  </video>
  <div class="video-content">
    <h1>Welcome to Our Site</h1>
    <p>Amazing content over video background</p>
    <button class="cta-button">Get Started</button>
  </div>
</div>

CSS 스타일링

.video-box {
  position: relative;
  height: 100vh;
  width: 100%;
  overflow: hidden;
  display: flex;
  align-items: center;
  justify-content: center;
}

.video-container {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  min-width: 100%;
  min-height: 100%;
  width: auto;
  height: auto;
  z-index: -1;
  background-size: cover;
}

.video-content {
  position: relative;
  z-index: 1;
  text-align: center;
  color: white;
  text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
}

.video-content h1 {
  font-size: 3rem;
  margin-bottom: 1rem;
}

.video-content p {
  font-size: 1.2rem;
  margin-bottom: 2rem;
}

.cta-button {
  padding: 15px 30px;
  font-size: 1.1rem;
  background: rgba(255, 255, 255, 0.2);
  color: white;
  border: 2px solid white;
  border-radius: 5px;
  cursor: pointer;
  transition: all 0.3s ease;
}

.cta-button:hover {
  background: white;
  color: #333;
}

반응형 배경 비디오

@media (max-width: 768px) {
  .video-container {
    /* 모바일에서는 이미지로 대체 */
    display: none;
  }

  .video-box {
    background-image: url('video-poster.jpg');
    background-size: cover;
    background-position: center;
  }

  .video-content h1 {
    font-size: 2rem;
  }
}

🎨 Transform 속성

기본 Transform 속성들

.transform-demo {
  /* 회전 */
  transform: rotate(45deg);

  /* 이동 */
  transform: translate(50px, 100px);
  transform: translateX(50px);
  transform: translateY(100px);

  /* 크기 조절 */
  transform: scale(1.5);
  transform: scaleX(2);
  transform: scaleY(0.5);

  /* 비틀기 */
  transform: skew(15deg, 5deg);
  transform: skewX(15deg);
  transform: skewY(5deg);

  /* 여러 속성 조합 */
  transform: rotate(45deg) scale(1.2) translateX(20px);
}

Transform의 장점

/* 나쁜 예: 레이아웃 재계산 발생 */
.bad-animation {
  transition: margin-left 0.3s;
}
.bad-animation:hover {
  margin-left: 100px; /* 레이아웃 재계산 */
}

/* 좋은 예: GPU 가속 사용 */
.good-animation {
  transition: transform 0.3s;
}
.good-animation:hover {
  transform: translateX(100px); /* 효율적 */
}

🎬 Keyframes 애니메이션

기본 문법

/* 1. 키프레임 정의 */
@keyframes slideIn {
  0% {
    transform: translateX(-100px);
    opacity: 0;
  }
  50% {
    transform: translateX(20px);
    opacity: 0.8;
  }
  100% {
    transform: translateX(0);
    opacity: 1;
  }
}

/* 2. 애니메이션 적용 */
.slide-element {
  animation: slideIn 0.8s ease-out;
}

Animation 속성 상세

.complex-animation {
  animation-name: myAnimation;           /* 키프레임 이름 */
  animation-duration: 2s;                /* 지속 시간 */
  animation-timing-function: ease-in-out; /* 타이밍 함수 */
  animation-delay: 0.5s;                 /* 시작 지연 */
  animation-iteration-count: 3;          /* 반복 횟수 */
  animation-direction: alternate;        /* 방향 */
  animation-fill-mode: forwards;         /* 종료 후 상태 */
  animation-play-state: running;         /* 재생/일시정지 */

  /* 축약형 */
  animation: myAnimation 2s ease-in-out 0.5s 3 alternate forwards;
}

Animation Fill Mode

/* 애니메이션 종료 후 원래 상태로 복귀 (기본값) */
.animation-none {
  animation-fill-mode: none;
}

/* 애니메이션 종료 후 마지막 상태 유지 */
.animation-forwards {
  animation-fill-mode: forwards;
}

/* 애니메이션 시작 전 첫 번째 상태 적용 */
.animation-backwards {
  animation-fill-mode: backwards;
}

/* 시작 전과 종료 후 모두 적용 */
.animation-both {
  animation-fill-mode: both;
}

🚀 실전 애니메이션 예제

1. 흔들리는 버튼

.shake-button {
  padding: 15px 30px;
  font-size: 18px;
  background: #007bff;
  color: white;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  transition: transform 0.3s ease;
}

.shake-button:hover {
  animation: shake 0.6s ease-in-out;
}

@keyframes shake {
  0%, 100% { 
    transform: rotate(0deg); 
  }
  25% { 
    transform: rotate(-5deg); 
  }
  50% { 
    transform: rotate(5deg); 
  }
  75% { 
    transform: rotate(-5deg); 
  }
}

2. 회전하는 플러스 버튼

.plus-button {
  font-size: 48px;
  color: #333;
  cursor: pointer;
  display: inline-block;
  transition: transform 0.3s ease;
}

.plus-button:hover {
  animation: rotatePlus 0.8s ease-out forwards;
}

@keyframes rotatePlus {
  0% { 
    transform: rotate(0deg) scale(1); 
  }
  25% { 
    transform: rotate(-15deg) scale(1.1); 
  }
  100% { 
    transform: rotate(45deg) scale(1.3); 
  }
}

3. 슬라이딩 메뉴

<nav class="sliding-menu">
  <h4>Menu</h4>
  <p class="menu-item">Home</p>
  <p class="menu-item">About</p>
  <p class="menu-item">Contact</p>
</nav>

.sliding-menu {
  position: fixed;
  left: 0;
  top: 0;
  width: 250px;
  height: 100vh;
  background: #333;
  color: white;
  padding: 30px 20px;
  transform: translateX(-200px);
  transition: all 0.5s ease;
  z-index: 1000;
}

.sliding-menu:hover {
  transform: translateX(0);
}

.sliding-menu h4 {
  text-align: right;
  transition: text-align 0.5s ease;
}

.sliding-menu:hover h4 {
  text-align: center;
}

.menu-item {
  cursor: pointer;
  padding: 10px 0;
  transition: all 0.3s ease;
}

.sliding-menu:hover .menu-item {
  animation: slideText 0.8s ease-out;
}

@keyframes slideText {
  0% { 
    transform: translateX(-100px); 
    opacity: 0;
  }
  50% { 
    transform: translateX(30px) skewX(-20deg); 
    opacity: 0.7;
  }
  100% { 
    transform: translateX(0) skewX(0deg); 
    opacity: 1;
  }
}

4. 페이드 인 카드 애니메이션

.card {
  background: white;
  border-radius: 10px;
  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
  padding: 20px;
  margin: 20px;
  opacity: 0;
  transform: translateY(50px);
  animation: fadeInUp 0.6s ease-out forwards;
}

.card:nth-child(2) { animation-delay: 0.2s; }
.card:nth-child(3) { animation-delay: 0.4s; }
.card:nth-child(4) { animation-delay: 0.6s; }

@keyframes fadeInUp {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

5. 로딩 스피너

.loader {
  width: 50px;
  height: 50px;
  border: 4px solid #f3f3f3;
  border-top: 4px solid #007bff;
  border-radius: 50%;
  animation: spin 1s linear infinite;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

6. 펄스 효과

.pulse-button {
  position: relative;
  padding: 15px 30px;
  background: #ff6b6b;
  color: white;
  border: none;
  border-radius: 50px;
  cursor: pointer;
}

.pulse-button::before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  border-radius: 50px;
  background: #ff6b6b;
  animation: pulse 2s infinite;
  z-index: -1;
}

@keyframes pulse {
  0% {
    transform: scale(1);
    opacity: 1;
  }
  100% {
    transform: scale(1.3);
    opacity: 0;
  }
}

⚡ 성능 최적화

Will-Change 속성

/* 애니메이션 성능 향상 */
.animated-element {
  will-change: transform;
}

/* 애니메이션 완료 후 제거 */
.animated-element.animation-complete {
  will-change: auto;
}

GPU 가속 활용

.gpu-accelerated {
  /* 3D 변환으로 GPU 가속 활성화 */
  transform: translate3d(0, 0, 0);

  /* 또는 */
  transform: translateZ(0);

  /* 더 명시적인 방법 */
  will-change: transform;
  transform: translate3d(0, 0, 0);
}

효율적인 애니메이션 속성

/* 권장: 레이아웃에 영향 없는 속성들 */
.efficient-animation {
  transition: transform 0.3s, opacity 0.3s;
}

/* 비권장: 레이아웃 재계산 발생 */
.inefficient-animation {
  transition: width 0.3s, height 0.3s, margin 0.3s;
}

🎯 반응형 애니메이션

미디어 쿼리와 애니메이션

/* 데스크톱 애니메이션 */
@media (min-width: 768px) {
  .desktop-animation {
    animation: complexAnimation 2s ease-in-out;
  }
}

/* 모바일에서는 단순한 애니메이션 */
@media (max-width: 767px) {
  .desktop-animation {
    animation: simpleAnimation 1s ease-out;
  }
}

/* 사용자가 애니메이션을 원하지 않는 경우 */
@media (prefers-reduced-motion: reduce) {
  * {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}

💡 실무 팁

애니메이션 디버깅

/* 개발 중 애니메이션 슬로우 모션 */
* {
  animation-duration: 10s !important;
}

/* 특정 요소만 슬로우 모션 */
.debug-animation {
  animation-duration: 5s !important;
}

재사용 가능한 애니메이션 클래스

/* 유틸리티 애니메이션 클래스 */
.fade-in {
  animation: fadeIn 0.5s ease-out forwards;
}

.slide-up {
  animation: slideUp 0.6s ease-out forwards;
}

.bounce-in {
  animation: bounceIn 0.8s ease-out forwards;
}

@keyframes fadeIn {
  from { opacity: 0; }
  to { opacity: 1; }
}

@keyframes slideUp {
  from { 
    transform: translateY(30px); 
    opacity: 0; 
  }
  to { 
    transform: translateY(0); 
    opacity: 1; 
  }
}

@keyframes bounceIn {
  0% { 
    transform: scale(0.3); 
    opacity: 0; 
  }
  50% { 
    transform: scale(1.05); 
    opacity: 0.8; 
  }
  70% { 
    transform: scale(0.9); 
    opacity: 0.9; 
  }
  100% { 
    transform: scale(1); 
    opacity: 1; 
  }
}

HTML 비디오 삽입부터 고급 CSS 애니메이션까지 정리해보았습니다.