diff --git a/Chapter_12/README.md b/Chapter_12/README.md
new file mode 100644
index 0000000..0981986
--- /dev/null
+++ b/Chapter_12/README.md
@@ -0,0 +1,238 @@
+## 🐝 12장 함수형 반복
+
+**이번장에서 살펴볼 내용**
+
+1.  함수형 도구 map(), filter(), reduce() 에 대해 배웁니다.
+
+2.  배열에 대한 반복문을 함수형 도구로 바꾸는 방법에 대해 알아봅니다.
+
+3.  함수형 도구를 어떻게 구현하는지 알아봅니다.
+
+### 이전 내용 한번 더 정리
+
+1. 코드 냄새: 함수 이름에 있는 암묵적 인자
+   특징: 거의 똑가팅 구현된 함수가 있다. / 함수 이름이 구현에 있는 다른 부분을 가르킨다.
+
+2. 리팩터링1 - 암묵적 인자를 드러내기
+   리팩터링은 암묵적 인자가 일급 값이 되도록 함수에 인자를 추가한다.
+   [단계]
+   1 - 함수 이름에 있는 암묵적 인자를 확인
+   2 - 명시적인 인자를 추가
+   3 - 함수 본분에 하드 코딩된 값을 새로운 인자로 변경
+   4 - 함수를 호출하는 곳을 수정
+
+3. 리팩터링2 - 함수 본문을 콜백으로 바꾸기
+   1 - 함수 본문에서 바꿀 부분의 앞부분과 뒷부분을 확인
+   2 - 리팩터링 할 코드를 함수로 빼냄
+   3 - 빼낸 함수의 인자로 넘길 부분을 또 다른 함수로 빼냄
+
+### 새로운 요청 : 쿠폰 이메일 처리
+
+[3장에 나왔던 코드] 를 리팩터링 해보자
+
+```js
+function emailsForCustomers(customers, goods, bests) {
+  var emails = [];
+  for (var i = 0; i < customers.length; i++) {
+    var customer = customers[i];
+    var email = emailForCustomer(customer, goods, bests);
+    emails.push(email);
+  }
+  return emails;
+}
+```
+
+1. 일단 `forEach` 로 반복문을 변경해봅니다.
+
+```js
+function emailsForCustomers(customers, goods, bests) {
+  var emails = [];
+  forEach(customers, function (customer) {
+    var email = emailForCustomer(customer, goods, bests);
+    emails.push(email);
+  });
+  return emails;
+}
+```
+
+2. `map` 함수를 도출하기
+   다른 코드들도 살펴봅니다.
+
+```js
+function emailsForCustomers(customers, goods, bests) {
+  var emails = [];
+  forEach(customers, function (customer) {
+    var email = emailForCustomer(customer, goods, bests);
+    emails.push(email);
+  });
+  return emails;
+}
+function biggestPurchasePerCustomer(customers) {
+  var purchases = [];
+  forEach(customers, function (customer) {
+    var purchase = biggestPurchase(customer);
+    purchases.push(purchase);
+  });
+  return purchases;
+}
+```
+
+지난 장에서 배운 것 처럼 앞부분 본문 뒷부분을 구분해서 본문을 콜백빼내고 변경해봅니다!
+
+![Alt text](image.png)
+
+```js
+function map(array, f) {
+  var newArray = [];
+  forEach(array, function (element) {
+    newArray.push(f(element));
+  });
+  return newArray;
+}
+```
+
+### 함수형 도구: map()
+
+```js
+// 배열과 함수를 인자로 받음
+function map(array, f) {
+  var newArray = []; // 빈 배열
+  forEach(array, function (element) {
+    newArray.push(f(element));
+    // 원래 배열 항목으로 새로운 배열 항목을 만들기 위해 f( ) 함수를 부른다.
+    // 원래 배열 항목에 해당하는 새로운 항목을 추가
+  });
+  return newArray;
+  // 새로운 배열 리턴
+}
+```
+
+![Alt text](image-1.png)
+
+전달함수는 익명함수를 사용해서 인라인으로 정의함.
+함수를 정의할 때 인자의 이름을 통해 인자가 무엇인지 알 수 있다.
+
+```js
+function emailsForCustomers(customers, goods, bests) {
+  return map(customers, function (customer) {
+    return emailForCustomer(customer, goods, bests);
+  });
+}
+```
+
+1. 익명 함수: 이름이 없는 함수.
+   익명 함수는 필요한 곳에 인라인으로 정의함
+
+2. 인라인 함수 : 이름을 붙여쓰는 대신 쓰는 곳에서 바로 정의하는 함수
+   ( = 인자를 넘기는 곳에서 바로 정의한다면 인라인 함수다.)
+
+![Alt text](image-2.png)
+
+### 함수를 전달하는 세 가지 방법
+
+#### 전역으로 정의하기
+
+```js
+function greet(name) {
+  return 'Hello, ' + name;
+}
+var friendGreetings = map(friendsNames, greet);
+```
+
+#### 지역적으로 정의하기
+
+```js
+function greetEverybody(friends) {
+  var greeting;
+  if (language === 'English') greeting = 'Hello, ';
+  else greeting = 'Salut, ';
+  var greet = function (name) {
+    return greeting + name;
+  };
+  return map(friends, greet);
+}
+```
+
+#### 인라인으로 정의하기
+
+```js
+var friendGreetings = map(friendsNames, function (name) {
+  return 'Hello, ' + name;
+});
+```
+
+### 새로운 요청: 우수 고객 목록
+
+여기에도 map() 을 사용하면 될까?
+-> map 은 주어진 배열과 길이가 같은 배열을 리턴하기 때문에 적절하지 않음.
+
+여기서는 우수 고객들만 가져와야함.
+
+![Alt text](image-3.png)
+
+```js
+function selectBestCustomers(customers){
+    return filter(customers, function(customer)){
+        return customer.purchases.length > = 3; // 표현식을 함수로 빼서 인자로 전달함
+    }
+}
+```
+
+### 함수형 도구: filter()
+
+배열에서 일부 항목을 선택하는 함수
+
+```js
+function filter(array, f) {
+  var newArray = [];
+  forEach(array, function (element) {
+    if (f(element)) newArray.push(element);
+  });
+  return newArray;
+}
+```
+
+#### 주의
+
+결과 배열에 null 이 발생할 수도 있음.
+
+```js
+var allEmails = map(customers, function (customer) {
+  return customer.email;
+});
+var emailsWithoutNulls = filter(emailsWithNulls, function (email) {
+  return email !== null;
+});
+```
+
+### 새로운 요청 : 모든 고객의 전체 구매 수
+
+### reduce
+
+배열을 순회하면서 값을 누적해감.
+
+```js
+function reduce(array, init, f) {
+    // 배열과 초깃값, 누적 함수를 인자로 받음
+    var accum = init;
+// 누적된값을 초기화
+    forEach(array, function(element) {
+        accum = f(accum, element);
+// 누적 값을 계산하기 위해 현재 값과 배열 항목으로
+f() 함수를 부름
+    });
+    return accum;
+// 누적된 값을 리턴
+}
+```
+
+![Alt text](image-6.png)
+
+### 세가지 함수형 도구 비교
+
+1. Map
+   어떤 배열의 모든 항목헤 함수를 적용해 새로운 배열로 변경
+2. filter
+   어떤 배열의 하위 집합을 선택해 새로운 배열로 만듬
+3. reduce
+   어떤 배열의 항목을 조합해 최종값으로 만든다.
diff --git a/Chapter_12/image-1.png b/Chapter_12/image-1.png
new file mode 100644
index 0000000..33af51b
Binary files /dev/null and b/Chapter_12/image-1.png differ
diff --git a/Chapter_12/image-2.png b/Chapter_12/image-2.png
new file mode 100644
index 0000000..02ea2db
Binary files /dev/null and b/Chapter_12/image-2.png differ
diff --git a/Chapter_12/image-3.png b/Chapter_12/image-3.png
new file mode 100644
index 0000000..d431a2c
Binary files /dev/null and b/Chapter_12/image-3.png differ
diff --git a/Chapter_12/image-4.png b/Chapter_12/image-4.png
new file mode 100644
index 0000000..7e5cf57
Binary files /dev/null and b/Chapter_12/image-4.png differ
diff --git a/Chapter_12/image-5.png b/Chapter_12/image-5.png
new file mode 100644
index 0000000..e2a2414
Binary files /dev/null and b/Chapter_12/image-5.png differ
diff --git a/Chapter_12/image-6.png b/Chapter_12/image-6.png
new file mode 100644
index 0000000..eddbd11
Binary files /dev/null and b/Chapter_12/image-6.png differ
diff --git a/Chapter_12/image.png b/Chapter_12/image.png
new file mode 100644
index 0000000..c6c8336
Binary files /dev/null and b/Chapter_12/image.png differ
diff --git a/Chapter_14/README.md b/Chapter_14/README.md
new file mode 100644
index 0000000..2a30ba5
--- /dev/null
+++ b/Chapter_14/README.md
@@ -0,0 +1,344 @@
+## 🐝 14장 중첩된 데이터에 함수형 도구 사용하기
+
+**이번장에서 살펴볼 내용**
+
+1. 해시 맵에 저장된 값을 다루기 위한 고차 함수를 만듬.
+
+2. 중첩된 데이터를 고차 함수로 쉽게 다루는 방법을 배움.
+
+3. 재귀를 이해하고 안전하게 재귀를 사용하는 방법을 살펴봄.
+
+4. 깊이 중첩된 엔티티에 추상화 벽을 적용해서 얻을 수 있는 장점을 이해.
+
+### 객체를 다루기 위한 고차 함수
+
+#### 필드명을 명시적으로 만들기
+
+원래 냄새가 나던 코드
+
+```js
+function incrementQuantity(item) {
+  var quantity = item['quantity'];
+  var newQuantity = quantity + 1;
+  var newItem = objectSet(item, 'quantity', newQuantity);
+  return newItem;
+}
+```
+
+인자로 바꾼 코드
+(명시적인 인자로 변경)
+
+```js
+function incrementField(item, field) {
+  var value = item[field];
+  var newValue = value + 1;
+  var newItem = objectSet(item, field, newValue);
+  return newItem;
+}
+```
+
+#### update() 도출하기
+
+두 가지를 리팩터링해야한다.
+
+1. 함수 이름에 있는 암묵적인 인자는 암묵적 인자를 드러내기 리팩터링으로 동작 이름을 명시적인 인자로 변경.
+   -> 근데 여기서는 명시적으로 바꿔야 할 인자가 일반값이 아니고 동작이기 때문에
+   **함수 본문을 콜백으로 바꾸기** 리팩터링으로 동작을 함수 인자로 받도록 해야함.
+
+```js
+function incrementField(item, field) {
+  var value = item[field];
+  var newValue = value + 1;
+  var newItem = objectSet(item, field, newValue);
+  return newItem;
+}
+```
+
+```js
+function incrementField(item, field) {
+  return updateField(item, field, function (value) {
+    return value + 1;
+  });
+}
+
+function updateField(item, field, modify) {
+  var value = item[field];
+  var newValue = modify(value);
+  var newItem = objectSet(item, field, newValue);
+
+  return newItem;
+}
+```
+
+모든 동작을 고차 함수 하나로 합침.
+바꾸고 싶은 필드와 동작을 콜백으로 전달할 수 있게 됨.
+
+다만, 특정 필드를 바꾸는 함수가 아니기 때문에 함수 이름에 field는 빼고 일반적인 이름인 update()로 변경!
+
+```js
+function update(object, key, modify) {
+  var value = object[key];
+  var newValue = modify(value);
+  var newObject = objectSet(object, key, newValue);
+  return newObject;
+}
+```
+
+**Q. update( ) 가 원본 해시 맵을 변경하는지?**
+원본 해시 맵을 변경하지 않음.
+원래 해시 맵의 복사본을 변경해서 리턴
+
+### 객체에 있는 값을 시각화
+
+update()가 동작하는 방식을 시각화해보자.
+
+```js
+var shoes = {
+  name: 'shoes',
+  quantity: 3,
+  price: 7,
+};
+```
+
+```js
+function update(object, key, modify) {
+  // 1. 조회
+  var value = object[key];
+  // 2. 변경
+  var newValue = modify(value);
+  //  3. 설정
+  var newObject = objectSet(object, key, newValue);
+  return newObject;
+}
+```
+
+#### 단계1: 키를 가지고 객체에서 값을 조회
+
+![Alt text](image.png)
+
+#### 단계2: 현재 값으로 Modify()를 불러 새로운 값을 생성
+
+![Alt text](image-1.png)
+
+#### 단계3: 복사본을 생성
+
+![Alt text](image-2.png)
+
+### 중접된 데이터에 update() 사용하기
+
+```js
+function incrementSize(item) {
+  // 조회
+  var options = item.options;
+  // 조회
+  var size = options.size;
+  // 변경
+  var newSize = size + 1;
+  // 설정
+  var newOptions = objectSet(options, 'size', newSize);
+  // 설정
+  var newItem = objectSet(item, 'options', newOptions);
+
+  return newItem;
+}
+```
+
+**조회하고 변경하고 설정하는 것을 update()로 교체하기의 단계**
+
+1. 조회하고 변경하고 설정하는 것을 찾는다.
+2. 바꾸는 동작을 콜백으로 전달해서 update()로 교체한다.
+
+**한 번 리팩터링한 코드**
+
+```js
+function incrementSize(item) {
+  var options = item.options;
+  var newOptions = update(options, 'size', increment);
+  var newItem = objectSet(item, 'options', newOptions);
+  return newItem;
+}
+```
+
+**두 번 리팩터링한 코드**
+
+```js
+function incrementSize(item) {
+  return update(item, 'options', function (options) {
+    return update(options, 'size', increment);
+  });
+}
+```
+
+update() 를 중첩해서 부르면 더 깊은 단계로 중첩된 객체도 사용가능하다...
+(\_> 이 단계의 생각에 도달하기가 아직까지는..어려울듯)
+
+### 근데 두 번 리팩터링한 코드에서 냄새가 난다..??
+
+```js
+function incrementSize(item) {
+  return update(item, 'options', function (options) {
+    return update(options, 'size', increment);
+  });
+}
+```
+
+암묵적인자가 있음!
+명시적으로 변경해주자!
+
+```js
+function update2(object, key1, key2, modify) {
+  return update(object, key1, function (value1) {
+    return update(value1, key2, modify);
+  });
+}
+```
+
+**암묵적 인자를 드러내기 리팩터링 단계**
+
+1. 함수 이름에 있는 암묵적 인자를 확인
+2. 명시적인 인자를 추가한다.
+3. 함수 본문에 하드 코딩된 값을 새로운 인자로 변경.
+4. 함수를 호출하는 곳을 고침.
+
+### 문제
+
+옵션 안에 바꿔야 할 객체가 있고 옵션은 제품 객체 안에 있음.
+제품 객체는 또 장바구니 객체 안에 있는 것이 문제
+
+중첩중첩중첩이 문제
+
+```js
+var cart = {
+  shirt: {
+    name: 'shirt',
+    price: 13,
+    options: {
+      color: 'blue',
+      size: 3,
+    },
+  },
+};
+```
+
+이 함수를 `incrementSizeByName` 으로 하자!
+
+### incrementSizeByName() 을 만드는 방법
+
+#### 옵션1: update()와 incrementSize()로 만들기
+
+```js
+function incrementSizeByName(cart, name) {
+  return update(cart, name, incrementSize);
+}
+```
+
+#### 옵션2: update()와 update2()
+
+update2()를 사용해 incrementSize()를 인라인으로 구현할 수 있다.
+
+```js
+function incrementSizeByName(cart, name) {
+  return update(cart, name, function (item) {
+    return update2(item, 'options', 'size', function (size) {
+      return size + 1;
+    });
+  });
+}
+```
+
+#### 옵션3: update()로 만들기
+
+```js
+function incrementSizeByName(cart, name) {
+  return update(cart, name, function (item) {
+    return update(item, 'options', function (options) {
+      return update(options, 'size', function (size) {
+        return size + 1;
+      });
+    });
+  });
+}
+```
+
+#### 옵션4: 조회하고 바꾸고 설정하는 것을 직접 만들기
+
+```js
+function incrementSizeByName(cart, name) {
+  var item = cart[name];
+  var options = item.options;
+  var size = options.size;
+  var newSize = size + 1;
+  var newOptions = objectSet(options, 'size', newSize);
+  var newItem = objectSet(item, 'options', newOptions);
+  var newCart = objectSet(cart, name, newItem);
+  return newCart;
+}
+```
+
+### 결국 14장에서 핵심: 재귀 함수
+
+```js
+function nestedUpdate(object, keys, modify) {
+  // 종료 조건(경로의 길이가 0일때)
+  if (keys.length === 0) return modify(object);
+  var key1 = keys[0];
+  // 종료 조건에 계속 가까워짐(항목을 하나씩 없앰)
+  var restOfKeys = drop_first(keys);
+  return update(object, key1, function (value1) {
+    // 재귀 호출
+    return nestedUpdate(value1, restOfKeys, modify);
+  });
+}
+```
+
+**Q. 어떻게 함수가 자기 자신을 부를 수 있는지?**
+
+A. 함수는 자신을 포함해서 어떤 함수라도 부를 수 있음.
+자신을 부를 때 재귀라고 함.
+
+### 안전한 재귀 사용법
+
+재귀고 for / while 반복문 처럼 무한 반복에 빠질 가능성이 있음
+
+1. 종료 조건
+   종료 조건을 필요로 함
+2. 재귀 호출
+   최소 하나의 재귀 호출이 필요
+3. 종료 조건에 다가가기
+
+```js
+function nestedUpdate(object, keys, modify) {
+  // 종료 조건(경로의 길이가 0일때)
+  if (keys.length === 0) return modify(object);
+  var key1 = keys[0];
+  // 종료 조건에 계속 가까워짐(항목을 하나씩 없앰)
+  var restOfKeys = drop_first(keys);
+  return update(object, key1, function (value1) {
+    // 재귀 호출
+    return nestedUpdate(value1, restOfKeys, modify);
+  });
+}
+```
+
+### 깊이 중첩된 데이터에 추상화 벽 사용하기
+
+- 추상화벽은 구현을 감추기 때문에 함수를 쓸 때 어떻게 구현되어 있는지는 몰라도 됨.
+
+깊이 중첩된 데이터를 사용할 때 너무 많은 것을 기억해야하는 어려움이 있다.
+
+```js
+//  분류에 있는 블로그 글이 어떤
+//  구조인지는 몰라도 함수 사용가능.
+function updatePostById(category, id, modifyPost) {
+  return nestedUpdate(category, ['posts', id], modifyPost);
+  // ['posts', id] 분류의 구조 같은
+  // 구체적인 부분은 추상화 벽 뒤로 숨김
+}
+```
+
+### 요점 정리
+
+1. 보통 일반적인 반복문은 재귀보다 명확하지만, 중첩된 데이터를 다룰 때는 재귀가 더 쉽고 명확하다.
+
+2. 재귀는 스스로 불렀던 곳이 어디인지 유지하기 위해 스택을 사용.
+   재귀함수에서 스택은 중첩된 데이터 구조를 그대로 반영함.
diff --git a/Chapter_14/image-1.png b/Chapter_14/image-1.png
new file mode 100644
index 0000000..dbb56fb
Binary files /dev/null and b/Chapter_14/image-1.png differ
diff --git a/Chapter_14/image-2.png b/Chapter_14/image-2.png
new file mode 100644
index 0000000..966ab7f
Binary files /dev/null and b/Chapter_14/image-2.png differ
diff --git a/Chapter_14/image.png b/Chapter_14/image.png
new file mode 100644
index 0000000..ab8bc27
Binary files /dev/null and b/Chapter_14/image.png differ