Lucky-kor · YeoSeungA · Nov 19, 2024
diff --git a/koans/01_Introduction.js b/koans/01_Introduction.js
@@ -29,13 +29,13 @@ describe('expect에 대해서 학습합니다.', function () {
       expect(true).to.be.true;
     */
     // TODO: 테스트가 통과될 수 있도록(테스트하는 값이 true가 되도록) expect의 첫 번째 전달인자를 수정합니다.
-    expect(false).to.be.true;
+    expect(true).to.be.true;
   });
 
   it('테스트하는 값(expect의 전달인자)이 falsy 여부를 검사합니다.', function () {
     // 반대의 경우에는 어떻게 해야할까요?
     // TODO: 테스트가 통과될 수 있도록(테스트하는 값이 false가 되도록) expect의 첫 번째 전달인자를 수정합니다.
-    expect(true).to.be.false;
+    expect(false).to.be.false;
   });
 
   /*
@@ -53,7 +53,7 @@ describe('expect에 대해서 학습합니다.', function () {
   it("'테스트하는 값'을 '기대하는 값'과 비교한 결과가 참 인지 확인합니다.", function () {
     // '테스트하는 값'은 우리가 작성한 어떤 코드의 실제 실행 결과 값이므로 '실제 값'이라고 불러도 됩니다.
     let actualValue = 1 + 1;
-    let expectedValue = FILL_ME_IN; // TODO: 'FILL_ME_IN'을 변경하여 테스트 케이스를 완성합니다.
+    let expectedValue = 2; // TODO: 'FILL_ME_IN'을 변경하여 테스트 케이스를 완성합니다.
     expect(actualValue === expectedValue).to.be.true;
   });
 
@@ -68,13 +68,13 @@ describe('expect에 대해서 학습합니다.', function () {
   이후에도 같은 방식으로 'FILL_ME_IN' 변경하면 됩니다.
   */
   it('Matcher .equal 의 사용법을 학습합니다.', function () {
-    let expectedValue = FILL_ME_IN; // TODO
+    let expectedValue = 2; // TODO
     // .equal은 두 값이 타입까지 엄격하게 같은지 검사(strict equality, ===)합니다.
     expect(1 + 1).to.equal(expectedValue);
   });
 
   it('Matcher .equal의 사용법을 학습합니다.', function () {
     let actualValue = (1 + 1).toString();
-    expect(actualValue).to.equal(FILL_ME_IN); // TODO
+    expect(actualValue).to.equal("2"); // TODO
   });
 });
diff --git a/koans/02_Types-part1.js b/koans/02_Types-part1.js
@@ -1,7 +1,7 @@
 describe('type에 대해서 학습합니다.', function () {
   it("비교연산자 '=='는 두 값의 일치 여부를 느슨하게 검사(loose equality)합니다.", function () {
     let actualValue = 1 + 1;
-    let expectedValue = FILL_ME_IN;
+    let expectedValue = 2;
     expect(actualValue == expectedValue).to.be.true;
 
     /*
@@ -33,26 +33,26 @@ describe('type에 대해서 학습합니다.', function () {
 
   it("비교연산자 '==='는 두 값의 일치 여부를 엄격하게 검사(strict equality)합니다.", function () {
     let actualValue = 1 + 1;
-    let expectedValue = FILL_ME_IN;
+    let expectedValue = 2;
     expect(actualValue === expectedValue).to.be.true;
     // 이제 'FILL_ME_IN'을 대신할 수 있는 건 number 타입의 2뿐입니다.
     // 문자열 '2'는 테스트를 통과하지 못합니다.
   });
 
   it('expect의 전달인자로 들어간 표현식의 평가(evaluation) 결과를 예측해 봅니다.', function () {
-    expect(1 + '1').to.equal(FILL_ME_IN);
+    expect(1 + '1').to.equal('11');
   });
 
   it('expect의 전달인자로 들어간 표현식의 평가(evaluation) 결과를 예측해 봅니다.', function () {
-    expect(123 - '1').to.equal(FILL_ME_IN);
+    expect(123 - '1').to.equal(122);
   });
 
   it('expect의 전달인자로 들어간 표현식의 평가(evaluation) 결과를 예측해 봅니다.', function () {
-    expect(1 + true).to.equal(FILL_ME_IN);
+    expect(1 + true).to.equal(2);
   });
 
   it('expect의 전달인자로 들어간 표현식의 평가(evaluation) 결과를 예측해 봅니다.', function () {
-    expect('1' + true).to.equal(FILL_ME_IN);
+    expect('1' + true).to.equal('1true');
   });
 
   /*

diff --git a/koans/03_LetConst.js b/koans/03_LetConst.js
@@ -2,17 +2,17 @@ describe("'const'에 대해서 학습합니다.", function () {
   it("'const'로 선언된 변수에는 재할당(reassignment)이 금지됩니다.", function () {
     // 아래 코드에서 문제가 되는 부분을 삭제합니다.
     const constNum = 0;
-    constNum = 0;
+    // constNum = 0;
     expect(constNum).to.equal(0);
 
     const constString = 'I am a const';
-    constString = "which means I'm a constant variable, delete me.";
+    // constString = "which means I'm a constant variable, delete me.";
     expect(constString).to.equal('I am a const');
   });
 
   it("'const'로 선언된 배열의 경우 새로운 요소를 추가하거나 삭제할 수 있습니다.", function () {
     const arr = [];
-    const toBePushed = FILL_ME_IN;
+    const toBePushed = 42;
     arr.push(toBePushed);
     expect(arr[0]).to.equal(42);
 
@@ -22,15 +22,15 @@ describe("'const'에 대해서 학습합니다.", function () {
 
   it("'const'로 선언된 객체의 경우, 속성을 추가하거나 삭제할 수 있습니다.", function () {
     const obj = { x: 1 };
-    expect(obj.x).to.equal(FILL_ME_IN);
+    expect(obj.x).to.equal(1);
 
     delete obj.x;
-    expect(obj.x).to.equal(FILL_ME_IN);
+    expect(obj.x).to.equal(undefined); /// expect(obj); 는 {} 빈객체, expect(obj.x)는 undefined
 
     // 여전히 재할당은 금지됩니다.
     // obj = { x: 123 };
 
-    obj.occupation = FILL_ME_IN;
+    obj.occupation = 'SW Engineer';
     expect(obj['occupation']).to.equal('SW Engineer');
   });
 

diff --git a/koans/04_Scope.js b/koans/04_Scope.js
@@ -2,86 +2,95 @@ describe('scope 대해서 학습합니다.', function () {
   //  scope는 변수의 값(변수에 담긴 값)을 찾을 때 확인하는 곳을 말합니다. 반드시 기억하시기 바랍니다.
   it('함수 선언식(declaration)과 함수 표현식(expression)의 차이를 확인합니다.', function () {
     let funcExpressed = 'to be a function';
-
-    expect(typeof funcDeclared).to.equal(FILL_ME_IN);
-    expect(typeof funcExpressed).to.equal(FILL_ME_IN);
+    // 함수는 선언돼면 그냥 위로 올라옴. (일종의 호이스팅)
+    expect(typeof funcDeclared).to.equal('function');
+    expect(typeof funcExpressed).to.equal('string');
 
     function funcDeclared() {
       return 'this is a function declaration';
     }
-
+    // 함수 재할당. 함수 표현식으로 표현돼면 안 끌어올려짐. 
     funcExpressed = function () {
       return 'this is a function expression';
     };
 
     // 자바스크립트 함수 호이스팅(hoisting)에 대해서 검색해 봅니다.
 
     const funcContainer = { func: funcExpressed };
-    expect(funcContainer.func()).to.equal(FILL_ME_IN);
+    // 함수 실행을 하려면 () 가 있어야 함.
+    expect(funcContainer.func()).to.equal('this is a function expression');
 
     funcContainer.func = funcDeclared;
-    expect(funcContainer.func()).to.equal(FILL_ME_IN);
+    expect(funcContainer.func()).to.equal('this is a function declaration');
   });
 
   it('lexical scope에 대해서 확인합니다.', function () {
     let message = 'Outer';
 
     function getMessage() {
+      //  이 때 message는 'Outer'
       return message;
     }
 
     function shadowGlobal() {
       let message = 'Inner';
-      return message;
+      return message;  // 'Inner'
     }
 
     function shadowGlobal2(message) {
-      return message;
+      return message;  // 바로 위의 message
     }
 
     function shadowParameter(message) {
       message = 'Do not use parameters like this!';
-      return message;
+      return message; // 어떤 데이터가 들어와도 재할당 함. 'Do not use parameters like this!' 만 출력됨.
     }
 
-    expect(getMessage()).to.equal(FILL_ME_IN);
-    expect(shadowGlobal()).to.equal(FILL_ME_IN);
-    expect(shadowGlobal2('Parameter')).to.equal(FILL_ME_IN);
-    expect(shadowParameter('Parameter')).to.equal(FILL_ME_IN);
-    expect(message).to.equal(FILL_ME_IN);
+    expect(getMessage()).to.equal('Outer');
+    expect(shadowGlobal()).to.equal('Inner');
+    expect(shadowGlobal2('Parameter')).to.equal('Parameter');
+    expect(shadowParameter('Parameter')).to.equal('Do not use parameters like this!');
+    expect(message).to.equal('Outer');
+    // shadowParameter();
+    // 함수를 실행해야 밑의 코드가 올바름.
+    // expect(message).to.equal('Do not use parameters like this!');
   });
 
   it('default parameter에 대해 확인합니다.', function () {
     function defaultParameter(num = 5) {
       return num;
     }
 
-    expect(defaultParameter()).to.equal(FILL_ME_IN);
-    expect(defaultParameter(10)).to.equal(FILL_ME_IN);
+    expect(defaultParameter()).to.equal(5);
+     // 함수는 매개변수 num을 갖음. 초기값(아무것도 안 넣었을 때 대응하기 위한)이 5이다. 
+     //  10이 들어오면 우선순위가 더 높음.
+    expect(defaultParameter(10)).to.equal(10); 
 
     function pushNum(num, arr = []) {
       arr.push(num);
       return arr;
     }
-
-    expect(pushNum(10)).to.deep.equal(FILL_ME_IN);
-    expect(pushNum(20)).to.deep.equal(FILL_ME_IN);
-    expect(pushNum(4, [1, 2, 3])).to.deep.equal(FILL_ME_IN);
+    // num에 변수 들어감.
+    expect(pushNum(10)).to.deep.equal([10]);
+    expect(pushNum(20)).to.deep.equal([20]);
+    expect(pushNum(4, [1, 2, 3])).to.deep.equal([1, 2, 3, 4]);
   });
 
   it('클로저(closure)에 대해 확인합니다.', function () {
     function increaseBy(increaseByAmount) {
+      //  밑 함수는 이름이 없음( 익명함수.) 따로 호출 X. 위 함수를 불러야 실행 가능해짐.
       return function (numberToIncrease) {
         return numberToIncrease + increaseByAmount;
       };
     }
-
+    // function (numberToIncrease) {return numberToIncrease + 3};
     const increaseBy3 = increaseBy(3);
+    // function (numberToIncrease) {return numberToIncrease + 5};
     const increaseBy5 = increaseBy(5);
 
-    expect(increaseBy3(10)).to.equal(FILL_ME_IN);
-    expect(increaseBy5(10)).to.equal(FILL_ME_IN);
-    expect(increaseBy(8)(6) + increaseBy(5)(9)).to.equal(FILL_ME_IN);
+    expect(increaseBy3(10)).to.equal(13);
+    expect(increaseBy5(10)).to.equal(15);
+    expect(increaseBy(8)(6) + increaseBy(5)(9)).to.equal(28);
 
     /*
     mdn에 따르면 클로저의 정의는 다음과 같습니다. 반드시 기억하시기 바랍니다.
@@ -109,28 +118,28 @@ describe('scope 대해서 학습합니다.', function () {
     let height = 179;
 
     function outerFn() {
-      let age = 24;
+      let age = 24;  // 26이 해당됨. 범위 안에 있는게 우선순위가 더 높음. innerFn()이 실행돼서 
       name = 'jimin';
       let height = 178;
 
       function innerFn() {
         age = 26;
-        let name = 'suga';
-        return height;
+        let name = 'suga'; // innerFn에서만 해당. 아무 영향 X
+        return height; // 바로 밖에 있는 178을 반환
       }
 
       innerFn();
 
-      expect(age).to.equal(FILL_ME_IN);
-      expect(name).to.equal(FILL_ME_IN);
-
+      expect(age).to.equal(26);
+      expect(name).to.equal('jimin');
+      // 함수 자체를 반환. 실행 X
       return innerFn;
     }
-
+    // 실행돼서 이름이 지민이 됨.
     const innerFn = outerFn();
-
-    expect(age).to.equal(FILL_ME_IN);
-    expect(name).to.equal(FILL_ME_IN);
-    expect(innerFn()).to.equal(FILL_ME_IN);
+    
+    expect(age).to.equal(27);
+    expect(name).to.equal('jimin');
+    expect(innerFn()).to.equal(178);
   });
 });
diff --git a/koans/05_ArrowFunction.js b/koans/05_ArrowFunction.js
@@ -4,28 +4,30 @@ describe('화살표 함수에 관해서', function () {
       return x + y
     }
 
-    expect(add(5, 8)).to.eql(FILL_ME_IN)
+    expect(add(5, 8)).to.eql(13)
   })
 
   it('화살표 함수 사용법을 익힙니다', function () {
     // function 키워드를 생략하고 화살표 => 를 붙입니다
     const add = (x, y) => {
       return x + y
     }
-    expect(add(10, 20)).to.eql(FILL_ME_IN)
+    expect(add(10, 20)).to.eql(30)
 
     // 리턴을 생략할 수 있습니다
     const subtract = (x, y) => x - y
-    expect(subtract(10, 20)).to.eql(FILL_ME_IN)
+    expect(subtract(10, 20)).to.eql(-10)
 
     // 필요에 따라 소괄호를 붙일 수도 있습니다
+    // return문과 중괄호를 같이 삭제할 수 있다. 무조건 '같이', 혼자는 안됨.
     const multiply = (x, y) => (x * y)
-    expect(multiply(10, 20)).to.eql(FILL_ME_IN)
+    expect(multiply(10, 20)).to.eql(200)
 
     // 파라미터가 하나일 경우 소괄호 생략이 가능합니다
     const divideBy10 = x => x / 10
-    expect(divideBy10(100)).to.eql(FILL_ME_IN)
+    expect(divideBy10(100)).to.eql(10)
   })
+    // 파라미터가 없을 경우 소괄호는 무조건 사용해야 합니다.!!!
 
   it('화살표 함수를 이용해 클로저를 표현합니다', function () {
     const adder = x => {
@@ -34,19 +36,23 @@ describe('화살표 함수에 관해서', function () {
       }
     }
 
-    expect(adder(50)(10)).to.eql(FILL_ME_IN)
-
+    expect(adder(50)(10)).to.eql(60)
+    //const subtractor = x => y => x - y;
     const subtractor = x => y => {
       return x - y
     }
-
-    expect(subtractor(50)(10)).to.eql(FILL_ME_IN)
+    // function subtractor(x) {
+    //  return function (y) {
+    //   return x- y;
+    //  }
+    //}
+    expect(subtractor(50)(10)).to.eql(40)
 
     const htmlMaker = tag => textContent => `<${tag}>${textContent}</${tag}>`
-    expect(htmlMaker('div')('javascript')).to.eql(FILL_ME_IN)
+    expect(htmlMaker('div')('javascript')).to.eql('<div>javascript</div>')
 
-    const liMaker = htmlMaker('li')
-    expect(liMaker('1st item')).to.eql(FILL_ME_IN)
-    expect(liMaker('2nd item')).to.eql(FILL_ME_IN)
+    const liMaker = htmlMaker('li') // -> <li>undefined<li> 커링함수.
+    expect(liMaker('1st item')).to.eql('<li>1st item</li>')
+    expect(liMaker('2nd item')).to.eql('<li>2nd item</li>')
   })
 })