Divide 큰 문제를 작은 문제로 쪼개는 것

Conquer 작은 문제들을 다시 합치는 것

Top-down approach : divide -> conquer -> combine

시간복잡도 time complexity :

2. 예시1: binary search (tree)

정렬된 배열에서는 최악의 경우에도 optimal algorithm!

1) code

2)

1) equalization 이란?

자동으로 대비가 향상되게 함(균등 분배!) CDF 값만 있으면 가능!

Equaliztion의 목표

• 최대한 균등하게 분포시킴
• 입력에서 같은 intensity 값을 가진 픽셀들은 동일한 출력 intensity로 변환되어야 함

2) Equalization의 수학계산

s: 결과 이미지의 intensity 중간에 적분이 들어가는데 이 사진에서는 생략됨

3) 문제점: wash out

input의 histogram이 너무 편향적일 경우(너무 어둡거나 밝은 부분만 존재) equalization은 무조건 균등분포를 목표로 하기 때문에 모든 밝기 값을 비슷한 비율로 강제 배분을 함 -> 기존의 밝기 구조나 분포를 전혀 고려하지 않은 결과값이 나옴: wash out

2. Histogram Matching

이 이미지의 톤을 저 이미지처럼 바꿔줘!

1) 계산 방법

1. 입력 이미지를 equalization
2. 참조 이미지를 equalization
3. 역변환!

• Before -> After

3. color 이미지에서의 equalization, matching 방법

1. 색을 RGB로 분리
2. RGB -> YIQ 로 변환 Y: 밝기 / I: 색상, Q: 채도
3. 밝기Y만 equalization matching 수행
4. YIQ -> RGB로 다시 변환
5. RGB를 합쳐서 output 출력!

픽셀 값의 범위를 늘려 이미지의 대비를 향상시킴

계산방법

• x = 원래 intensity
• y = 결과 intensity
• a(i~i+1) : 입력 image에서 intensity 구간
• b(i~i+1) : 결과 image에서 mapping 구간
• before vs after

2. gamma correction 감마 보정

픽셀의 밝기를 어두운 건 더 어둡거나 밝게, 밝은 건 더 밝거나 어둡게

1) 계산법

계산공식

• x = 원래 intensity
• y = 감마 값
• a,b : 입력 범위
• c,d : 결과 범위
• Before -> After

2) gamma<1 vs gamma>1

• gamma<1: 어두운 픽셀을 밝게!
• gamma>1: 밝은 픽셀을 어둡게!

각 intensity가 얼마나 많이 등장하였는지 나타내는 것 이를 통해

• 얼마나 어둡고 밝은지?
• 이미지의 대비 정도

를 알 수 있다.

전체 면적=전체 픽셀 수 이다.

예시그림: 블랙과 회색이 많은 그림 -> 어두운 부분과 중간 부분에 peak 가 보인다.

2. histogram vs PDF

PDF: 확률밀도함수: histogram을 정규화한것 : 각 intensity가 등장할 확률을 나타냄 전체 면적 = 1 이다.

3. PDF vs CDF

CDF: 누적 분포 함수: 어떤 값 x 이하가 나올 확률: 지금까지의 확률들을 누적한 값

PDF, CDF 계산 방법 -> CDF에서는 필요시 적분 해야함

1) add, substract

덧셈: 이미지를 더 밝게 , F(i)=i+128 뺄셈: 이미지를 더 어둡게 , F(i)=i-128

2) complements 보수 => 색반전

double 타입: 0.0-1.0 : 1-m unsigned char타입: 0-255 : 255-m

1. Amortized Analysis

Potential method

배열에 push를 하는데, 배열이 꽉차면 그 배열의 크기를 늘리면서 복사를 해야하기 때문에 갑자기 큰 비용이 발생함 그래서 potential(잠재에너지)개념이 등장 매번 push를 할 때 잠재 에너지에 1씩 저장함 -> 나중에 배열이 꽉차면 잠재에너지로 배열크기를 늘리고(복사) 계속해서 push를 하면 됨 -> 갑자기 큰 비용이 발생하지 않음

Amortized Cost = Actual Cost + Φ(D i) − Φ(D i−1) 잠재비용 = 실제 비용 + 잠재변화량

2. Space complexity

저장 공간(Storage space)에 들어가야 할 것들

• 명령어(Instructions)
• 상수, 간단한 변수(constants, simple variables)
• 입력 데이터와 추가 작업 공간(데이터 구조 포함)

입력데이터의 저장 형태

• 배열, 그래프 등등
• 배열로 저장되면, 추가 작업 공간만 분석하면 됨
• 그래프와 같은 형태의 경우, 입력되어있는 데이터와 추가작업공간 모두 분석해놔야함

분석 방법

• 최악의 경우 공간 분석(Worst-case space analysis) 최악의 입력이 들어왔을 때 알고리즘이 사용하는 최대 메모리 양
• 평균적인 경우 공간 분석(Average-case space analysis) 모든 가능한 입력에 대해 알고리즘이 사용하는 평균적인 메모리 양

• FoV: it depends on 'sensor size' and 'lens focal length'
• lens focal length(=f): the distance between lens and sensor
• CCD sensor size:
  • pixel size * pixel 개수
  • image quality depends on the CCD sensor size!
• Pixel number:
  • 일정 이상(1000 * 1000정도)가 되면 image quality에 큰 영향X
  • no matter how many pixels you are quantizing, the sensor size and the quality of image is almost same
  • 너무 줄여버리면 aliasing artifacts 발생

이 시리즈는 대학교 수업에서 진행하는 내용을 요약한 것입니다.

1. About computer vision

a field that includes methods for acquiring processing analyzing understanding images, as the human being does all techniques for enabling a computer to see a real-world using images

images is stored as RGB data in computer

2. low~high level computer vision

1) low level computer vision

• image enhancement, restoration
• image filtering
• computational photography(HDR image)
• image registration(alignment) -> Structure From Motion

• computer vision technique used to create 3D models of an object or scene from a series of 2D images taken from different viewpoints

  2) Middle-level computer vision

• image segmentation(here is background, here is human body~)
• contour detection

• contour is differnt from 'edge'

• edge: point in an image where the pixel value (like brightness or color) changes sharply.

• contour: A curve or a closed shape that connects all points along a boundary with the same color or intensity

• image descriptor
• 3D reconstruction

3) High-level computer vision

• object classification/recognition
• object localization
• visual question and answering
• scene understanding

• find: 모두 조회
• findOne: 하나만
• sort:정렬
• limit: 조회할 다큐먼츠 제한
• skip: 건너뛸 다큐먼츠 정함

2. mongodb 연결

const mongoose = require('mongoose');
const connect = () => {
    //배포 전(개발중)일때는 debug 하도록
    if (process.env.NODE_ENV !== 'production') {
        mongoose.set('debug', true);
    }
    mongoose.connect('mongodb://root:nodejsbook@localhost:27017/adming'), {
        dbName: 'nodejs',
        useNewUrlParser: true,
        useCreateIndex:true
    }, (error) => {
        if (error) {
            console.log('mongodb error');
        }
        else {
            console.log('mongodb connect');
        }
    }
}
mongoose.connection.on('error', (error) => {
  console.error('몽고디비 연결 에러', error);
});
mongoose.connection.on('disconnected', () => {
  console.error('몽고디비 연결이 끊겼습니다. 연결을 재시도합니다.');
  connect();
});

module.exports = connect;

3. mongodb 스키마 정의

type:자료형 require: 필수 여부 default: 기본값 unique: 고유여부 ref: 특정 컬랙션의 문서와 연결할 수 있음

const mongoose = require('mongoose');

const { Schema } = mongoose;
const { Types: { ObjectId } } = Schema;
//ref: 'User': 이 ID는 User 컬렉션의 문서와 연결 
// populate를 사용하면 댓글 작성자의 정보를 가져올 수 있음
const commentSchema = new Schema({
  commenter: {
    type: ObjectId,
    required: true,
    ref: 'User',
  },
  comment: {
    type: String,
    required: true,
  },
  createdAt: {
    type: Date,
    default: Date.now,
  },
});

module.exports = mongoose.model('Comment', commentSchema);

1. 데이터 베이스: MYSQL

데이터를 영구적으로 저장 MySQL: 관계형 데이터베이스

• 관련성을 가지며 중복이 없는 데이터들의 집합
• 여러 사람이 동시에 접근할 수 있고 권한을 따로 줄 수 있음
• 다운 받는 주소: https://downloads.mysql.com/archives/installer/
• MySQL cmd에서 작동시키기: "C:\Program Files\MySQL\MySQL Server 8.0\bin" C:\Program Files\MySQL\MySQL Server 8.0\bin>mysql -h localhost -u root -p

2. 시퀄라이즈

1) 기본 조작

js로 sql 조작할 수 있게 하는 도구

초기 터미널 설치 npm i express morgan nunjucks sequelize sequelize-cli mysql2 npm i -D nodemon npx sequelize init : 시퀄라이즈 구조 초기화

config 파일에 password 부분을 본인 password로 변경하기

"development": {
    "username": "root",
    "password": "이부분!!!",
    "database": "database_development",
    "host": "127.0.0.1",
    "dialect": "mysql"
  }

데이터베이스 연결

sequelize.sync({ force: false })
  .then(() => {
    console.log('데이터베이스 연결 성공');
  })
  .catch((err) => {
    console.error(err);
  });

2) 모델 만들기

테이블 관계

• 1:N 관계:
  • 시퀄라이즈에서는 hasMany, belongsTo로 표현
  • belongsTo가 있는 테이블에 컬럼이 생김
• 1:1관계:
  • hasOne, belongsTo 로 표현

코드예제: 모델 만드는 방법 + 테이블 관계 알아보자

//models/user.js
const Sequelize = require('sequelize');

class User extends Sequelize.Model {
  static initiate(sequelize) {
    User.init({
      name: {
        type: Sequelize.STRING(20),
        allowNull: false, //notnull
        unique: true,
      },
      age: {
        type: Sequelize.INTEGER.UNSIGNED,
        allowNull: false,
      },
      married: {
        type: Sequelize.BOOLEAN,
        allowNull: false,
      },
      comment: {
        type: Sequelize.TEXT,
        allowNull: true,
      },
      created_at: {
        type: Sequelize.DATE,
        allowNull: false,
        defaultValue: Sequelize.NOW,
      },
    }, {
      sequelize,
      timestamps: false,
      underscored: false,
      modelName: 'User',
      tableName: 'users',
      paranoid: false,
      charset: 'utf8',
      collate: 'utf8_general_ci',
    });
  }

  static associate(db) {
    db.User.hasMany(db.Comment, { foreignKey: 'commenter', sourceKey: 'id' });
  }
};

module.exports = User;

comment.js에서는 hasMany가 아닌 belongsTo가 쓰인다.

//models.comment.js
static associate(db) {
    db.Comment.belongsTo(db.User, { foreignKey: 'commenter', targetKey: 'id' });
}

1) 분리하는 방법

보통 routes 폴더 안에 여러 route 파일들을 두는 구조를 이용

//위치: routes/user.js
const express = require('express');
const router = express.Router();
//GET / 라우터
router.get('/', (req, res) => {
    //GET /user/
    res.send('hello user');
});

module.exports = router;

// app.js
const indexRouter = require('./routes');
const userRouter = require('./routes/user');

app.use('/', indexRouter);
app.use('/user', userRouter);

4. req, res 에 대하여

1) req

req는 클라이언트가 서버로 보낸 HTTP 요청에 대한 정보를 담고 있음

• req.app: req 객체를 통해 app 객체에 접근, req.app.get('port')와 같은 식으로 사용
• req.body: body-parser 미들웨어가 만드는 요청의 본문을 해석한 객체
• req.cookies: cookie-parser 미들웨어가 만드는 요청의 쿠키를 해석한 객체
• req.ip: 요청의 ip 주소가 담겨 있음
• req.params: 라우트 매개변수에 대한 정보가 담긴 객체
• req.query: 쿼리스트링에 대한 정보가 담긴 객체
• req.signedCookies: 서명된 쿠키들은 req.cookies 대신 여기에 담겨 있음
• req.get(헤더 이름): 헤더의 값을 가져오고 싶을 때 사용하는 메서드

2) res

res는 서버가 클라이언트에게 응답을 보낼 때 사용하는 객체

• res.app: req.app처럼 res 객체를 통해 app 객체에 접근
• res.cookie(키, 값, 옵션): 쿠키를 설정하는 메서드
• res.clearCookie(키, 값, 옵션): 쿠키를 제거하는 메서드
• res.end(): 데이터 없이 응답을 보냄
• res.json(JSON): JSON 형식의 응답을 보냄
• res.redirect(주소): 리다이렉트할 주소와 함께 응답을 보냄
• res.render(뷰, 데이터): 다음 절에서 다룰 템플릿 엔진을 렌더링해서 응답할 때 사용하는 메서드
• res.send(데이터): 데이터와 함께 응답을 보냄. 데이터는 문자열, HTML, 버퍼,객체나 배열 다 가능
• res.sendFile(경로): 경로에 위치한 파일을 응답
• res.set(헤더, 값): 응답의 헤더를 설정
• res.status(코드): 응답 시의 HTTP 상태 코드를 지정

5. pug 템플릿 엔진

템플릿 엔진: HTML의 단점을 개선

• 반복문 조건문 변수 등을 사용할 수 있음
• 동적인 페이지 작성 가능
• PHP, JSP 와 유사
• 대표적으로 pug가 있음

Pug

• 태그를 닫을 필요 X
• 들여쓰기로 표현
• css 처럼 표현 가능! <div class="jade"></div> => .jade로 표현!

보통 views 폴더 안에 pug 파일들을 위치시킴 npm i pug: 설치

코드 예제

//app.js -> pug 템플릿 설정해줘야함 
app.set('views', path.join(__dirname, 'views')); // 템플릿 파일 위치
app.set('view engine', 'pug');                   // Pug를 템플릿 엔진으로 설정

//views/layout.pug
doctype html
html
  head
    title= title
    link(rel='stylesheet', href='/style.css')
  body
    block content

//views/index.pug
extends layout
block content
  h1= title
  p Welcome to #{title}

//views/error.pug
extends layout
block content
  h1= message
  h2= error.status
  pre #{error.stack}

6. nonjucks 템플릿 엔진

pug 가 익숙해지지 않으면 nonjucks! 확장자는 html로 함

코드예제

//app.js
const nunjucks = require('nunjucks');
app.set('view engine', 'html');
nunjucks.configure('views', {
  express: app,
  watch: true,
});

//views/layout.html
<!DOCTYPE html>
<html>
  <head>
    <title>{{title}}</title>
    <link rel="stylesheet" href="/style.css" />
  </head>
  <body>
    {% block content %}
    {% endblock %}
  </body>
</html>

//views/error.html
{% extends 'layout.html' %}
<h1><%= message %></h1>
<h2><%= error.status %></h2>
<pre><%= error.stack %></pre>

//views/index.html
{% extends 'layout.html' %}
{% block content %}
<h1>{{title}}</h1>
<p>Welcome to {{title}}</p>
{% endblock %}

1) express 다운받기

npm i express

2) express 간단히 이용해보기

express를 쓰면 앞장에서 살펴본 것처럼 if 문으로 도배하지 않아도 된다. 훨씬 간단한 코드가 가능해짐

const express = require('express');
const app = express();
const path = require('path');
app.set('port', process.env.PORT || 3000);

app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'index.html'));
});

app.listen(app.get('port'), () => {
    console.log('express 서버 실행');
});

2. 미들웨어

여러 종류의 미들웨어가 존재, 미들웨어 간의 코드순서도 중요

1) 애플리케이션 레벨 미들웨어

use이용, next()로 실행 모든 라우터에 적용할 수 있도록 함

next(): next를 호출해야 다음 코드로 넘어감

• next에 인수로 값을 넣으면 에러 핸들러로 넘어감
• next('route'): 인수에 route가 들어간 경우만 다음 라우트로 이동

코드 예제 /category/:name 라우터: 라우트 파라미터로 변수처럼 이용 예를 들어, http://localhost:3000/category/python → hello python 이 나타남

//6.1, app.js
const express = require('express');
const app = express();
const path = require('path');

app.set('port', process.env.PORT || 3000);

//use -> 미들웨어, 모든 라우터에 실행됨
//next()로 실행해줘야함
app.use((req, res,next) => {
    console.log("모든 요청에 실행됨");
    next();
});

app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'index.html'));
});
app.get('/category/javascript',(req, res)=> {
    res.send('hello javascript');
});
//404같은 오류가 날때 처리하기 좋음
app.get('*', (req, res) => {
    res.send('*'); 
});
app.listen(app.get('port'), () => {
    console.log('express 서버 실행');
});

2 ) 라우터 레벨 미들웨어

특정 라우터에만 작동

app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'index.html'));
})

3) 에러 처리 미들웨어

err,req,res,next까지 매개변수 4개 이용 res.status() -> HTTP 상태 코드 지정(기본값200) 특별한 경우가 아니면 가장 아래에 위치

코드 예제: 에러를 발생시키는 미들웨어를 넣은 뒤, 그 에러를 처리

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

app.set('port', process.env.PORT || 3000);
//두개의 미들웨어
//첫번째: 요청이 올때마다 console.log를 출력하고 다음 미들웨어로 넘어감
//두번째: 에러를 발생시키고 next(error)로 에러를 다음 핸들러로 넘김
app.use((req, res,next) => {
    console.log("모든 요청에 실행됨");
    next();
}, (req, res, next) => {
    try { console.log(asdf); }
    catch (err) {
        next(err);
    }
});

app.get('/', (req, res) => { 
    res.json({ hello: 'jade' });
    console.log('hello jade');
;}); 

//error 처리
app.use((err,req, res, next) => {
    res.status(200).send('404발생');
    console.log(err);
});
app.use((err,req, res, next) => {
    res.status(200).send('에러가 발생했어요ㅜ');
})

app.listen(app.get('port'), () => {
    console.log('express 서버 실행');
});

4) 서드파티 미들웨어

외부 라이브러리 사용: 대표적으로 morgan, cookie-parser, express-session, multer npm i margan cookie-parser express-session : 설치

1. morgan, cookie-parser 예제코드

• morgan : 어디서 어떤 http 코드를 받았는지 알 수 있음
• cookie-parser: 쿠키 관련 조작

  const express = require('express');
  const app = express();
  const path = require('path');
  const morgan = require('morgan');
  const cookieParser = require('cookie-parser');
  

app.set('port', process.env.PORT || 3000); app.use(morgan('dev')); // GET / 301 라는 console.log가 뜸 app.use(cookieParser('zerochopasswd'));

// 루트 경로 app.get('/', (req, res) => { req.cookies;
req.signedCookies; //쿠키 암호화 res.cookie('name', encodeURIComponent(name), { expires: new Date(), httpOnly: true, path:'/' }); res.clearCookie('name', encodeURIComponent(name), { httpOnly: true, path: '/' }); res.sendFile(path.join(__dirname, 'index.html')); });

app.listen(app.get('port'), () => { console.log('express 서버 실행'); });

**2. express-session** 코드예제
-> 세션 관리용, 로그인/로그아웃 기능을 할때 많이 쓰임

```js
const express = require('express');
const session = require('express-session');
const app = express();

app.use(session({
    secret: 'mySecretKey',      // 세션 암호화에 사용될 키
    resave: false,              // 세션을 강제로 저장할지 여부
    saveUninitialized: false,   // 초기화되지 않은 세션을 저장할지 여부
    cookie: { secure: false }   // true면 HTTPS에서만 쿠키 전송
}));

app.get('/', (req, res) => {
    req.session.user = '홍길동'; // 세션에 사용자 저장
    res.send('세션 생성 완료');
});

app.get('/session-check', (req, res) => {
    if (req.session.user) {
        res.send(`세션 사용자: ${req.session.user}`);
    } else {
        res.send('세션 없음');
    }
});

app.get('/logout', (req, res) => {
    req.session.destroy((err) => {
        if (err) return res.send('로그아웃 실패');
        res.send('로그아웃 완료');
    });
});

app.listen(3000, () => {
    console.log('서버 실행 중...');
});

3. multer

• multer는 파일 업로드를 처리
• 디스크 저장, 메모리 저장 모두 가능
• 파일 크기, 형식 제한 등 다양한 옵션 제공
• 프로필 사진, 게시판 첨부파일, 이미지 갤러리 같은 기능 구현에 필수

+)dotenv: 민감한 데이터를 별도의 파일에 저장하고 안전하게 불러올 수 있음 ex) key를 환경변수에 숨겨넣는 방법

//dotenv.js
const express = require('express');
const cookieParser = require('cookie-parser');
const session = require('express-session');
const dotenv = require('dotenv');
const path = require('path');

dotenv.config(); //dotenv!
const app = express();
app.set('port', process.env.PORT || 3000);

app.use(morgan('dev'));
app.use('/', express.static(path.join(__dirname, 'public')));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser(process.env.COOKIE_SECRET)); //dotenv! 환경변수에 저장
app.use(session({
  resave: false,
  saveUninitialized: false,
  secret: process.env.COOKIE_SECRET, //dotenv!
  cookie: {
    httpOnly: true,
    secure: false,
  },
  name: 'session-cookie',
}));

const multer = require('multer');
const fs = require('fs');
//uploads 폴더가 있는지 확인, 없으면 생성
try {
  fs.readdirSync('uploads');
} catch (error) {
  console.error('uploads 폴더가 없어 uploads 폴더를 생성합니다.');
  fs.mkdirSync('uploads');
}
const upload = multer({
 //storage: 업로드한 파일을 어디에 저장할 것인지, 어떤 이름으로 저장할 것인지
  storage: multer.diskStorage({
    destination(req, file, done) {
      done(null, 'uploads/'); //파일 저장위치
    },
    filename(req, file, done) { //파일 이름
      const ext = path.extname(file.originalname);
      done(null, path.basename(file.originalname, ext) + Date.now() + ext);
    },
  }),
  //limits: 파일 사이즈, 개수
  limits: { fileSize: 5 * 1024 * 1024 },
});

app.get('/upload', (req, res) => {
  res.sendFile(path.join(__dirname, 'multipart.html'));
});
//POST 요청 시 파일 업로드 처리
//input 태그의 name="image"인 파일 하나만 업로드, 성공하면 ok
app.post('/upload', upload.single('image'), (req, res) => {
  console.log(req.file);
  res.send('ok');
});

app.get('/', (req, res, next) => {
  console.log('GET / 요청에서만 실행됩니다.');
  next();
}, (req, res) => {
  throw new Error('에러는 에러 처리 미들웨어로 갑니다.')
});

//.env 파일
COOKIE_SECRET=cookiesecret

5) 내장 미들웨어 (Express 기본 제공)

express.static: 정적 파일 제공 express.json: JSON 데이터 처리

app.use(express.json());
app.use('/', express.static(__dirname, 'public'));
//'요청경로', express.static('실제경로')

*npm=node package manager *

• 노드의 패키지 매니저
• 다른 사람들이 만든 소스코드들을 모아둔 저장소
• 오픈소스

package.json

• 현재 프로젝트에 대한 정보와 사용중인 패키지에 대한 정보를 담은 파일
• npm init 으로 만들 수 있음

package-lock.json npm i D nodemon으로 다운

node_modules

• 다운받은 패키지들이 모여있는 곳
• npm install 로 다운 가능

2. npm 명령어

https://docs.npmjs.com/cli/v9/commands?v=true 이 주소에 가면 여러 npm 명령어들이 설명되어 있음

1) https

웹 서버에 SSL 암호를 거는 모듈 제공 https의 port는 443

const https = require('https');
const fs = require('fs');

//서버가 시작되기 전에 인증서를 읽고 넣어줘야함
//인증서: cert, key, ca -> fs로 가져와야함
//https로 하면 port가 443
https.createServer({
  cert: fs.readFileSync('도메인 인증서 경로'),
  key: fs.readFileSync('도메인 비밀키 경로'),
  ca: [
    fs.readFileSync('상위 인증서 경로'),
    fs.readFileSync('상위 인증서 경로'),
  ],
}, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
  res.write('<h1>Hello Node!</h1>');
  res.end('<p>Hello Server!</p>');
})
  .listen(443, () => {
    console.log('443번 포트에서 서버 대기 중입니다!');
  });

2) http2

SSL 암호화와 더불어 최신 HTTP 프로토콜인 http/2를 사용하는 모듈 요청 및 응답 방식이 기존 http/1.1보다 개선됨 웹의 속도가 개선됨 요청을 하나씩(http)이 아닌 여러개를 동시에 보낼 수 있음

//http2
const http2 = require('http2');
const fs = require('fs');

//여기도 인증서 가져와야함
//port 443
http2.createSecureServer({
  cert: fs.readFileSync('도메인 인증서 경로'),
  key: fs.readFileSync('도메인 비밀키 경로'),
  ca: [
    fs.readFileSync('상위 인증서 경로'),
    fs.readFileSync('상위 인증서 경로'),
  ],
}, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
  res.write('<h1>Hello Node!</h1>');
  res.end('<p>Hello Server!</p>');
})
  .listen(443, () => {
    console.log('443번 포트에서 서버 대기 중입니다!');
  });

2. Cluster

원래 nodejs는 단일 스레드에서 동작 -> 하나의 cpu 코어만 사용 Cluster -> 여러 개의 프로세스를 생성하여 모든 CPU 코어를 사용가능

요청이 많이 들어왔을 때 병렬로 실행된 서버의 개수만큼 요청이 분산됨->서버에 무리가 덜감 cluster로 코어 하나 당 노드 프로세스 하나를 배정 가능 단점: 컴퓨터 자원(메모리 세션 등) 공유 못함

워커스레드 기능과 유사

• 워커스레드: 여러 스레드를 만듦
• 클러스터: 여러 프로세스를 만듦

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`마스터 프로세스 아이디: ${process.pid}`);
  // CPU 개수만큼 워커를 생산
  for (let i = 0; i < numCPUs; i += 1) {
    cluster.fork();
  }
  // 워커가 종료되었을 때
  cluster.on('exit', (worker, code, signal) => {
    console.log(`${worker.process.pid}번 워커가 종료되었습니다.`);
    console.log('code', code, 'signal', signal);
    cluster.fork();
  });
} else {
  // 워커들이 포트에서 대기
  http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.write('<h1>Hello Node!</h1>');
    res.end('<p>Hello Cluster!</p>');
    setTimeout(() => { // 워커 존재를 확인하기 위해 1초마다 강제 종료
      process.exit(1);
    }, 1000);
  }).listen(8086);

  console.log(`${process.pid}번 워커 실행`);
}

1) 서버와 클라이언트의 관계

• 클라이언트가 서버로 "요청request"을 보냄
• 서버는 요청을 처리
• 처리 후 클라이언트로 "응답response"을 보냄

2) HTTP

const http = require('http');
const server = http.createServer((req, res) => {
    res.write('<h1>hello node</h1>');
    res.write('<h2>hello node</h2>');
    res.write('<h3>hello node</h3>');
})
    .listen(8080);

server.on('listening', () => {
    console.log('8080포트에서 서버 대기 중입니다.');
});
server.on('error', () => {
    console.log(error);
});

localhost8080에 들어가면 hello node 가 나옴! localhost는 컴퓨터 내부 주소로 외부에서는 접근이 안됨..!

2. fs로 HTML 읽어 제공하기

const http = require('http');
const fs = require('fs').promises;

const server = http.createServer(async(req, res) => {
    try {
        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
        const data = await fs.readFile('./chap4/server2.html');
        res.end(data);
    }
    catch (error) {
        console.log(error);
        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end(error.message);
    }
})
    .listen(8080);


server.on('listening', () => {
    console.log('8080포트에서 서버 대기 중입니다.');
});
server.on('error', (error) => {
    console.log(error);
});

3. REST API 서버

서버에 요청을 보낼 때 주소를 통해 요청의 내용을 표현 -> 서버가 이해하기 쉬운 주소로 보내는게 좋음 REST API: 주소를 정하는 규칙

• ex) /post : 게시글과 관련된 요청

1) HTTP 프로토콜

RESTful: REST API를 사용한 주소 체계를 이용하는 서버

GET: 서버 자원을 가져와야 할 때 POST: 서버에 자원을 새로 등록하고자 할때 PUT: 서버의 자원을 요청에 들어잇는 자원으로 치환하려 할때(전체수정) PATCH: 서버 자원의 일부만 수정하고자 할때(일부수정) DELETE: 서버의 자원을 삭제하고자 할때

2) CRUD REST API 서버 만들어보기

이 서버의 설명

• GET / → restFront.html 제공
• GET /about → about.html 제공
• GET /users → 저장된 사용자 목록(JSON) 반환
• POST /user → 새로운 사용자 추가
• PUT /user/:id → 사용자 정보 수정
• DELETE /user/:id → 사용자 삭제
• 파일 제공 기능 → 정적 파일 요청 처리
• 존재하지 않는 라우트 요청 시 404 NOT FOUND
• 서버 오류 시 500 INTERNAL SERVER ERROR

writeHead : http 서버에서 응답헤더를 설정

• http 상태코드와 응답헤더를 설정한 후 본문을 전송할 준비를 함
• res.end()로 본문을 전송하여 응답 완료

  const http = require('http');
  const fs = require('fs').promises;
  const path = require('path');
  

const users = {}; // 데이터 저장용

//서버 생성, req: request, res: respond http.createServer(async (req, res) => { try { if (req.method === 'GET') { //GET /: restFront.html 파일을 읽어와 응답 //200 응답코드와 함께 html 반환 if (req.url === '/') { const data = await fs.readFile(path.join(dirname, 'restFront.html')); res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); //200,201 -> 성공적으로 요청에 응답 //404 -> 요청에 응답 실패 NOT FOUND return res.end(data); } //GET /about: about.html을 읽어와 응답 else if (req.url === '/about') { const data = await fs.readFile(path.join(dirname, 'about.html')); res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); return res.end(data); } //GET/ users: users 객체를 JSON 형식으로 응답 else if (req.url === '/users') { res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' }); return res.end(JSON.stringify(users)); } // /도 /about도 /users도 아니면 try { const data = await fs.readFile(path.join(__dirname, req.url)); return res.end(data); } catch (err) { // 주소에 해당하는 라우트를 못 찾았다는 404 Not Found error 발생 } } //POST 요청 처리: 사용차 추가 else if (req.method === 'POST') { // POST /user if (req.url === '/user') { let body = ''; // 데이터를 스트림 형태로 받아 body 변수에 저장 req.on('data', (data) => { body += data; }); // 요청의 body를 다 받은 후 실행됨 // 받은 JSON 데이터를 파싱하여 사용자 객체에 추가 return req.on('end', () => { console.log('POST 본문(Body):', body); const { name } = JSON.parse(body); const id = Date.now(); users[id] = name; res.writeHead(201, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end('등록 성공'); }); } } //PUT /user:id : 해당 사용자의 정보 수정 else if (req.method === 'PUT') { if (req.url.startsWith('/user/')) { const key = req.url.split('/')[2]; // /user/12345 같은 요청에서 12345를 추출하여 사용자의 키로 사용 // 수정할 데이터(body)를 받습니다. let body = ''; req.on('data', (data) => { body += data; }); return req.on('end', () => { console.log('PUT 본문(Body):', body); users[key] = JSON.parse(body).name; res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); return res.end(JSON.stringify(users)); }); } } else if (req.method === 'DELETE') { if (req.url.startsWith('/user/')) { //해당 키를 가진 사용자를 삭제. 삭제 후 응답 const key = req.url.split('/')[2]; delete users[key]; res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); return res.end(JSON.stringify(users)); } } //주소에 해당하는 라우트를 하나도 찾지 못했을 때 -> 404 NOT FOUND res.writeHead(404); return res.end('NOT FOUND'); } catch (err) { console.error(err); res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end(err.message); } }) .listen(8082, () => { console.log('8082번 포트에서 서버 대기 중입니다'); });

## 4. 쿠키, 세션
### 1) 쿠키
요청의 단점: 누가 요청을 보냈는지 알수가 없음
- IP주소와 브라우저 정보 정도만 알 수 있음
- "누가" 요청을 보냈는지를 알려면 쿠키, 세션 필요

**쿠키: 쿠키명=쿠키값 의 쌍**
- ex) name=jade
- 매 요청마다 쿠키를 서버에 동봉해서 보냄
서버가 응답할 때도 쿠키랑 같이 응답
- 서버는 쿠키를 읽어서 누구인지 파악

쿠키 옵션
- Expires, Max-age, Domain(쿠키가 전송될 도메인을 특정), Path(쿠키가 전송될 URL), Secure, HttpOnly 

**예제코드**
- 쿠키문자열을 객체로 변환(parseCookies) 
- 주소가 /login, / 인경우로 나눔
- /login : 이름을 쿠키로 5분간 저장, / 으로 redirect
- / : 쿠키가 있는지 없는지 확인
있으면 환영 인사, 없으면 로그인 페이지 띄움

```js
const http = require('http');
const fs = require('fs').promises;
const path = require('path');
//쿠키문자열을 객체{name:"value"}로 변환
const parseCookies = (cookie = '') => 
//cookie가 null/undefined라면 빈문자열
  cookie  //'cookie1=1234; cookie2=5678'
    .split(';') //["cookie1=1234", "cookie2=5678"]
    .map(v => v.split('=')) //[["cookie1", "1234"], [" cookie2", "5678"]]
    .reduce((acc, [k, v]) => {
      acc[k.trim()] = decodeURIComponent(v);
      return acc;
      //reduce() 를 이용해 {key:value}형태의 객체 생성
      //k.trim(): 공백 제거
      //decodeURLComponent(v): URL 인코딩된 값을 디코딩
    }, {}); //결과:{cookie1: "1234"},{cookie2: "5678"}

http.createServer(async (req, res) => {
  const cookies = parseCookies(req.headers.cookie); // { mycookie: 'test' }
  // 주소가 /login으로 시작하는 경우(로그인버튼을 눌렀을때)
  if (req.url.startsWith('/login')) {
    const url = new URL(req.url, 'http://localhost:8084');
    const name = url.searchParams.get('name');
    const expires = new Date();
    // 쿠키 유효 시간을 현재시간 + 5분으로 설정
    expires.setMinutes(expires.getMinutes() + 5);
    res.writeHead(302, { //302-> redirection
      Location: '/',
      'Set-Cookie': `name=${encodeURIComponent(name)}; Expires=${expires.toGMTString()}; HttpOnly; Path=/`,
    });
    res.end();
  }
    //주소가 / 이면서 쿠키가 있는 경우
  else if (cookies.name) {
    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
    res.end(`${cookies.name}님 안녕하세요`);
  }
  else {//주소가 / 이면서 쿠키가 없는 경우
    try {
      const data = await fs.readFile(path.join(__dirname, 'cookie2.html'));
      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
      res.end(data);
    } catch (err) {
      res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
      res.end(err.message);
    }
  }
})
  .listen(8084, () => {
    console.log('8084번 포트에서 서버 대기 중입니다!');
  });

2) 세션

쿠키의 정보는 노출되고 수정되는 위험이 있음 -> 세션 이용

세션 원리 중요한 정보는 서버에서 관리하고 클라이언트에는 세션 키만 제공 서버에 세션객체 생성 후 키(uniquelnt)를 만들어 속성명으로 이용 속성 값에 정보를 저장하고 uniquelnt를 클라이언트에 제공 6장에 더 깊게 다룰 예정

const http = require('http');
const fs = require('fs').promises;
const path = require('path');

const parseCookies = (cookie = '') =>
  cookie
    .split(';')
    .map(v => v.split('='))
    .reduce((acc, [k, v]) => {
      acc[k.trim()] = decodeURIComponent(v);
      return acc;
    }, {});

const session = {};

http.createServer(async (req, res) => {
  const cookies = parseCookies(req.headers.cookie);
  if (req.url.startsWith('/login')) {
    const url = new URL(req.url, 'http://localhost:8085');
    const name = url.searchParams.get('name');
    const expires = new Date();
    expires.setMinutes(expires.getMinutes() + 5);
    //**여기부터 세션**//
    const uniqueInt = Date.now();
    session[uniqueInt] = {
      name,
      expires,
    };
    res.writeHead(302, {
      Location: '/',
      'Set-Cookie': `session=${uniqueInt}; Expires=${expires.toGMTString()}; HttpOnly; Path=/`,
    });
    res.end();
  // 세션쿠키가 존재하고, 만료 기간이 지나지 않았다면
  } else if (cookies.session && session[cookies.session].expires > new Date()) {
    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
    res.end(`${session[cookies.session].name}님 안녕하세요`);
  } else {
    try {
      const data = await fs.readFile(path.join(__dirname, 'cookie2.html'));
      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
      res.end(data);
    } catch (err) {
      res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
      res.end(err.message);
    }
  }
})
  .listen(8085, () => {
    console.log('8085번 포트에서 서버 대기 중입니다!');
  });

1) 에라토스테네스의 체

에라토스테네스의 체의 원리

1. 주어진 범위까지의 배열 생성(1은 제외하고 2부터)
2. 선택한 수의 배수를 모두 삭제(ex, 2의 배수를 모두 삭제)
3. 다음 지워지지 않은 수(3)을 선택, -> 3의 배수를 모두 삭제, 이때 이미 지운 수는 다시 지우지 않음
4. 앞의 과정을 배열의 끝까지 반복
5. 삭제되지 않은 수를 모두 출력

에라토스테네스 체의 시간복잡도 -> 문제마다 다름 O(N^2) or O(Nlog(logN))

2) 문제1: 소수구하기 1929

1. 문제: https://www.acmicpc.net/problem/1929

2. 코드

• 2가 소수 -> 2의 배수들 모두 isPrime: false 처리

  #include<iostream> 
  #include<vector>
  using namespace std;
  

int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

int m, n;
cin >> m >> n;

vector <bool> isPrime(n + 1, true);
isPrime[0] = false;
isPrime[1] = false;

for (int i = 2; i * i <= n; i++) { 
    if (isPrime[i]) {
        for (int j = i * i; j <= n; j += i) {
            isPrime[j] = false;
        }
    }  
}

for (int i = m; i <= n; i++) {
    if (isPrime[i]) cout << i << "\n";
}
return 0;

}

### 3) 문제2: 거의 소수 1456
1. 문제
https://www.acmicpc.net/problem/1456
소수의 제곱의 개수를 찾는 문제

2. 코드
- 범위 -> int 가 아닌 longlong을 써야함!
- 거의 소수 구할 때 a와 b사이 범위 안에서 카운트 하도록 조건 넣어줘야함!
```cpp
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
typedef long long ll;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);

    ll a, b;
    cin >> a >> b;
    int limit = sqrt(b) + 1;
    vector <bool> isPrime(limit + 1, true);
    vector <int>primes;

    //소수구하기
    for (ll i = 2; i <= limit; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
            for (ll j = i * i; i <= b; j += i) {
                isPrime[j] = false;
            }
        }
    }

    //거의 소수 구하기
    ll cnt = 0;
    for (ll i : primes) {
        ll temp = i * i;
        while (temp <= b) {
            if (temp >= a) {
                cnt++;
            }
            if (temp > (b / i)) break;
            temp *= i;
        }
    }
    cout << cnt;

    return 0;
}

3) 문제3: 소수&팰린드롬 1747번

1. 문제 https://www.acmicpc.net/problem/1747

2. 코드

• 팰린드롬 <- 투포인터로 찾기 숫자를 문자열로 바꾼 후, 투포인터를 이용해 비교

  #include<iostream>
  #include<vector>
  #include<string> 
  using namespace std; 
  int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);
    //입력받기
    int n;
    cin >> n;
  
    vector <bool> isPrime(10000001, true);
    isPrime[0] = false; isPrime[1] = false;
  
    string num;
    bool pen = false;
  
    //소수를 찾기
    for (int i = 2; i*i<= 10000000; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= 10000000; j += i) {
                isPrime[j] = false;
            }
        }
    }
  
    //소수의 값을 char 형태로 변환 후 투포인터를 이용해 팰린드롬 여부 확인
    for (int i = n; i <= 10000000; i++) {
        if (isPrime[i]) {
            pen = true;
            num = to_string(i);
            int ind1 = 0; int ind2 = num.length()- 1;
            while (ind1 <= ind2) {
                if (num[ind1] == num[ind2]) {
                    ind1++;
                    ind2--;
                }
                else {
                    pen = false;
                    break;
                }
            }
        }
        if (pen) {
            cout << num;
            break;
        }
    }
    return 0;
  

}

1016번

오일러피 관련 문제: 11689
유클리드 호제법 문제: 1934 1850 1033
확장 유클리드 호제법: 21568

현재 상태에서 보는 최선의 선태이 전체 선택지 중 최선의 선택지라고 가정하는 알고리즘

2. 대표 코드

코드 작동 원리

• 해 선택: 현재 상태에서 최선이라고 생각되는 해를 선택
• 적절성 검사: 현재 선택한 해가 전체 문제의 제약 조건에서 벗어나지 않는지 검사
• 해검사: 현재까지 선택한 해 집합이 전체 문제를 해결할 수 있는지 검사 -> 전체 문제를 해결하지 못한다면 처음으로 돌아가 '해 선택'부터 반복

3. 문제1: 동전 0 11047번

1. 문제: https://www.acmicpc.net/problem/11047

2. 코드

• 가격이 큰 것부터 k보다 작거나 같은 동전이 나올 때까지 탐색
• 예제코드1로 설명해보면(k=4200) 4200/1000=4 -> sum=4, k=200
• 아직 k가 0보다 크니까, 이 과정을 반복
• 200/100=2 -> sum+=2, k=0
• 결과(sum)는 6이 됨

  #include<iostream>
  #include<vector> 
  using namespace std;
  

int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

int n, k;
cin >> n >> k;

vector <int> coin(n, 0);
for (int i = 0; i < n; i++) {
    cin >> coin[i];
}

int sum = 0;
for (int i = n - 1; i >= 0; i--) {
    if (k >= coin[i]) {
        sum += (k / coin[i]); //4200/1000=4
        k = k % coin[i]; //4200%1000=200
    }
}


cout << sum;
return 0;

}

## 4. 문제2: 잃어버린 괄호 1541번
1. 문제: https://www.acmicpc.net/problem/1541
![](https://velog.velcdn.com/images/to_world/post/163b95fc-9073-4f09-a85f-55e2cab1b830/image.png)


2. 코드
- ```atoi()``` -> 문자열을 정수형으로 바꿔주는 기능
- 20-50+40 -> 20-(50+40) 이어야 최솟값이 됨
20-50+40-30+20 -> 20-(50+40)-(30+20) -> 최솟값
=> 덧셈을 최대한 뺄셈으로 바꿔주는 것이 중요
- '-' 를 만난뒤에 나오는 '+' 는 '-' 처리되어야함
'-' 를 만나기 전에 나오는 + 는 그대로 + 처리
- 문제에 - 를 한번만 써야한다는 제약은 없으므로 - 뒤에 나오는 모든 + 를 - 로 계속 바꿔주면 됨
```cpp
#include<iostream>
#include<string> //문자열을 숫자로 바꿔줄 수 있는 기능!
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    string number = "";
    int res = 0;
    string s;
    cin >> s;
    bool isMinus = false;

    for (int i = 0; i <= s.length(); i++) {
        if (s[i] == '+' || s[i] == '-' || i == s.length()) {
            if (isMinus) {
                res -= stoi(number); //문자열을 정수형으로 바꿔줌
                number = "";
            }
            else {
                res += stoi(number);
                number = "";
            }
        }
        else { //숫자를 만난 경우
            number += s[i];
        }

        if (s[i] == '-') {
            isMinus = true;
        }

    }
    cout << res;
    return 0;
}

5 못푼 문제들

https://www.acmicpc.net/problem/1931 https://www.acmicpc.net/problem/1744 https://www.acmicpc.net/problem/1715

1) 개념

"데이터가 정렬된 상태에서" 원하는 값을 찾아내는 알고리즘 대상 데이터의 중앙값과 찾고자 하는 값을 비교해 데이터의 크기를 절반씩 줄여나가는 것 시간복잡도: O(logN)

2) 대표코드

이진 탐색과정

• 현재 데이터의 중앙값 선택
• 중앙값>타깃값 -> 중앙값 기준 왼쪽 데이터셋 선택 중앙값<타깃값 ->중앙값 기준 오른쪽 데이터셋 선택
• 반복하다가 중앙값=타깃값 -> 종료

while (s <= e) {
    int middle= (s + e) / 2;
    if (input[middle] > num) {
        e = middle-1;
    }
    else if (input[middle] < num) {
        s = middle + 1;
    }
    else {
        found = true;
        break;
    }
}

3) 문제: 원하는 정수 1920번

1. 문제: https://www.acmicpc.net/problem/1920

2. 코드

#include<iostream>
#include<vector> 
#include<algorithm> 
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int n, m;
    cin >> n;
    vector <int> input(n,0);
    for (int i = 0; i < n; i++) {
        cin >> input[i];
    }
    sort(input.begin(), input.end());

    cin >> m;
    for (int i = 0; i < m; i++) {
        int num;
        cin >> num;
        int s = 0; int e = input.size() - 1;
        bool found = false;

        while (s <= e) {
            int middle= (s + e) / 2;
            if (input[middle] > num) {
                e = middle-1;
            }
            else if (input[middle] < num) {
                s = middle + 1;
            }
            else {
                found = true;
                break;
            }
        }
        if (found) cout << 1 << "\n";
        else cout << 0 << "\n";
    }

    return 0;
}

**4) 문제: 기타레슨 2373번

1. 문제: https://www.acmicpc.net/problem/2343

2. 코드

**5) 문제: 기타레슨 2373번

1. 문제: https://www.acmicpc.net/problem/1300

1) 멀티스레딩 지원 기본적으로 Node.js는 단일 스레드에서 실행되지만, worker_threads를 사용하면 여러 개의 스레드를 실행 가능 CPU 연산이 많은 작업을 처리할 때 사용하면 성능 향상!

2) 메시지 기반 통신 메인 스레드와 워커 스레드는 postMessage()와 on('message')를 통해 데이터를 주고받으며 통신

3) 각 워커는 독립적인 실행 환경을 가짐 메모리를 공유하지 않고 실행됨 (단, SharedArrayBuffer를 사용하면 일부 메모리 공유 가능).

*4) 개발의 번거로움, 어려움 존재 * 워커 스레드를 다 나눠줘야하고, 일을 하나하나 시키고 처리해야하는 번거로움, 어려움 존재

const { Worker, isMainThread, parentPort,workerData } = require('worker_threads');

if (isMainThread) { // 메인 스레드
    const threads = new Set(); //중복되지 않은 배열
    threads.add(new Worker(__filename, {
        workerData: { start: 1 }
    }));
    threads.add(new Worker(__filename, {
        workerData: { start: 2 }
    }));

    for (let worker of threads) {
        worker.on('message', (value) => console.log('워커로부터:', value));
        worker.on('exit', () => {
            threads.delete(worker);
            if (threads.size === 0) {
                console.log('워커 끝');
            }
        });
    } 
} else { // 워커 스레드
    const data = workerData;
    parentPort.postMessage(data.start+100);
}
/*출력결과
워커로부터: 101
워커로부터: 102
워커 끝
*/

2. 내장모듈- child_process

외부 프로세스를 생성하고 실행할 수 있도록 해주는 내장 모듈 -> 이를 통해 운영 체제 명령어 실행, 다른 프로그램 실행, 병렬 작업 수행 등이 가능

//Node.js의 child_process 모듈을 사용하여
//외부 명령어(dir)를 실행하는 예제

const { exec } = require('child_process');
//exec()는 외부 명령어(프로그램)를 실행하고, 그 결과를 비동기적으로 반환하는 함수

var process = exec('dir');
//Windows에서 dir 명령어를 실행하여 현재 디렉토리의 파일 목록을 출력

process.stdout.on('data', function (data) {
    console.log(data.toString());
});

3. 파일 시스템

내장모듈- fs

파일 시스템에 접근하는 모듈 파일및 폴더 생성 삭제 존재여부 체크 등

fs.readFile('./chap3/readme.txt') //읽기
    .then((data) => {
        console.log(data.toString());
    })
    .catch((err) => {
        throw err;
    })
//파일 생성
fs.writeFile('./chap3/writefile.txt',"writenow")
    .then(( ) => {
        return fs.readFile('./chap3/writefile.txt');
    })
    //생성한 파일을 읽어서 내용 출력
    .then((data) => {
         console.log(data.toString())
    })
    .catch((err) => {
        throw err;
})

!비동기 파일 작업!

• 파일을 읽는 건 "비동기"로 많이 진행됨, 동기로 진행하면 뒷사람이 파일작업을 하기까지 시간이 너무 많이 걸림
• const fs=require('fs').promises : 비동기 작업으로 처리
• 그러나! 비동기로 하면 코드 실행 순서를 예상할 수 없기 때문에 이를 잘 처리해주는 것이 중요함
• 다음 코드를 읽어보면서 익혀보자

  //chap3/fs_async.js
  //주의해야할 점!
  //비동기함수 -> 백그라운드로 넘어감
  // -> 백그라운드에 넘어간 함수들이 동시 실행
  // -> 누가 먼저 끝나는지 모른다는 단점 존재
  //readFile을 비동기로 여러번 하면 어떤 파일을 먼저 읽을지 모름
  //이 코드를 실행시켜보면, 1~4번이 무작위로 출력됨!
  const fs = require('fs').promises;
  fs.readFile('./chap3/readme.txt')
    .then((data) => {
        console.log("1번"+ data.toString());
    })
    .catch((err) => {
        throw err;
    })
  fs.readFile('./chap3/readme.txt')
    .then((data) => {
        console.log("2번"+ data.toString());
    })
    .catch((err) => {
        throw err;
    })
  fs.readFile('./chap3/readme.txt')
    .then((data) => {
        console.log("3번"+ data.toString());
    })
    .catch((err) => {
        throw err;
    })
  fs.readFile('./chap3/readme.txt')
    .then((data) => {
        console.log("4번"+ data.toString());
    })
    .catch((err) => {
        throw err;
    })
  
  

//해결1: 비동기 + 순서예측 되게끔 + promise fs.readFile('./chap3/readme.txt') .then((data) => { console.log("1번!"); return fs.readFile('./chap3/readme.txt'); }) .then((data) => { console.log("2번!"); return fs.readFile('./chap3/readme.txt'); }) .then((data) => { console.log("3번!"); return fs.readFile('./chap3/readme.txt'); }) .catch((err)=>{ throw err; })

//해결2: async로 해서 더 깔끔하게도 가능 async function main() { let data=await fs.readFile('./chap3/readme.txt') console.log("1번"); data=await fs.readFile('./chap3/readme.txt') console.log("2번"); data=await fs.readFile('./chap3/readme.txt') console.log("3번"); } main();

이외에도 fs 관련 여러 함수들, 기능들이 있다...
파일 복사, 파일 존재여부 체크, 등등
필요하면 그때그때 공식문서, 서칭 등 해보기

### 2) 버퍼buffer
일정한 크기로 모아두는 데이터
일정한 크기가 되면 한번에 통째로 처리
```js
const buffer = Buffer.from('저를 버퍼로 바꿔보세요');
console.log(buffer);
console.log(buffer.length);
console.log(buffer.toString());
console.log(Buffer.alloc(5)); //5바이트 버퍼 생성

3) 스트림stream

데이터의 흐름 일정한 크기로 나눠서 여러번에 걸쳐 처리 버퍼를 작게 만들어서 주기적으로 전달 스트리밍: 일정한 크기의 데이터를 지속적으로 전달

1. stream 읽기 쓰기 예제

//스트림 읽기
const fs = require('fs');
const readstream = fs.createReadStream('./chap3/readme2.txt');const data = [];
readstream.on('data', (chunk) => {
    data.push(chunk);
    console.log('data:', chunk, chunk.length);
});
readstream.on('end', () => {
    console.log('end', Buffer.concat(data).toString());
});
readstream.on('error', (err) => {
    throw err;
});
//스트림 쓰기
const writestream = fs.createWriteStream('./chap3/write2.txt');
writestream.on('finish', () => {
    console.log("쓰기 완료");
});
writestream.write('글쓰기\n');
writestream.write('한번 더 글쓰기\n');
writestream.end();

2. stream piping 예제

//16byte씩 읽고 그 16byte를 바로 writeme.txt에 쓰는 코드
const fs = require('fs');
const readstream = fs.createReadStream('./chap3/readme.txt',
    {highwatermark:16}
);
const writestream = fs.createWriteStream('./chap3/write3.txt');
readstream.pipe(writestream); //**

4. 스레드풀과 커스텀 이벤트

1) 스레드풀

노드는 기본적으로 background에서 4개의 thread까지 작업 가능 만약 본인의 코어가 그 이상이어서 본인컴퓨터의 코어만큼 작업시키고 싶으면 SET UV_THREADPOOL_SIZE=8(코어개수)을 터미널에 입력시키면 됨

2) 내장 모듈- 커스텀 이벤트

커스텀 이벤트는 사용자가 정의한 이벤트 사용법

• EventEmitter 클래스를 사용하여 커스텀 이벤트를 정의하고 리스너들을 추가
• 이벤트 발생 (emit) 시, 해당 이벤트에 등록된 리스너들이 호출됨

const eventemitter = require('events');
const myEvent = new eventemitter();

myEvent.addListener('event1', () => {
    console.log("1");
});
myEvent.on('event2', () => {
    console.log("2");
});
myEvent.once('event3', () => { //실행이 한번만 됨
    console.log("3");
});

myEvent.emit('event1');
myEvent.emit('event2');
myEvent.emit('event3');
myEvent.emit('event3');//이미 한번 실행을 해서 이번에는 실행안됨
myEvent.removeAllListeners('event1'); //event1지우기

5. 에러,예외 처리하기

예외: 처리하지 못한 에러 노드 스레드를 멈춤 -> 노드는 싱글스레드 -> 전체가 멈춰버림

해결법1: try catch 문으로 예외 처리 해결법2: 콜백함수에서 err 처리하기 if(err) console.log(err); 해결법3: process.on('uncaughtException',(err)=>{console.error('에러발생');}); -> 에러내용을 기록용, 모든 에러가 이 부분에 모여들어서 저장됨

프로세스 종료하기(강제종료) taskkill /pid : 윈도우

1) 모듈화

var.js를 다른 파일에서 받아 쓸 수 있다. 모듈화의 2가지 방법

• 둘 중 한가지 방법만 사용해서 쭉 써야함
• 방법1을 썼다가 다음 줄에 방법2로 쓰는 식으로 코딩작성하면 안됨
• module.exports에 아무것도 안넣으면 기본값으로 빈객체가 생성됨

  //var.js
  const odd = "홀수입니다.";
  const even = "짝수입니다";
  

//모듈화 방법1 //두가지 이상을 exports하고 싶을 때 사용 가능 exports.odd = odd; exports.even = even;

//모듈화 방법2 module.exports = { odd: odd, even: even };

### 2) require
**기본 개념:**
require가 제일 위에 올 필요는 없음
require을 console.log(require)해보면 require 속성들이 나옴
- require.cache에 한번 require한 모듈에 대한 캐슁 정보가 들어있음
- require.main은 노드 실행 시 첫 모듈을 가리킴
```js
require('./var'); //var 파일 실행만 됨.

const {odd,even} = require('./var.js'); //구조분해할당
console.log(odd);
console.log(even);

순환 참조

• 서로가 서로를 require해서 무한cycle이 도는 경우
• 순환참조가 발견되면 빈객체로 만들어 무한cycle, 순환참조를 막아버림

  //require1.js
  require('./require2');
  //require2.js
  require('./require1'); //빈객체
  

**dynamic import**
```js
const a = true;
if(a) require('./var');
else require('./index');

2. ES 모듈시스템

기본 개념: 확장자를 mjs로 쓰거나, package.json에 type:"module" 로 바꿔줘야한다. CommonJs -> ES 모듈이 되면서 바뀐 것

• require -> import
• exports -> export
• module.exports -> export default
• require, exports는 함수,객체였으나 import export default는 문법 그 자체(예약어)이다.
• async+await이 항상 함께 -> async 없이 await을 쓸 수 있음
• dynamic import 방식이 바뀜
• __dirname, __filename 사용 가능 -> 사용 불가

  //var.mjs
  export const odd = "홀수입니다.";
  export const even = "짝수입니다";
  

//func.mjs import { odd, even } from './var.mjs' //확장자까지 꼭 써줘야함 function checkOddorEven(num) { if (num % 2) { return odd; } return even; }; export default checkOddorEven;

**dynamic import in ES 모듈**
```js
const a = true;
if(a) a1 = await import('./var.mjs');
else a2 = await import('./index.mjs');

3. process

1)기본 개념: 현재 실행중인 노드 프로세스에 대한 정보에 접근할 수 있음

process.upTime(); //프로세스가 시작된 후 지난 시간
process.cwd(); //현재 프로세스가 실행되는 위치
process.pid //프로세스 아이디

process.env : 환경변수

• 시스템 환경변수 정보가 들어있음
• 비밀키를 보관하는 용도로 쓰임
• process.env 로 접근
• 일부 환경변수는 노드 실행시 영향을 줄 수 있음

  const passwd=process.env.SECRET_ID;

• process.nextTick*
• 이벤트 루프가 다른 콜백함수보다 process.nextTick 의 콜백함수를 우선적으로 처리

  setImmediate(() => {
    console.log('immediate');
  });
  

process.nextTick(() => { console.log('nextTick'); });

setTimeout(() => { console.log('timeout'); }, 0);

Promise.resolve().then(() => console.log('promise')); //nextTick->promise->timeout->immediate

**process.exit**
- 노드 process 종료시킴
- ``` process.exit(0)```  : 정상적으로 종료된 것
- 0 이외의 숫자: 비정상적으로 종료


## 4. 내장모듈- os path
### 1) os
운영체제의 정보
process와 겹치는 부분이 있음
```js
//os.js
const os = require('os');  
os.arch() // process.arch와 동일합니다.
os.platform() // process.platform과 동일합니다.
os.type() // 운영체제의 종류를 보여줍니다.
os.uptime() // 운영체제 부팅 이후 흐른 시간(초)을 보여줍니다. //process.uptime()은 노드의 실행 시간이었습니다.
os.hostname() // 컴퓨터의 이름을 보여줍니다.
os.release() // 운영체제의 버전을 보여줍니다.
os.homedir() // 홈 디렉터리 경로를 보여줍니다.
os.tmpdir() // 임시 파일 저장 경로를 보여줍니다.
os.cpus() // 컴퓨터의 코어 정보를 보여줍니다.
os.freemem() // 사용 가능한 메모리(RAM)를 보여줍니다.
os.totalmem() // 전체 메모리 용량을 보여줍니다.

2) path

경로처리 맥, 리눅스 등에 따라 경로처리가 다름: \을 쓰는 경우도 있고 /를 쓰는 경우도 있고... 이러한 경로들을 path 가 처리해줌

const path = require('path');
path.join(__dirname, '..', 'var.js'); 
//-> 주어진 경로들을 단순히 이어 붙여 새로운 경로를 만듦
//___dirname에서 한 단계 위(..)로 이동한 후 var.js를 붙인 경로를 반환
///Users/user/project/src/index.js =>/Users/user/project/index.js
path.resolve(__dirname, '..', '/var.js');
//-> 절대 경로를 반환
//__dirname에서 한 단계 위(project)로 이동한 후 var.js를 추가
///Users/user/project/src/index.js =>/Users/user/project/index.js

이 예제들 이외에도 굉장히 많음..

5. url dns searchParams

0) http 해석

1) url(URL) searchParams

URL, searchParams : 내장 모듈이 아니라 객체, require('url') 없어도 됨

const url = require('url');
const myURL = new URL('https://www.naver.com/');
console.log(myURL);
console.log(url.format(myURL)); //문자열로 바꿔줌
/* 출력1
URL {
  href: 'https://www.naver.com/',
  origin: 'https://www.naver.com',
  protocol: 'https:',
  username: '',
  password: '',
  host: 'www.naver.com',
  hostname: 'www.naver.com',
  port: '',
  pathname: '/',
  search: '',
  searchParams: URLSearchParams {},        
  hash: ''
}
출력2: https://www.naver.com/ 
*/

const myURL = new URL('http://www.gilbut.co.kr/?page=3&limit=10&category=nodejs&category=javascript');

console.log('searchParams:', myURL.searchParams);
console.log('searchParams.getAll():', myURL.searchParams.getAll('category'));
console.log('searchParams.get():', myURL.searchParams.get('limit'));
console.log('searchParams.has():', myURL.searchParams.has('page'));

console.log('searchParams.keys():', myURL.searchParams.keys());
console.log('searchParams.values():', myURL.searchParams.values());

myURL.searchParams.append('filter', 'es3');
myURL.searchParams.append('filter', 'es5');
console.log(myURL.searchParams.getAll('filter'));

myURL.searchParams.set('filter', 'es6');
console.log(myURL.searchParams.getAll('filter'));

myURL.searchParams.delete('filter');
console.log(myURL.searchParams.getAll('filter'));

console.log('searchParams.toString():', myURL.searchParams.toString());
myURL.search = myURL.searchParams.toString();

2) 내장모듈- dns

내장 모듈 주로 도메인을 통해 IP나 기타 dns를 찾는데 쓰임

import dns from 'dns/promises';
const ip = await dns.lookup('gilbut.co.kr');
console.log(ip); //ip 주소 가져옴
const a = await dns.resolve('gilbut.co.kr', 'A');
console.log(a);  //ipv4 주소
const mx = await dns.resolve('gilbut.co.kr', 'MX');
console.log(mx); //메일서버 관련 정보들(=레코드 라고 부름)
const cname = await dns.resolve('www.gilbut.co.kr', 'CNAME');
console.log(cname); //별칭(www가 붙은 주소는 별칭인 경우가 많다) 
const any = await dns.resolve('gilbut.co.kr', 'ANY');
console.log(any); 

6. 내장모듈- crypto, util

1) crypto

암호화: 평문 -> 암호, 복호화: 암호 -> 평문 해시: 단방향 암호화의 대표주자: 암호화만 되고 복호화가 안됨

const crypto = require('crypto');
console.log(crypto.createHash('sha512').update('비밀번호').digest('base64'))
//비밀번호 라는 문자열을 해시로 바꿈

cipher, decipher : 양방향 암호화

const cipher = crypto.createCipheriv(algorithm, key, iv);
const decipher = crypto.createDecipheriv(algorithm, key, iv);

2) util

각종 편의 기능을 모아둠

deprecate 그 함수가 사용되었을 때 경고창을 띄움

const util = require('util');

const dontuse = util.deprecate((x, y) => {
    console.log(x + y);
}, 'dontuse 함수는 더이상 사용하지 마세요');

• console.log(x + y) 를 실행하여 8을 출력.
• 동시에 DeprecationWarning(사용 중단 경고) 이 발생하며, dontuse 함수는 더이상 사용하지 마세요 라는 메시지가 표시됨

promisify 콜백 기반 함수를 Promise 기반 함수로 변환

// crypto.randomBytes를 Promise 기반 함수로 변환
const promiseme = util.promisify(crypto.randombytes);
promiseme(64)
    .then((buf) => {
        console.log(buf.toString('base64'));
    })
    .catch((error) => {
        console.log(error);
    });