diff --git "a/1\354\243\274\354\260\250 /sunghyun/1week.md" "b/1\354\243\274\354\260\250 /sunghyun/1week.md"
new file mode 100644
index 0000000..f3bfc12
--- /dev/null
+++ "b/1\354\243\274\354\260\250 /sunghyun/1week.md"	
@@ -0,0 +1,102 @@
+# 04. 변수
+
+## 4.1 변수란 무엇? 왜 필요?
+
+### 변수가 무엇인지 알기 전에
+
+```js
+10 + 20;
+```
+
+- 자바스크립트 엔진이 자바스크립트 코드를 계산하려면 먼저 기호(리터럴과 연산자)를 알고 있어야 하고 표현식의 의미도 해석(파싱)할 수 있어야 한다.
+- `+` 연산을 수행하기 위해 `+` 연산자의 좌변과 우변의 숫자 값(피연산자)의 데이터를 메모리에 저장한다.
+- 컴퓨터는 사람을 모델로 고안되었다. 사람은 두뇌를 통해 기억을 담지만, 컴퓨터는 **메모리**를 통해서 데이터를 저장하는 셈이다.
+- 컴퓨터는 사람을 모델로 고안되었다는 사실을 항상 기억하자. 어떤 문제를 해결할 때 중요한 단서가 될 수도 있을 것 같다.
+
+### 무엇?
+
+- 하나의 값을 저장하기 위해 확보한 메모리 공간 자체 또는 그 메모리 주소를 식별하기 위해 붙인 이름
+- 프로그래밍 언어에서 값을 저장하고 참조하는 메커니즘
+- 값의 위치를 가리키는 상징적인 이름
+- 컴파일러 또는 인터프리터에 의해 값이 저장된 메모리 공간의 주소로 치환되어 저장된다.
+
+### 왜 변수라는 개념이 필요한가?
+
+- 메모리 주소는 임의로 결정된다. 메모리 주소는 코드가 실행될 때 결정되며 실행될 때마다 그 값이 변한다. 이는 시스템을 멈추게 하는 치명적인 오류를 야기할 수 있다.
+- 기억하고 싶은 값을 메모리에 저장하고, 저장된 값을 읽어 들여 재사용하기 위해서
+- 개발자가 직접 메모리 주소를 통해 값을 저장하고, 참조할 필요가 없고 변수를 통해 안전하게 값에 접근할 수 있다.
+
+### 변수 이름(변수명, 식별자)
+
+- 메모리 공간에 저장된 값을 식별할 수 있는 고유 이름
+- 사람이 이해할 수 있는 언어로 값이 저장된 메모리 공간에 붙인 상징적인 이름
+- 변수 이름을 사용해 참조를 요청하면 자바스크립트 엔진은 변수 이름과 매핑된 메모리 주소를 통해 메모리 공간에 접근해서 저장된 값을 반환한다.
+
+### 변수값
+
+- 변수에 저장된 값
+
+### 할당 (대입, 저장)
+
+- 변수게 값을 저장하는 것
+
+### 참조
+
+- 변수에 저장된 값을 읽어 들이는 것
+
+## 4.2 식별자
+
+> "10과 20을 연산한 결과 값을 메모리 주소 #1001에 저장할게. 이 메모리 주소와 매핑되어 있는 식별자는 sum이야."
+
+### 무엇?
+
+- 변수 이름, 함수, 클래스 등의 이름
+- 메모리 상에 존재하는 어떤 값을 식별할 수 있는 이름
+- 선언에 의해 자바스크립트 엔진에게 식별자의 존재를 알림
+- 특정 값은 메모리 공간에 저장되어 있기 때문에 식별자는 메모리 공간에 저장되어 있는 어떤 값을 구별해서 식별할 수 있어야 한다.
+
+### 역할
+
+- 어떤 값이 저장되어 있는 **메모리 주소**를 저장한다.
+- 값이 저장되어 있는 메모리 주소와 매핑 관계를 맺고 매핑 정보도 메모리에 저장됨
+
+### 어디에 등록되나?
+
+- 실행 컨텍스트에 등록된다. (실행 컨텍스트 : 자바스크립트 엔진이 소스코드를 평가하고 실행하기 위해 필요한 환경을 제공하고 코드의 실행 결과를 실제로 관리하는 영역. 식별자와 스코프를 관리한다. 자바스크립트 엔진이 변수를 관리할 수 있도록 변수의 존재를 알리는 것.)
+- 변수 이름과 값은 실행 컨텍스트 내에 객체 형태로 등록되어 관리된다.
+
+### 4.3 변수 선언
+
+> 변수 score을 선언하여 변수 이름을 등록한 후 #1001에 메모리 공간을 확보하고, undefined로 초기화 할게.
+
+## 무엇?
+
+- 변수를 생성하는 것
+- 값을 저장하기 위한 메모리 공간을 확보하고 변수 이름과 확보된 메모리 공간의 주소를 연결해서 값을 저장할 수 있게 준비하는 것
+- 변수 선언에 의해 확보된 메모리는 확보가 해제되기 전까지 누구도 확보된 메모리 공간을 사용할 수 없도록 보호되므로 안전하게 사용할 수 있음
+
+## 선언 방법
+
+```js
+var score; // 변수 선언
+```
+
+- `var`, `let`, `const` 키워드 사용
+- `var` vs `let`, `const`
+  - `var` : 함수 레벨 스코프
+  - `let`, `const` : 블록 레벨 스코프
+  - `var` 키워드는 함수의 스코프만을 지역 스코프로 인정한다. 따라서, 코드 블록 내에 선언해도 전역 변수가 되는 문제점이 있다.
+
+## 선언하면 어떤 일이 벌어지나?
+
+- 변수 이름을 등록하고 값을 저장할 메모리 공간에 `undefined`라는 값이 암묵적으로 할당되어 초기화 됨
+
+## 변수 초기화
+
+- 변수가 선언된 이후 최초로 값을 할당하는 것
+- 초기화를 거치지 않으면 확보된 메모리 공간에는 이전에 다른 애플리케이션이 사용했던 값(garbage value)이 남아있을 수 있음
+- 값을 할당하지 않은 상태에서 곧바로 변수 값을 참조하면 garbage value가 나올 수 있음
+
+## 변수를 선언하지 않으면?
+
+- ReferenceError(식별자를 통해 값을 참조하려 했지만 자바스크립트 엔진이 등록된 식별자를 찾을 수 없음)발생
diff --git "a/1\354\243\274\354\260\250/qkreltms/index.md" "b/1\354\243\274\354\260\250 /sunghyun/qkreltms/index.md"
similarity index 73%
rename from "1\354\243\274\354\260\250/qkreltms/index.md"
rename to "1\354\243\274\354\260\250 /sunghyun/qkreltms/index.md"
index f5b437d..03971da 100644
--- "a/1\354\243\274\354\260\250/qkreltms/index.md"
+++ "b/1\354\243\274\354\260\250 /sunghyun/qkreltms/index.md"	
@@ -1,5 +1,7 @@
 # 1주차 정리
+
 ## 4장 변수
+
 변수 또는 식별자란?
 
 메모리에서 어떤 값이 저장되어있는 주소를 가리키는 상징적인 이름이다.
@@ -12,28 +14,33 @@ JS는 개발자의 직접적인 메모리 제어를 허용하지 않는다.
 
 소스코드 실행시 변수 선언 이나 모든 선언문(함수, 클래스 등)은 런타임 이전에 실행된다. 따라서 변수가 어디에서 선언이 되던지 접근이 가능하다. 이것을 전문용어로 호이스팅이라 부름.(단, let,const 등은 제한이 있음) 이 때에 변수는 메모리의 쓰레기 값을 보여주지 않기 위해 undefined로 자동 초기화 된다.
 
-변수 네이밍 규칙: 예약어, 숫자, 특수문자를 제외한 문자, (_), ($)로 시작해야한다.
+변수 네이밍 규칙: 예약어, 숫자, 특수문자를 제외한 문자, (\_), ($)로 시작해야한다.
 
 ## 5장 표현식과 문
+
 표현식(expression): 평가되어 값을 생성할 수 있는 문
 
-문(statement): 프로그램을 구성하는 기본 단위이자 최소 실행 단위. 
+문(statement): 프로그램을 구성하는 기본 단위이자 최소 실행 단위.
+
+예:
 
-예: 
 ```js
-var score = 50 + 50 // 문 + 표현식
+var score = 50 + 50; // 문 + 표현식
 
-console.log(score) // 문 + 표현식.
+console.log(score); // 문 + 표현식.
 
-a=b=c=0 // 문 + 표현식
+a = b = c = 0; // 문 + 표현식
 
-if (true) {} // 제어문(제어 + 문)
+if (true) {
+} // 제어문(제어 + 문)
 ```
+
 리터럴(literal): 사람이 이해할 수 있는 문자 또는 약속된 기호를 사용해 값을 생성하는 표기법 예: 3
 
 세미콜론은 Optional이나 ASI(automatic semicolon insertion)에 의해 자동 삽입된다.
 
 ## 6장 데이터 타입
+
 원시 타입(총 6개)
 
 1. 숫자, 문자열, 불리언, undefined, null, Symbol
@@ -64,6 +71,7 @@ undefined은 JS 엔진이 변수를 초기화하 데 사용하므로 의도적
 자바스크립트 변수는 선언이 아닌 할당에 의해 타입이 결정된다.(타입 추론) 재할당을 통해 언제든지 동적으로 변할수 있다.
 
 ## 7장 연산자
+
 연산자란?
 
 하나 이상의 표현식을 대상으로 산술, 할당, 비교, 논리, 지수 연상 등을 수행해 하나의 값을 만든다. 이때 연산의 대상을 피연산자(operand)라 한다.
@@ -71,20 +79,15 @@ undefined은 JS 엔진이 변수를 초기화하 데 사용하므로 의도적
 숫자 타입이 아닌 피연산자에 + 단항 연산자를 사용하면 피연산자를 숫자 타입으로 암묵적으로 변환하여 반환한다.
 
 ```js
-+'1' = 1
-
-+true = 1
-
-+'hello' = NaN 
-
-+undefined = NaN
++"1" = 1 + true = 1 + "hello" = NaN + undefined = NaN;
 ```
 
 피연산자 중 하나 이상이 문자열인 경우 문자열 연산자로 피연산자를 문자열 타입으로 암묵적 변환하여 동작한다.
+
 ```js
-'1'+2 = '12'
+"1" + 2 = "12";
 // true 1로 암시적 변환된다.
-1+true = 2
+1 + true = 2;
 ```
 
 비교연산자
@@ -94,18 +97,20 @@ undefined은 JS 엔진이 변수를 초기화하 데 사용하므로 의도적
 반면 일치 비교 연산자(===) 는 타입과 값을 비교한다.
 
 예외
-```js
-NaN === NaN // false
-isNaN(NaN) // true
-isNaN(1+undefined) // true
 
--0 === +0 // true
+```js
+NaN === NaN; // false
+isNaN(NaN); // true
+isNaN(1 + undefined) - // true
+  0 ===
+  +0; // true
 // ES6, 더 예측가능한 비교를 위해서 Object.is 사용
-Object.is(-0,+0) // false
-Object.is(NaN,NaN) // true
+Object.is(-0, +0); // false
+Object.is(NaN, NaN); // true
 ```
 
 js는 python과 다르게 set에 대해 논리 연산자(||, &&, !)를 쓸 수 없다.
+
 ```py
 set([1,2,3]) | set([3,4,5]) # {1,2,3,4,5}
 set([1,2,3]) & set([3,4,5]) # {3}
@@ -113,24 +118,28 @@ set([1,2,3]) - set([3,4,5]) # {1,2}
 ```
 
 ```js
-const union = (first, second) => { // first: set, second: set
-  const union = [...first]; 
-  second.forEach((value) => { if (!union.includes(value)) union.push(value); }) 
+const union = (first, second) => {
+  // first: set, second: set
+  const union = [...first];
+  second.forEach((value) => {
+    if (!union.includes(value)) union.push(value);
+  });
   // 없을 때에만 추가 해준다. (합집합 중복 방지)
   return union;
-}
+};
 
-const intersect = function(first, second) { // first: set, second: set
-  return first.filter(value => second.includes(value)); // 둘 다 있으면 교집합
-}
+const intersect = function (first, second) {
+  // first: set, second: set
+  return first.filter((value) => second.includes(value)); // 둘 다 있으면 교집합
+};
 
-const complement = function(first, second) { // first: set, second: set
-  return first.filter(value => !second.includes(value)); // 중복되는 것 제거하면 차집합
-}
+const complement = function (first, second) {
+  // first: set, second: set
+  return first.filter((value) => !second.includes(value)); // 중복되는 것 제거하면 차집합
+};
 
-
-const setA = new Set([1,2,3])
-const setB = new Set([3,4,5]);
+const setA = new Set([1, 2, 3]);
+const setB = new Set([3, 4, 5]);
 
 union(setA, setB); // Set([1,2,3,4,5])
 intersect(setA, setB); // Set([3])
@@ -141,18 +150,23 @@ complement(setB, setA); // Set([4,5])
 js 버그
 
 ```js
-typeof null // null이 아닌 object가 나온다.
+typeof null; // null이 아닌 object가 나온다.
 // 따라서 null 타입 확인시 일치 연산자(===)를 사용
-foo = null
-foo === null // true
+foo = null;
+foo === null; // true
 ```
 
 지수 연산자
+
 ```js
-2**2 = 4 // 2^2
-Math.pow(2,2) = 4// 2^2
+2 ** 2 = 4; // 2^2
+Math.pow(2, 2) = 4 - // 2^2
 // 주의!!
--5 ** 2 = error // 이와 반해 c 계열, python은 -25가 나온다. 왼쪽 피연산자를 양수로 암묵적 변환 후 5^2 계산, 음수를 입혀준다. 아래의 방법으로 해야 잘 나온다.
+5 ** 2 = error(
+  // 이와 반해 c 계열, python은 -25가 나온다. 왼쪽 피연산자를 양수로 암묵적 변환 후 5^2 계산, 음수를 입혀준다. 아래의 방법으로 해야 잘 나온다.
 
-(-5) ** 2 - 1 = -25 
+  -5
+) **
+  2 -
+1 = -25;
 ```
diff --git "a/2\354\243\274\354\260\250 / sunghyun/2week.md" "b/2\354\243\274\354\260\250 / sunghyun/2week.md"
new file mode 100644
index 0000000..859fc14
--- /dev/null
+++ "b/2\354\243\274\354\260\250 / sunghyun/2week.md"	
@@ -0,0 +1,658 @@
+- [08. 제어문](#08-제어문)
+  - [8.1 블록문](#81-블록문)
+  - [8.2 조건문](#82-조건문)
+    - [8.2.1 if ... else 문](#821-if--else-문)
+      - [삼항 연산자](#삼항-연산자)
+    - [8.2.2 switch 문](#822-switch-문)
+  - [8.3 반복문](#83-반복문)
+    - [8.3.1 for문](#831-for문)
+    - [8.3.2 while 문](#832-while-문)
+    - [8.3.3 do... while 문](#833-do-while-문)
+  - [8.4 break](#84-break)
+    - [8.5 continue](#85-continue)
+- [09. 타입 변환과 단축 평가](#09-타입-변환과-단축-평가)
+  - [9.1 타입 변환이란](#91-타입-변환이란)
+  - [9.2 암묵적 타입 변환](#92-암묵적-타입-변환)
+    - [9.2.1 문자열 타입으로 변환](#921-문자열-타입으로-변환)
+    - [9.2.2 숫자 타입으로 변환](#922-숫자-타입으로-변환)
+    - [9.2.3 불리언 타입으로 변환](#923-불리언-타입으로-변환)
+  - [9.3 명시적 타입 변환](#93-명시적-타입-변환)
+    - [9.3.1 문자열 타입으로 변환](#931-문자열-타입으로-변환)
+    - [9.3.2 숫자 타입으로 변환](#932-숫자-타입으로-변환)
+    - [9.3.3 불리언 타입으로 변환](#933-불리언-타입으로-변환)
+  - [9.4 단축 평가](#94-단축-평가)
+    - [9.4.1 논리 연산자를 사용한 단축 평가](#941-논리-연산자를-사용한-단축-평가)
+    - [9.4.2 옵셔널 체이닝 연산자](#942-옵셔널-체이닝-연산자)
+    - [9.4.3 null 병합 연산자](#943-null-병합-연산자)
+- [10. 객체 리터럴](#10-객체-리터럴)
+  - [10.1 객체란?](#101-객체란)
+  - [10.2 객체 리터럴에 의한 생성](#102-객체-리터럴에-의한-생성)
+  - [10.3 프로퍼티](#103-프로퍼티)
+  - [10.4 메서드](#104-메서드)
+  - [10.5 프로퍼티 접근](#105-프로퍼티-접근)
+  - [10.6 프로퍼티 값 갱신](#106-프로퍼티-값-갱신)
+  - [10.7 프로퍼티 동적 생성](#107-프로퍼티-동적-생성)
+  - [10.8 프로퍼티 삭제](#108-프로퍼티-삭제)
+  - [10.9 ES6에서 추가된 객체 리터럴의 확장 기능](#109-es6에서-추가된-객체-리터럴의-확장-기능)
+  - [11. 원시 값과 객체의 비교](#11-원시-값과-객체의-비교)
+    - [11.1 원시 값](#111-원시-값)
+    - [12.2 객체](#122-객체)
+
+# 08. 제어문
+
+- 제어문은 조건에 따라 코드 블록을 실행(조건문)하거나 반복 실행(반복문)할 때 사용함
+- 일반적으로 코드는 위에서 아래 방향으로 순차적으로 실행됨
+
+## 8.1 블록문
+
+```js
+// 블록문
+{
+  var foo = 10;
+}
+// 제어문
+var x = 1;
+if (x < 10) {
+  x++;
+}
+// 함수 선언문
+function sum(a, b) {
+  return a + b;
+}
+```
+
+- 블록문은 0개 이상의 문을 중괄호로 묶은 것으로 코드 블록 또는 블록이라고 칭함
+- 자바스크립트는 블록문을 하나의 실행 단위로 취급함
+- 단독으로 사용할 수도 있으나 일반적으로 제어문이나 함수를 정의할 때 사용함
+
+## 8.2 조건문
+
+- 조건(불리언 값)에 따라 코드 블록의 실행을 결정함
+- 자바스크립트는 `if문`, `switch` 두 가지 조건문을 제공한다.
+
+### 8.2.1 if ... else 문
+
+```js
+if (조건식) {
+  // 참이면 해당 코드 블록을 실행
+} else {
+  // 거짓이면 해당 코드 블록을 실행
+}
+```
+
+- 참 또는 거짓에 따라 실행할 코드 블록을 결정함
+- 조건식(불리언 값으로 평가될 수 있는 표현식)의 결과가 `true`일 경우 if문의 코드 블록이 실행됨
+- 조건식의 결과가 `false`일 경우 else문의 코드 블록이 실행됨
+- if문의 조건식이 불리언 값이 아닌 값으로 평가되면 암묵적으로 강제 변환됨
+
+```js
+if (조건식1) {
+  // 조건식1이 참이면 실행
+} else if (조건식2) {
+  // 조건식2가 참이면 실행
+} else {
+  // 조건식1과 2가 모두 거짓이면 실행
+}
+```
+
+- 조건식을 추가하고 싶으면 `else if`문을 사용
+- `else if`과 `else`은 옵션임
+- `if`와 `else`는 한 번만 사용할 수 있지만, `else if`는 여러 번 사용 가능
+- 코드 블록 내의 문이 하나뿐이면 중괄호 생략 가능
+<details>
+
+<summary>펼치기</summary>
+
+```js
+let num = 2;
+let kind;
+
+// if
+if (num > 0) {
+  kind = "양수"; // 음수를 구별할 수 없다.
+}
+console.log(kind); // 양수
+
+// if ... else
+if (num > 0) {
+  kind = "양수";
+} else {
+  kind = "음수"; // 0은 음수가 아니다.
+}
+console.log(kind); // 양수
+
+// if ... else if
+if (num > 0) {
+  kind = "양수";
+} else if (num < 0) {
+  kind = "음수";
+} else {
+  kind = "영";
+}
+console.log(kind); //양수
+```
+
+</details>
+
+#### 삼항 연산자
+
+- `if else`문은 삼항 조건 연산자로 바꿔 쓸 수 있음
+
+<details>
+
+<summary>펼치기</summary>
+  
+> if else
+```js
+let x = 2;
+let result;
+
+if (x % 2) {
+result = "홀수";
+} else {
+result = "짝수";
+}
+console.log(result); // 짝수
+
+````
+> 삼항 연산자
+
+- 두 가지 경우의 수(홀수 또는 짝수)
+
+```js
+let x = 2;
+let result = x % 2 ? '홀수' : '짝수';
+console.log(result);
+````
+
+- 세 가지 경우의 수(양수, 음수, 영을 갖는 경우)
+
+```js
+let num = 2;
+var kind = num ? (num > 0 ? : '양수' : '음수') : '영'
+```
+
+- 조건에 따라 단순히 값을 결정하여 변수에 할당하는 경우에는 삼항 조건 연산자를 사용하는 게 좋음
+- 삼항 조건 연산자 표현식은 값처럼 사용할 수 있기 때문에 변수에 할당할 수 있음
+</details>
+
+### 8.2.2 switch 문
+
+- 모든 `switch` 문은 `if` 문으로 대체할 수 있다. 하지만,`case`가 다양한 상황의 경우 `switch` 문을 사용해서 깔끔하게 코드를 작성할 수 있음
+
+```js
+let fruit = prompt("무슨 과일을 원하시나요?");
+switch (fruit) {
+  case "사과":
+    console.log("100원입니다.");
+    break;
+  case "바나나":
+  case "메론":
+    console.log("200원입니다.");
+    break;
+  case "망고":
+    console.log("300원입니다.");
+  default:
+    console.log("그런 과일은 없습니다.");
+}
+```
+
+- `if` 문의 else 역할을 `default`가 수행한다.
+
+## 8.3 반복문
+
+- 조건식이 참일 경우 코드 블록을 실행하고 조건식이 거짓일 때까지 코드 블록을 반복 실행함
+
+### 8.3.1 for문
+
+```js
+
+for (변수 선언문 또는 할당문; 조건식; 증감식;){
+  조건식이 참인 경우 반복 실행될 문;
+}
+
+for (let i = 0; i < 3; i++) {
+  console.log(i);
+}
+// 0
+// 1
+// 2
+```
+
+- `for` 문을 실행하면 맨 먼저 변수 선언문 `let i = 0`이 실행되며 변수 선언문은 단 한 번만 실행됨
+- 조건식이 실행되며 현재 `i`의 값은 0이므로 조건식의 평가 결과는 `true`임
+- 조건식 평가 결과가 `true`이므로 코드 블록이 실행됨
+- **증감문으로 실행 흐름이 이동하는 것이 아니라 코드 블록으로 실행 흐름이 이동하는 것에 주의**
+- `for` 문의 선언문, 조건식, 증감식은 모두 옵션이므로 반드시 사용할 필요는 없지만 어떤 식도 선언하지 않으면 무한루프가 됨
+
+**중첩 for문**
+
+```js
+for (let i = 0; i <= 6; i++) {
+  for (let j = 0; j <= 6; j++) {
+    if (i + j === 6) console.log(`[${i}, ${j}]`);
+  }
+}
+// [0, 6]
+// [1, 5]
+// [2, 4]
+// [3, 3]
+// [4, 2]
+// [5, 1]
+// [6, 0]
+```
+
+- `i`가 실행되고 안 쪽 for 문으로 들어가서 `j`의 조건식이 만족할 때까지 실행되고 다시 `i`가 실행됨(`i`는 증가)
+
+### 8.3.2 while 문
+
+- 반복 횟수가 명확하지 않은 상황에 주로 사용함
+
+```js
+let count = 0;
+
+// 무한루프
+while (true) {
+  console.log(count);
+  count++;
+  // count가 3이면 코드 블록을 탈출
+  if (count === 3) break;
+}
+```
+
+- 조건식의 평가 결과가 언제나 참이면 무한루프가 된다.
+- `if` 문으로 탈출 조건을 만들고 `break` 문으로 코드 블록을 탈출
+
+### 8.3.3 do... while 문
+
+- 코드 블록을 먼저 실행하고 조건식을 평가함. 따라서 코드 블록은 무조건 한 번 이상 실행됨
+
+```js
+let count = 0;
+// count가 3보다 작을 때까지 코드 블록 반복 실행
+do {
+  console.log(count);
+  count++;
+} while (count < 3);
+```
+
+## 8.4 break
+
+- 코드 블록을 탈출할 때 사용하는데 정확히 표현하면 **레이블 문, 반복문(for, for...in, for...of, while, do...while), switch 문**의 코드 블록을 탈출함
+- 레이블 문, 반복문, switch 문의 코드 블록 외에 `break`를 사용하면 `SyntaxError` 발생
+- 레이블 문이란 식별자가 붙은 문을 말함
+  - 즉, break 문에도 식별자를 지정하는 셈
+  - 중첩된 `for` 문 외부로 탈출할 때 유용하지만 가독성이 저하되고 오류를 야기할 수 있어서 권장하지 않음
+
+```js
+if (true) {
+  break; // Uncaught SyntaxError: Illegal break statement
+}
+```
+
+문자열에서 특정 문자의 인덱스(위치)를 검색하는 예
+
+```js
+let string = "Hello word";
+let search = "l";
+let index;
+// 문자열은 유사 배열이므로 for 문으로 순회 가능
+for (let i = 0; i < string.length; i++) {
+  // 문자열의 개별 문자가 'l'이면
+  if (string[i] === search) {
+    index = i;
+    break; // 반복문 탈출
+  }
+}
+console.log(index); // 2
+```
+
+### 8.5 continue
+
+- 반복문의 코드 블록 실행을 현 지점에서 중단하고 반복문의 **증감식**으로 실행 흐름을 이동시킴
+- `break`처럼 반복문을 탈출하지는 않는다.
+
+# 09. 타입 변환과 단축 평가
+
+## 9.1 타입 변환이란
+
+- 자바스크립트의 모든 값에는 타입이 있음
+- 개발자가 의도적으로 값의 타입을 변환하는 것은 **명시적 타입 변환** 또는 **타입 캐스팅**이라고 함
+- 자바스크립트 엔진이 암묵적으로 변환하는 것을 **암묵적 타입 변환** 또는 **타입 강제 변환**이라고 함
+
+## 9.2 암묵적 타입 변환
+
+### 9.2.1 문자열 타입으로 변환
+
+- 문자열 타입이 아닌 값을 문자열 타입으로 변환함
+
+```js
+0 + ""; // "0"
+true + "진짜"; // "ture진짜"
+Array + ""; // 'function Array() { [native code] }'
+```
+
+### 9.2.2 숫자 타입으로 변환
+
+```js
+1 / "one" + // NaN
+  "string" + // NaN
+  undefined + // NaN
+  // 객체 타입
+  {} + // NaN
+  [10, 20] + // NaN
+  function () {}; // NaN
+```
+
+- 피연산자를 숫자 타입으로 변환할 수 없는 경우는 산술 연산을 수행할 수 없으므로 평가 결과는 `NaN`이 됨
+
+```js
+"1" > 0; // true
+```
+
+- 위에서 비교 연산자는 불리언 값을 만드는데 이때 자바스크립트 엔진은 암묵적으로 피연산자를 숫자 타입으로 변환함
+
+### 9.2.3 불리언 타입으로 변환
+
+```js
+if ("") console.log("1"); // falsy
+if (true) console.log("2"); // truthy
+if (0) console.log("3"); // falsy
+if ("str") console.log("4"); // truthy
+if (null) console.log("5"); // falsy
+```
+
+- 자바스크립트 엔진은 조건식의 평가 결과를 불리언 타입으로 암묵적으로 변환함
+- 이때 자바스크립트 엔진은 **Truthy(참으로 평가되는 값)과 Falsy(거짓으로 평가되는 값)** 을 구분
+
+**Falsy 값**
+
+- false
+- undefined
+- null
+- 0, -0
+- NaN
+- ''(빈 문자열)
+
+**Truth 값**
+
+- '0' (0을 포함하는 문자열)
+- 'false' (false를 포함하는 문자열)
+- [] (빈 배열)
+- {} (빈 객체)
+- function () {} (빈 함수)
+
+`Falsy` 값 외의 모든 값은 모두 ture로 평가되는 Truthy 값
+
+## 9.3 명시적 타입 변환
+
+### 9.3.1 문자열 타입으로 변환
+
+- String 생성자 함수를 new 연산자 없이 호출하는 방법
+
+```js
+// 숫자 타입 => 문자열 타입
+String(1);
+String(NaN);
+String(Infinity);
+// 불리언 타입 => 문자열 타입
+String(true);
+String(false);
+```
+
+- Object.prototype.toString 메서드를 사용하는 방법
+
+```js
+(1).toString(); // "1"
+NaN.toString(); // "NaN"
+```
+
+- 문자열 연결 연산자를 이용하는 방법
+
+```js
+1 + ""; // "1"
+true + ""; // "true
+```
+
+### 9.3.2 숫자 타입으로 변환
+
+- Number 생성자 함수를 new 연산자 없이 호출하는 방법
+
+```js
+Number(1); // 1
+Number("hi"); // 숫자 타입으로 변경할 수 없으므로 NaN
+Number("10.53"); // 10.35
+```
+
+- parseInt, parseFloat 함수를 사용하는 방법(문자열만 숫자 타입으로 변환 가능)
+
+```js
+parseInt("0"); // 0
+parseInt("-1001"); // -1001
+parseFlat("10.53"); // 10.53
+```
+
+- `+` 단항 산술 연산자를 이용하는 방법
+
+```js
++0; // 0
++"-1"; // -1
+// 불리언 타입 => 숫자 타입
++true; // 1
++false; // 0
+```
+
+- `*` 산술 연산자를 이용하는 방법
+
+```js
+"0" * 1; // 0
+1 * "456"; // 456
+"10.53" * 1; // 10.53
+```
+
+### 9.3.3 불리언 타입으로 변환
+
+- Boolean 생성자 함수를 new 연산자 없이 호출하는 방법
+
+```js
+Boolean("x"); // true
+Boolean(""); // false
+Boolean("false"); // true
+Boolean(null); // false
+Boolean(undefined); // false
+Boolean({}); // true
+Boolean([]); // true
+```
+
+- ! 부정 논리 연산자를 두 번 사용하는 방법
+
+```js
+!!"x"; // true
+!!""; // false
+!!{}; // true
+```
+
+## 9.4 단축 평가
+
+### 9.4.1 논리 연산자를 사용한 단축 평가
+
+- `||` 연산자
+- `&&` 연산자
+
+위의 논리 연산자를 사용해서 표현식을 평가할 때 도중에 결과가 확정된 경우 나머지 과정을 생략할 수 있는데 이를 **단축 평가**라고 함
+
+| 단축 평가 표현식    | 평가 결과 |
+| ------------------- | --------- | --------- | -------- |
+| `true               |           | anything` | true     |
+| `false              |           | anything` | anything |
+| `true && anything`  | anything  |
+| `false && anything` | false     |
+
+- 참일 경우, `&&` 연산자는 두 번째 피연산자의 문자열을 반환함
+
+### 9.4.2 옵셔널 체이닝 연산자
+
+- 옵셔널 체이닝 연산자(`?.`)는 좌항의 피연산자가 `null` 또는 `undefined`인 경우 `undefined`를 반환하고, 그렇지 않으면 우항의 참조를 이어간다.
+
+```js
+let elem = null;
+let value = elem?.value;
+console.log(value); // undefined
+```
+
+- 옵셔널 체이닝 연산자(`?.`)는 객체를 가리키기를 기대하는 변수가 `null` 또는 `undeinfed`가 아닌지 확인하고 프로퍼티를 참조할 때 유용함
+
+### 9.4.3 null 병합 연산자
+
+```js
+let foo = null ?? "default string";
+console.log(foo); // "default string"
+```
+
+- ES11에서 새로 도입되었고 null 병합 연산자(`??`)는 좌항의 피연산자가 `null` 또는 `undefined`인 경우 우항의 피연산자를 반환하고, 그렇지 않으면 좌항의 피연산자를 반환함
+
+# 10. 객체 리터럴
+
+## 10.1 객체란?
+
+- 자바스크립트는 프로토타입 객체 기반의 언어이며 자바스크립트를 구성하는 모든 것이 객체임
+- 원시 타입은 단 하나의 값을 나타내지만, 객체 타입은 **다양한 값(원시 값 또는 다른 객체**를 하나의 단위로 구성한 복합적인 **자료구조**다.
+- 원시 값은 **변경 불가능한 값(immutable value)** 이지만, 객체는 **변경 가능한 값(mutable value)**
+- 객체는 프로퍼티로 구성된 집합
+  - 프로퍼티 : 키와 값으로 구성되어 있으며 이를 통해 객체의 상태를 나타내는 값
+  - 메서드 : 프로퍼티를 조작할 수 있는 동작을 나타내는 값
+
+## 10.2 객체 리터럴에 의한 생성
+
+- `C++`, `JAVA`는 클래스 기반의 객체지향 언어는 사전에 클래스를 정의하고 필요한 시점에 호출하는 방식으로 객체를 생성함
+- `JavaScript`는 프로토타입 기반의 객체지향 언어로서 다양한 객체 생성 방법을 지원함
+  - 객체 리터럴
+  - Object 생성자 함수
+  - 생성자 함수
+  - Object.create 메서드
+  - 클래스(ES6)
+
+위와 같은 방식으로 객체를 생성할 수 있는데 이를 통해 자바스크립트의 유연함(?)을 확인할 수 있음 이는 독이 될 수도 있겠다만..
+
+## 10.3 프로퍼티
+
+```js
+let person = {
+  name: "jeon",
+  age: 27,
+};
+```
+
+- 위와 같이 프로퍼티는 키와 값으로 구성되어 있음
+- 네이밍 규칙을 준수해야 함
+
+## 10.4 메서드
+
+- 자바스크립트에서 사용할 수 있는 모든 값으 `프로퍼티 값`으로 사용할 수 있음
+- 자바스크립트의 함수는 일급 객체임. 함수를 값으로 취급할 수 있기 때문에 프로퍼티 값으로 사용할 수 있음
+- 이를 메서드라고 함. 즉, 메서드는 객체에 묶여 있는 함수를 의미
+
+```js
+let circle = {
+  radius: 5, // 프로퍼티
+  // 원의 지름
+  getDiameter: function () {
+    // 메서드
+    return 2 * this.radius; // this는 circle을 가리킴
+  },
+};
+console.log(circle.getDiameter()); // 10
+```
+
+## 10.5 프로퍼티 접근
+
+- 마침표(`.`)를 통해 접근
+- 대괄호(`[]`)를 통해 접근
+
+```js
+let person = {
+  name: "jeon",
+  age: 27,
+};
+console.log(person.name); // 'jeon'
+console.log(person["age"]); // 27
+```
+
+## 10.6 프로퍼티 값 갱신
+
+- 이미 존재하는 프로퍼티에 값을 재할당하면 프로퍼티 값이 갱신됨
+
+## 10.7 프로퍼티 동적 생성
+
+```js
+let person = {
+  name: "jeon",
+};
+person.age = 27;
+console.log(person); // {name:'jeon', age:27}
+```
+
+## 10.8 프로퍼티 삭제
+
+```js
+let person = {
+  name: "jeon",
+};
+// 프로퍼티 동적 생성
+person.age = 27;
+delete person.age;
+console.log(person); // {name:'jeon'}
+```
+
+## 10.9 ES6에서 추가된 객체 리터럴의 확장 기능
+
+- 프로퍼티 축약 표현
+- 계산된 프로퍼티 이름
+- 메서드 축약 표현
+
+## 11. 원시 값과 객체의 비교
+
+- 원시 타입의 값은 변경 불변값
+- 객체 타입의 값은 변경 가능한 값
+- 원시 값을 변수에 할당하면 메모리 공간에는 실제 값이 저장됨
+- 객체를 변수에 할당하면 메모리 공간의 주소(참조 값)이 저장됨
+
+### 11.1 원시 값
+
+**변경 불가능한 값**
+
+- 원시 값의 변경은 재할당을 통해서만 가능함
+
+**값에 의한 전달**
+
+```js
+let score = 80;
+let copy = score;
+// console.log(score); // 80
+// console.log(copy); // 80
+score = 100;
+// console.log(score); // 100
+// console.log(copy); // 80;
+```
+
+- score 변수와 copy 변수의 값은 다른 메모리 공간에 저장된 별개의 값임
+
+### 12.2 객체
+
+**변경 가능한 값**
+
+- 객체를 할당한 변수는 재할당 없이 객체를 직접 변경할 수 있음
+- 객체를 할당한 변수가 메모리 주소를 통해 메모리 공간에 접근하면 참조값에 접근할 수 있음
+- 여러 개의 식별자가 하나의 객체를 공유할 수 있음
+
+**참조에 의한 전달**
+
+```js
+let person = {
+  name: "jeon",
+};
+let copy = person;
+```
+
+- 객체를 가리키는 변수(원본, person)를 다른 변수(사본, copy)에 할당하면 원본의 참조 값이 복사되어 전달됨
+- 두 개의 식별자가 하나의 객체를 공유하는 셈
diff --git "a/3\354\243\274\354\260\250 / sunghyun/3week.md" "b/3\354\243\274\354\260\250 / sunghyun/3week.md"
new file mode 100644
index 0000000..26e4298
--- /dev/null
+++ "b/3\354\243\274\354\260\250 / sunghyun/3week.md"	
@@ -0,0 +1,329 @@
+# 12. 함수
+
+## 12.1 함수란?
+
+- 함수는 일련의 과정을 문(statement)으로 구현하고 코드 블록으로 감싸서 하나의 **실행 단위**로 정의한 것
+
+## 12.2 함수를 사용하는 이유
+
+- 반복되는 코드의 재사용을 위해 사용함
+
+## 12.3 함수 리터럴
+
+```js
+// 변수에 함수 리터럴을 할당
+let f = function add(x, y) {
+  return x * y;
+};
+```
+
+- 자바스크립트의 함수는 객체 타입의 값임
+- 객체를 객체 리터럴로 생성하는 것처럼 함수도 리터럴로 생성할 수 있음
+- 사람이 이해할 수 있도록 표기하는 것이 리터럴 방식이었음
+- 함수 리터럴 또한 평가되어 값을 생성하는데 이 값은 객체
+- **즉, 함수는 객체다.**
+
+**함수 리터럴의 구성 요소**
+
+- 함수 이름
+  - 함수 이름은 식별자, 따라서 네이밍 규칙을 준수
+  - **함수 이름은 함수 몸체 내에서만 참조할 수 있는 식별자**
+  - 함수 이름은 생략 가능 (익명 함수, 기명 함수)
+- 매개변수
+  - 함수를 호출할 때 지정한 인수는 순서대로 할당
+  - **매개변수는 함수 몸체 내에서 변수와 동일하게 취급**
+  - 변수와 마찬가지로 식별자 네이밍 규칙을 준수
+- 함수 몸체
+
+## 12.4 함수 정의
+
+- 함수 선언문
+- 함수 표현식
+- Function 생성자 함수
+- 화살표 함수(ES6)
+
+### 12.4.1 함수 선언문
+
+```js
+function add(x, y) {
+  return x * y;
+}
+```
+
+- 함수 리터럴과 형태가 동일함
+- 단, 함수 선언문은 함수 이름을 생략할 수 없음
+- 자바스크립트 엔진은 암묵적으로 함수 선언문을 **함수 표현식**으로 변환해 함수 객체를 생성함
+
+### 12.4.2 함수 표현식
+
+```js
+let add = function add(x, y) {
+  return x * y;
+};
+```
+
+- 함수를 리터럴로 생성한 함수 객체를 변수에 할당하는 함수 정의 방식
+- 함수 표현식의 함수 리터럴은 함수 이름을 생략하는 것이 일반적임
+  - 단, 재귀적으로 사용하거나 디버깅을 할 때 기명으로 표기하기도 함
+
+### 12.4.3 함수 생성 시점과 함수 호이스팅
+
+- 함수 선언문으로 정의한 함수는 런타임 이전에 함수 객체가 먼저 생성됨
+- 따라서 선언문 이전에 함수를 미리 참조하고 호출할 수 있음
+- 이처럼 함수 선언문이 코드의 선두로 끌어 올려진 것처럼 동작하는 특징을 **함수 호이스팅**이라고 함
+
+cf. 함수 호이스팅과 변수 호이스팅
+
+- `var` 키워드를 사용한 `변수 선언문`과 `함수 선언문`은 런타임 이전에 자바스크립트 엔진에 의해 먼저 실행되어 식별자를 생성한다는 점에서 동일함
+- `var` 키워드를 사용한 변수 선언문 이전에 변수를 참조하면 `undefined`
+- 반면에 `함수 선언문`으로 정의한 함수를 함수 선언문 이전에 호출이 가능함
+- 함수 선언문으로 작성한 함수는 함수 호이스팅이 발생하는 것
+- 함수 표현식으로 함수를 정의하면 변수 호이스팅이 발생하는 것
+  - 따라서 함수 표현식으로 정의한 함수는 반드시 함수 표현식 이후에 호출해야 함
+- 더글라스 크락포드는 함수 선언문 대신 함수 표현식을 사용할 것을 권장한다고 함
+
+### 12.4.4 Function 생성자 함수
+
+```js
+let add = new Function("x", "y", "return x+y");
+console.log(add(2, 5)()); // 7
+```
+
+- 빌트인 Function 생성자 함수를 통해 함수를 생성하는 방식
+- 해당 방식으로 생성한 함수는 클로저를 생성하지 않는 등
+- 함수 선언문이나 함수 표현식으로 생성한 함수와 다르게 동작한다고 함
+
+(해당 부분은 책 후반부에서 자세히 다룰 예정)
+
+### 12.4.5 화살표 함수
+
+```js
+const add = (x, y) => x * y;
+console.log(add(2, 5)()); // 10
+```
+
+- 화살표 함수는 항상 익명으로 정의함
+- 함수 선언문 또는 함수 표현식을 완전히 대체하기 위해 고안된 것은 아님
+- 표현만 간략한 것이 아니라 내부 동작 또한 간략화되어 있음
+- `this` 바인딩 방식이 다르고 `prototype` 프로퍼티가 없으며 `arguments` 객체를 생성하지 않음
+
+(해당 부분은 책 후반부에서 자세히 다룰 예정)
+
+## 12.5 함수 호출
+
+- 함수를 호출하면 현재의 실행 흐름을 중단하고 호출된 함수로 실행 흐름을 옮김
+
+### 12.5.1 매개변수와 인수
+
+- 매개변수는 함수 몸체 내부에서 변수와 동일하게 취급
+- 함수가 호출되면 함수 내부에서 암묵적으로 매개변수가 생성되고 일반 변수와 마찬가지로 `undefined`로 초기화된 이후 인수가 순서대로 할당됨
+  - **[Q. 질문]** 매개변수가 암묵적으로 생성되는 거면 이 매개변수는 함수 식별자 내부에서 또 다른 식별자가 되는 걸까요? 예를 들면 매개변수를 x와 y로 지정한다고 했을 때 x와 y도 식별자가 되는 것인지?
+- 매개변수는 함수 내부에서만 참조할 수 있음
+- 즉, 매개변수의 스코프는 함수 내부
+- 인수가 부족해서 할당하지 않는 매개변수의 값은 `undefined`
+- 매개변수보다 초과된 인수는 무시됨
+  - 모든 인수는 암묵적으로 `arguments` 객체의 프로퍼티로 보관됨 (초과된 인수 포함)
+
+### 12.5.2 인수 확인
+
+- 자바스크립트 함수는 매개변수와 인수의 개수가 일치하는지 확인하지 않음
+- 자바스크립트는 동적 타입의 언어임
+- 따라서 자바스크립트 함수는 매개변수의 타입을 사전에 지정할 수 없음
+- ES6에서 도입된 매개변수 `기본값`을 사용하면 함수 내에서 인수 체크 및 초기화를 간소화할 수 있음
+- 이로 인해 발생하는 문제를 **타입스크립트**를 도입해서 사전에 방지할 수 있음
+- 반환문(`return` 뒤의 문)은 생략할 수 있지만 `undefined`를 반환함
+- 반환문은 함수 몸체 내부에서만 사용 가능
+
+## 12.6 참조에 의한 전달과 외부 상태의 변경
+
+- 매개변수에 인수를 할당할 때
+- 원시 타입의 인수는 그 값을 변경(재할당을 통해 값이 변경)해도 원본이 훼손되지 않음
+- 객체 타입의 인수는 그 값을 바꾸면 원본도 변경됨
+  - 이처럼 함수가 외부 상태를 변경하면 상태 변화를 추적하기 어려워짐
+  - **코드 복잡성 증가**, **가독성을 해치는 원인**
+    - 객체의 변경을 추적하려면 `옵저버 패턴`을 통할 수 있음
+    - `불변 객체`를 만들어서 외부 상태 변경을 막을 수 있음 (`깊은 복사`)
+
+외부 상태를 변경하지 않고 외부 상태에 의존하지 않아도 되는 함수를 **순수 함수**라고 한다. 순수 함수를 통해 부수 효과를 최대한 억제하여 프로그램의 안정성을 높이려는 프로그래밍 패러다임을 **함수형 프로그래밍**이라고 한다.
+
+- 유인동님의 함수형 프로그래밍 강의를 들어야겠음
+
+## 12.7 다양한 함수의 형태
+
+### 12.7.1 즉시 실행 함수
+
+```js
+// 익명 즉시 실행 함수
+(function () {
+  let a = 3;
+  let b = 5;
+  return a * b;
+})();
+// 기명 즉시 실행 함수
+(function foo() {
+  let a = 3;
+  let b = 5;
+  return a * b;
+})(); // ReferenceError: foo is not defined
+```
+
+- 함수 정의와 동시에 즉시 호출되는 함수
+- 즉시 실행 함수는 단 한 번만 호출되며 다시 호출할 수 없음
+- 즉시 실행 함수는 일반적으로 `익명 함수`를 사용하며
+- `기명 함수`를 사용할 수 있지만 다시 호출할 수 없음
+- **즉시 실행 함수 내에 코드를 모아 두면 혹시 있을 수도 있는 변수나 함수 이름의 충돌을 방지할 수 있음**
+
+### 12.7.2 재귀 함수
+
+```js
+// 팩토리얼
+function factorial(n) {
+  // 탈출 조건 : n이 1 이하일 때 재귀 호출을 멈춤
+  if (n <= 1) return 1;
+  // 재귀 호출
+  return n * factorial(n - 1);
+}
+console.log(factorial(0)); // 0! = 1
+console.log(factorial(1)); // 1! = 1
+console.log(factorial(2)); // 2! = 2 * 1 = 2
+console.log(factorial(5)); // 5! = 5 * 4 * 3 * 2 * 1 = 120
+```
+
+- 함수가 자기 자신을 호출하는 것을 재귀 호출이라고 함
+- 재귀 함수는 자기 자신을 호출하는 함수를 말함
+- 함수 이름은 물론 함수를 가리키는 식별자로도 자기 자신을 호출할 수 있음
+  - 단, 함수 외부에서 호출할 때는 반드시 함수를 가리키는 식별자로 호출
+- 재귀 함수는 반드시 **탈출 조건**을 만들어서 사용해야 함
+
+### 12.7.3 중첩 함수
+
+````js
+function outer(){
+  let x = 1;
+  // 중첩 함수
+  function inner(){
+    let y = 2;
+    // 외부 함수의 변수를 참조할 수 있다.
+    console.log(x+y) // 3;
+  }
+  inner();
+}
+outer();
+```
+````
+
+### 12.7.4 콜백 함수
+
+- 함수의 매개변수를 통해 다른 함수의 내부로 전달되는 함수
+- 매개변수를 통해 콜백 함수를 전발 받은 함수는 고차 함수
+
+```js
+// 콜백 함수를 익명으로 전달한다.
+// 익명 함수는 repeat 함수를 호출할 때마다 평가되어 함수 객체를 생성한다.
+repeat(5, function (i) {
+  if (i % 2) console.log(i);
+}); // 1 3
+```
+
+- 함수 내부에서만 전달한 콜백 함수가 사용되면 익명 함수로 사용해도 되지만
+- 콜백 함수를 전달받는 함수(고차 함수)가 자주 호출된다면 함수 외부에서 콜백 함수를 정의한 후 **함수 자체**를 전달해서 사용
+- 콜백 함수는 함수형 프로그래밍 뿐만 아니라 비동기의 꽃이라고 할 수 있음
+
+### 12.7.5 순수 함수와 비순수 함수
+
+- 순수 함수 : 어떤 외부 상태에 의존하지도 않고 변경하지도 않는 순수 함수
+- 비순수 함수 : 그와 반대
+
+함수형 프로그래밍은 외부 상태 변경을 최소화하고 로직 내에 존재하는 조건문과 반복분을 제거해서 복잡성을 해결하며 변수 사용을 억제하거나 생명주기를 최소화해서 상태 변경을 피해 오류를 최소화하는 것을 목표로 함
+
+# 13. 스코프
+
+## 13.1 스코프란
+
+- 식별자를 검색할 때 사용하는 규칙 즉, 식별자의 유효 범위
+- 컴퓨터의 `폴더`를 생각하면 이해하기 쉬움
+
+## 13.2 스코프의 종류
+
+- 전역 스코프(Global scope)
+- 지역 스코프(Local scope)
+
+## 13.3 스코프 체인
+
+- 스코프가 함수의 중첩에 의해 계층적인 구조를 갖는데
+- 이는 렉시컬 환경의 스코프 체인을 통해 가능한 것임
+- 상위 스코프를 하위 스코프에서 참조할 수 있지만 하위 스코프를 상위에서 참조하는 게 불가능한 이유 또한 스코프 체인은 **계층적**이기 때문
+
+## 13.4 함수 레벨 스코프
+
+- 함수에 의해서만 지역 스코프가 생성되다는 의미
+  - `var` 키워드로 선언된 변수는 오로지 함수의 코드 블록만을 지역 스코프로 인정
+  - 이러한 특성을 함수 레벨 스코프라고 함
+
+## 13.5 렉시컬 스코프
+
+- **동적 스코프** : 함수를 어디서 호출했는지에 따라 함수의 상위 스코프를 결정
+- **렉시컬 스코프(정적 스코프)** : 함수를 어디에 정의했는지에 따라 상위 스코프를 결정
+- 함수가 호출된 위치는 상위 스코프 결정에 어떠한 영향도 주지 않음
+- 즉, 함수의 상위 스코프는 언제나 자신이 정의된 스코프
+
+# 14. 전역 변수의 문제점
+
+- 전역 변수는 스코프 체인 상에서 종점에 존재함
+- 호이스팅은 변수 선언이 스코프의 선두로 끌어 올려진 것처럼 동작하는 자바스크립트 고유의 특징을 말함
+- 호이스팅은 스코프를 단위로 동작함
+- `var` 키워드로 선언한 전역 변수는 전역 객체(`window`)의 프로퍼티가 됨
+  - 즉, `var` 키워드로 선언한 전역 변수의 생명 주기는 전역 객체의 생명 주기와 일치
+  - 때문에 전역 변수 사용을 최대한 지양해야 함
+
+## 14.3 전역 변수의 사용을 억제하는 방법
+
+일반적으로 지역 변수를 지향하면 됨
+
+- 즉시 실행 함수
+- 네임스페이스 객체
+- 모듈 패턴
+  - 클래스를 모방해서 관련이 있는 변수와 함수를 모아 `즉시 실행 함수`로 감싸서 하나의 모듈을 만듬 / 캡슐화까지 구현할 수 있다는 장점이 있음
+  - 캡슐화는 프로퍼티와 메서드를 하나로 묶는 것을 말함
+- ES6 모듈
+  - 파일 자체의 독자적인 모듈 스코프를 제공함
+  - ES6에서 제공하는 모듈을 사용하면 전역 변수를 사용할 수 없음
+  - `var` 키워드로 선언한 변수는 전역 변수가 아니며 `window` 객체의 프로퍼티도 아님
+  - `script` 태그에 `type="module"` 속성을 추가하면 로드된 파일은 모둘로 동작하며 파일의 확장자는 `mjs`
+  - 브라우저의 ES6 모듈을 사용하더라도 트랜스파일링이나 번들링이 필요하기 때문에 아직까지는 `Webpack` 등의 모듈 번들러를 사용함
+
+# 15. let, const 키워드와 블록 레벨 스코프
+
+- `var` 키워드
+  - 함수 레벨 스코프
+  - 변수 중복 선언 허용
+  - 변수 호이스팅
+    - 변수 선언문 이전에 참조할 수 있음
+    - 단, 할당문 이전에 변수를 참조하면 `undefined`를 반환
+    - `선언 단계`와 `초기화 단계`가 한번에 진행됨
+      - **선언 단계**에서(실행 컨텍스트의 렉시컬 환경)에 변수 식별자를 등록해서 자바스크립트 엔진에 변수의 존재를 알림
+      - **초기화 단계** `undefined`로 변수를 초기화함
+      - 선언문 이전에 변수에 접근하면 따라서 `undefined`가 반환되는 것이고 이후에 변수 할당문에 도달하면 값이 할당됨
+- `let`, `const` 키워드
+
+  - 블록 레벨 스코프
+  - 변수 중복 선언 금지
+  - 변수 호이스팅
+    - `선언 단계`와 `초기화 단계`가 분리되어 진행
+    - 자바스크립트 엔진에 의해 암묵적으로 선언 단계가 먼저 실행되지만 초기화 단계는 `변수 선언문`에 도달했을 때 실행됨
+    - 만약 초기화 단계가 실행되기 이전에 변수에 접근하려고 하면 `참조 에러(ReferenceError)`가 발생함
+    - `let`, `const` 키워드로 선언한 변수는 스코프의 시작 지점부터 초기화 단계 시작 지점(변수 선언문)까지 변수를 참조할 수 없는데 이 구간을 `일시적 사각지대(Temporal Dead Zond:TDZ)`라고 부름
+    - 호이스팅이 되지만 발생하지 않는 것처럼 동작하는 이유가 이 때문임
+
+- const 키워드
+  ```js
+  const foo = 1;
+  ```
+  - const 키워드로 선언한 변수는 반드시 선언과 동시에 초기화 해야 함
+  - const 키워드는 상수를 표현하는 데 사용함 (상수는 재할당이 불가능함)
+  - const 키워드로 선언한 원시 값은 값을 변경할 수 없지만 객체를 할당한 경우 값을 변경할 수 있음
+
+# var vs let vs const
+
+- 변수 선언에는 기본적으로 `const`를 사용하고 `let`은 재할당이 필요한 경우에만 사용
+- 변경이 발생하지 않고 읽기 전용으로 사용하는(재할당이 필요 없는 상수) 원시 값과 객체에는 `const` 키워드를 사용
diff --git a/README.md b/README.md
index 1d4d361..47ae7ba 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,18 @@
 # 모던 자바스크립트 딥 다이브 3개월 완독 프로젝트
-목적: JS를 기초부터 차근차근 익힌다. 
+
+목적: JS를 기초부터 차근차근 익힌다.
 
 책 링크: http://www.yes24.com/Product/Goods/92742567
 
 기간: 5.10(월) ~ 8.1(일) 총 84일
+
 # 규칙
+
 1. 오픈 채팅방 주도 진행 [주소](https://open.kakao.com/o/gXNDEfcd)
 1. 4~49 챕터(총 46)를 진행합니다.
-2. 한 달 4주, 약 28일, 총 12주, 84일이므로 한 주에 4~6 챕터를 진행합니다. 그전 주에 [카톡 오픈 채팅방](https://open.kakao.com/o/gXNDEfcd)에서 투표합니다. (기본값-4챕터)
-3.  온라인 위주로 활동합니다.
-4.  각 주차별/닉네임 폴더 아래에 그 주에 공부한 내용을 정리해 PR로 공유합니다.
-5.  branch 명명 규칙: 닉네임-n(주 차). 예: qkreltms-1 또는 qkreltms-week1, main을 바라보고 branch를 생성합니다.
-5. 자유롭게 PR을 리뷰하고 main에 병합합니다.
-6.  **중요!!: 그 주에 올린 PR을 캡처하고 챌린저스에 인증합니다.**
+1. 한 달 4주, 약 28일, 총 12주, 84일이므로 한 주에 4~6 챕터를 진행합니다. 그전 주에 [카톡 오픈 채팅방](https://open.kakao.com/o/gXNDEfcd)에서 투표합니다. (기본값-4챕터)
+1. 온라인 위주로 활동합니다.
+1. 각 주차별/닉네임 폴더 아래에 그 주에 공부한 내용을 정리해 PR로 공유합니다.
+1. branch 명명 규칙: 닉네임-n(주 차). 예: qkreltms-1 또는 qkreltms-week1, main을 바라보고 branch를 생성합니다.
+1. 자유롭게 PR을 리뷰하고 main에 병합합니다.
+1. **중요!!: 그 주에 올린 PR을 캡처하고 챌린저스에 인증합니다.**