From cfedafd0b61d52805230b7070d96791add3cce71 Mon Sep 17 00:00:00 2001
From: hyunhu24 <140373389+hyunhu24@users.noreply.github.com>
Date: Tue, 19 Nov 2024 10:20:33 +0900
Subject: [PATCH] Add files via upload
---
koans/01_Introduction.js | 10 +++---
koans/02_Types-part1.js | 13 ++++----
koans/03_LetConst.js | 12 +++----
koans/04_Scope.js | 44 ++++++++++++-------------
koans/05_ArrowFunction.js | 20 ++++++------
koans/06_Types-part2.js | 44 ++++++++++++-------------
koans/07_Array.js | 56 ++++++++++++++++----------------
koans/08_Object.js | 50 ++++++++++++++--------------
koans/09_SpreadSyntax.js | 47 ++++++++++++++-------------
koans/10_Destructuring.js | 68 +++++++++++++++++++++++++++++++--------
10 files changed, 203 insertions(+), 161 deletions(-)
diff --git a/koans/01_Introduction.js b/koans/01_Introduction.js
index f9cfaa6..99947ee 100644
--- 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
index a54a4d6..ea897bf 100644
--- 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,28 +33,29 @@ 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");
});
+
/*
지금까지 본 것처럼 자바스크립트에는 다소 이해하기 힘든 부분들이 존재합니다.
아래처럼 자바스크립트의 별난(quirky) 부분들을 따로 모아둔 저장소도 있을 정도입니다.
diff --git a/koans/03_LetConst.js b/koans/03_LetConst.js
index c3756c3..5522c5e 100644
--- 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);
// 여전히 재할당은 금지됩니다.
// 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
index 83a1705..8fda29b 100644
--- a/koans/04_Scope.js
+++ b/koans/04_Scope.js
@@ -3,8 +3,8 @@ describe('scope 대해서 학습합니다.', function () {
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';
@@ -17,10 +17,10 @@ describe('scope 대해서 학습합니다.', function () {
// 자바스크립트 함수 호이스팅(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 () {
@@ -44,11 +44,11 @@ describe('scope 대해서 학습합니다.', function () {
return message;
}
- 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");
});
it('default parameter에 대해 확인합니다.', function () {
@@ -56,17 +56,17 @@ describe('scope 대해서 학습합니다.', function () {
return num;
}
- expect(defaultParameter()).to.equal(FILL_ME_IN);
- expect(defaultParameter(10)).to.equal(FILL_ME_IN);
+ expect(defaultParameter()).to.equal(5);
+ 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);
+ 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 () {
@@ -79,9 +79,9 @@ describe('scope 대해서 학습합니다.', function () {
const increaseBy3 = increaseBy(3);
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에 따르면 클로저의 정의는 다음과 같습니다. 반드시 기억하시기 바랍니다.
@@ -121,16 +121,16 @@ describe('scope 대해서 학습합니다.', function () {
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");
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
index 116e39d..47e59c4 100644
--- a/koans/05_ArrowFunction.js
+++ b/koans/05_ArrowFunction.js
@@ -4,7 +4,7 @@ describe('화살표 함수에 관해서', function () {
return x + y
}
- expect(add(5, 8)).to.eql(FILL_ME_IN)
+ expect(add(5, 8)).to.eql(13)
})
it('화살표 함수 사용법을 익힙니다', function () {
@@ -12,19 +12,19 @@ describe('화살표 함수에 관해서', 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)
// 필요에 따라 소괄호를 붙일 수도 있습니다
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 () {
@@ -34,19 +34,19 @@ describe('화살표 함수에 관해서', function () {
}
}
- expect(adder(50)(10)).to.eql(FILL_ME_IN)
+ expect(adder(50)(10)).to.eql(60)
const subtractor = x => y => {
return x - y
}
- expect(subtractor(50)(10)).to.eql(FILL_ME_IN)
+ expect(subtractor(50)(10)).to.eql(40)
const htmlMaker = tag => textContent => `<${tag}>${textContent}`
- expect(htmlMaker('div')('javascript')).to.eql(FILL_ME_IN)
+ expect(htmlMaker('div')('javascript')).to.eql(`javascript
`)
const liMaker = htmlMaker('li')
- expect(liMaker('1st item')).to.eql(FILL_ME_IN)
- expect(liMaker('2nd item')).to.eql(FILL_ME_IN)
+ expect(liMaker('1st item')).to.eql(`1st item`)
+ expect(liMaker('2nd item')).to.eql(`2nd item`)
})
})
diff --git a/koans/06_Types-part2.js b/koans/06_Types-part2.js
index 52c8bf6..b6f866b 100644
--- a/koans/06_Types-part2.js
+++ b/koans/06_Types-part2.js
@@ -8,12 +8,12 @@ describe('primitive data type과 reference data type에 대해서 학습합니
*/
it('원시 자료형은 값 자체에 대한 변경이 불가능(immutable)합니다.', function () {
let name = 'javascript';
- expect(name).to.equal(FILL_ME_IN);
- expect(name.toUpperCase()).to.equal(FILL_ME_IN);
- expect(name).to.equal(FILL_ME_IN);
+ expect(name).to.equal("javascript");
+ expect(name.toUpperCase()).to.equal("JAVASCRIPT");
+ expect(name).to.equal("javascript");
// 새로운 값으로 재할당은 가능합니다.
name = name.toUpperCase();
- expect(name).to.equal(FILL_ME_IN);
+ expect(name).to.equal("JAVASCRIPT");
/*
원시 자료형은 값 자체에 대한 변경이 불가능하다고 하는데, 한 변수에 다른 값을 할당하는 것은 변경이 된 것이 아닌가요?
@@ -29,14 +29,14 @@ describe('primitive data type과 reference data type에 대해서 학습합니
let allowedToDrink = overTwenty;
overTwenty = false;
- expect(overTwenty).to.equal(FILL_ME_IN);
- expect(allowedToDrink).to.equal(FILL_ME_IN);
+ expect(overTwenty).to.equal(false);
+ expect(allowedToDrink).to.equal(true);
let variable = 'variable';
let variableCopy = 'variableCopy';
variableCopy = variable;
variable = variableCopy;
- expect(variable).to.equal(FILL_ME_IN);
+ expect(variable).to.equal('variable');
});
it('원시 자료형 또는 원시 자료형의 데이터를 함수의 전달인자로 전달할 경우, 값 자체의 복사가 일어납니다.', function () {
@@ -45,14 +45,14 @@ describe('primitive data type과 reference data type에 대해서 학습합니
year = year + 10;
}
afterTenYears(currentYear);
- expect(currentYear).to.equal(FILL_ME_IN);
+ expect(currentYear).to.equal(2020);
function afterTenYears2(currentYear) {
currentYear = currentYear + 10;
return currentYear;
}
let after10 = afterTenYears2(currentYear);
- expect(currentYear).to.equal(FILL_ME_IN);
- expect(after10).to.equal(FILL_ME_IN);
+ expect(currentYear).to.equal(2020);
+ expect(after10).to.equal(2030);
// 사실 함수의 전달인자도 변수에 자료(data)를 할당하는 것입니다.
// 함수를 호출하면서 넘긴 전달인자가 호출된 함수의 지역변수로 (매 호출 시마다) 새롭게 선언됩니다.
});
@@ -106,20 +106,20 @@ describe('primitive data type과 reference data type에 대해서 학습합니
*/
it('참조 자료형의 데이터는 동적(dynamic)으로 변합니다.', function () {
const arr = [1, 2, 3];
- expect(arr.length).to.equal(FILL_ME_IN);
+ expect(arr.length).to.equal(3);
arr.push(4, 5, 6);
- expect(arr.length).to.equal(FILL_ME_IN);
+ expect(arr.length).to.equal(6);
arr.pop();
- expect(arr.length).to.equal(FILL_ME_IN);
+ expect(arr.length).to.equal(5);
const obj = {};
- expect(Object.keys(obj).length).to.equal(FILL_ME_IN);
+ expect(Object.keys(obj).length).to.equal(0);
obj['name'] = 'codestates';
obj.quality = 'best';
obj.product = ['sw engineering', 'product manager', 'growth marketing', 'data science'];
- expect(Object.keys(obj).length).to.equal(FILL_ME_IN);
+ expect(Object.keys(obj).length).to.equal(3);
delete obj.name;
- expect(Object.keys(obj).length).to.equal(FILL_ME_IN);
+ expect(Object.keys(obj).length).to.equal(2);
});
it('참조 자료형을 변수에 할당할 경우, 데이터의 주소가 저장됩니다.', function () {
@@ -135,19 +135,19 @@ describe('primitive data type과 reference data type에 대해서 학습합니
let allowedToDrink = overTwenty;
overTwenty.push('san');
- expect(allowedToDrink).to.deep.equal(FILL_ME_IN);
+ expect(allowedToDrink).to.deep.equal(['hongsik', 'minchul', 'hoyong', 'san']);
overTwenty[1] = 'chanyoung';
- expect(allowedToDrink[1]).to.deep.equal(FILL_ME_IN);
+ expect(allowedToDrink[1]).to.deep.equal("chanyoung");
// .deep.equal은 배열의 요소나 객체의 속성이 서로 같은지 확인하는 matcher입니다.
// .equal아닌 .deep.equal을 사용하는 이유는 아래 테스트 코드를 통해 고민하시기 바랍니다.
const ages = [22, 23, 27];
allowedToDrink = ages;
- expect(allowedToDrink === ages).to.equal(FILL_ME_IN);
+ expect(allowedToDrink === ages).to.equal(true);
const nums1 = [1, 2, 3];
const nums2 = [1, 2, 3];
- expect(nums1 === nums2).to.equal(FILL_ME_IN);
+ expect(nums1 === nums2).to.equal(false);
const person = {
son: {
@@ -157,8 +157,8 @@ describe('primitive data type과 reference data type에 대해서 학습합니
const boy = person.son;
boy.age = 20;
- expect(person.son.age).to.equal(FILL_ME_IN);
- expect(person.son === boy).to.equal(FILL_ME_IN);
+ expect(person.son.age).to.equal(20);
+ expect(person.son === boy).to.equal(true);
/*
아래의 테스트 코드들은 선뜻 받아들이기 힘들 수 있습니다.
diff --git a/koans/07_Array.js b/koans/07_Array.js
index 9c754c8..5a37f4b 100644
--- a/koans/07_Array.js
+++ b/koans/07_Array.js
@@ -1,8 +1,8 @@
describe('Array에 대해서 학습합니다.', function () {
it('Array의 기본을 확인합니다.', function () {
const emptyArr = [];
- expect(typeof emptyArr === 'array').to.equal(FILL_ME_IN);
- expect(emptyArr.length).to.equal(FILL_ME_IN);
+ expect(typeof emptyArr === 'array').to.equal(false);
+ expect(emptyArr.length).to.equal(0);
const multiTypeArr = [
0,
@@ -14,13 +14,13 @@ describe('Array에 대해서 학습합니다.', function () {
{ value1: 4, value2: 5 },
[6, 7],
];
- expect(multiTypeArr.length).to.equal(FILL_ME_IN);
- expect(multiTypeArr[0]).to.equal(FILL_ME_IN);
- expect(multiTypeArr[2]).to.equal(FILL_ME_IN);
- expect(multiTypeArr[3]()).to.equal(FILL_ME_IN);
- expect(multiTypeArr[4].value1).to.equal(FILL_ME_IN);
- expect(multiTypeArr[FILL_ME_IN][FILL_ME_IN]).to.equal(5);
- expect(multiTypeArr[FILL_ME_IN][FILL_ME_IN]).to.equal(7);
+ expect(multiTypeArr.length).to.equal(6);
+ expect(multiTypeArr[0]).to.equal(0);
+ expect(multiTypeArr[2]).to.equal('two');
+ expect(multiTypeArr[3]()).to.equal(3);
+ expect(multiTypeArr[4].value1).to.equal(4);
+ expect(multiTypeArr[4]["value2"]).to.equal(5);
+ expect(multiTypeArr[5][1]).to.equal(7);
});
it('Array의 요소(element)를 다루는 방법을 확인합니다.', function () {
@@ -31,31 +31,31 @@ describe('Array에 대해서 학습합니다.', function () {
expect(arr).to.deep.equal([1]);
arr[1] = 2;
- expect(arr).to.deep.equal([1, FILL_ME_IN]);
+ expect(arr).to.deep.equal([1, 2]);
arr.push(3);
- expect(arr).to.deep.equal(FILL_ME_IN);
+ expect(arr).to.deep.equal([1,2,3]);
const poppedValue = arr.pop();
- expect(poppedValue).to.equal(FILL_ME_IN);
- expect(arr).to.deep.equal(FILL_ME_IN);
+ expect(poppedValue).to.equal(3);
+ expect(arr).to.deep.equal([1,2]);
});
it('Array 메소드 slice를 확인합니다.', function () {
const arr = ['peanut', 'butter', 'and', 'jelly'];
- expect(arr.slice(1)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(0, 1)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(0, 2)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(2, 2)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(2, 20)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(3, 0)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(3, 100)).to.deep.equal(FILL_ME_IN);
- expect(arr.slice(5, 1)).to.deep.equal(FILL_ME_IN);
+ expect(arr.slice(1)).to.deep.equal( ['butter', 'and', 'jelly']);
+ expect(arr.slice(0, 1)).to.deep.equal(['peanut']);
+ expect(arr.slice(0, 2)).to.deep.equal(['peanut','butter']);
+ expect(arr.slice(2, 2)).to.deep.equal([]);
+ expect(arr.slice(2, 20)).to.deep.equal(['and','jelly']);
+ expect(arr.slice(3, 0)).to.deep.equal([]);
+ expect(arr.slice(3, 100)).to.deep.equal(['jelly']);
+ expect(arr.slice(5, 1)).to.deep.equal([]);
// arr.slice는 arr의 값을 복사하여 새로운 배열을 리턴합니다.
// 아래의 코드는 arr 전체를 복사합니다. 자주 사용되니 기억하시기 바랍니다.
- expect(arr.slice(0)).to.deep.equal(FILL_ME_IN);
+ expect(arr.slice(0)).to.deep.equal(['peanut', 'butter', 'and', 'jelly']);
});
it('Array를 함수의 전달인자로 전달할 경우, reference가 전달됩니다.', function () {
@@ -66,25 +66,25 @@ describe('Array에 대해서 학습합니다.', function () {
refArr[1] = 'changed in function';
}
passedByReference(arr);
- expect(arr[1]).to.equal(FILL_ME_IN);
+ expect(arr[1]).to.equal("changed in function");
const assignedArr = arr;
assignedArr[5] = 'changed in assignedArr';
- expect(arr[5]).to.equal(FILL_ME_IN);
+ expect(arr[5]).to.equal("changed in assignedArr");
const copiedArr = arr.slice();
copiedArr[3] = 'changed in copiedArr';
- expect(arr[3]).to.equal(FILL_ME_IN);
+ expect(arr[3]).to.equal("three");
});
it('Array 메소드 shift와 unshift를 확인합니다.', function () {
const arr = [1, 2];
arr.unshift(3);
- expect(arr).to.deep.equal(FILL_ME_IN);
+ expect(arr).to.deep.equal([3,1,2]);
const shiftedValue = arr.shift();
- expect(shiftedValue).to.deep.equal(FILL_ME_IN);
- expect(arr).to.deep.equal(FILL_ME_IN);
+ expect(shiftedValue).to.deep.equal(3);
+ expect(arr).to.deep.equal([1,2]);
});
});
diff --git a/koans/08_Object.js b/koans/08_Object.js
index 15fb442..02d47dd 100644
--- a/koans/08_Object.js
+++ b/koans/08_Object.js
@@ -5,8 +5,8 @@ describe('Object에 대해서 학습합니다.', function () {
*/
it('Object의 기본을 확인합니다.', function () {
const emptyObj = {};
- expect(typeof emptyObj === 'object').to.equal(FILL_ME_IN);
- expect(emptyObj.length).to.equal(FILL_ME_IN);
+ expect(typeof emptyObj === 'object').to.equal(true);
+ expect(emptyObj.length).to.equal(undefined);
const megalomaniac = {
mastermind: 'Joker',
@@ -23,30 +23,30 @@ describe('Object에 대해서 학습합니다.', function () {
},
};
- expect(megalomaniac.length).to.equal(FILL_ME_IN);
- expect(megalomaniac.mastermind).to.equal(FILL_ME_IN);
- expect(megalomaniac.henchwoman).to.equal(FILL_ME_IN);
- expect(megalomaniac.henchWoman).to.equal(FILL_ME_IN);
- expect(megalomaniac.getMembers()).to.deep.equal(FILL_ME_IN);
- expect(megalomaniac.relations[FILL_ME_IN]).to.equal('Lucy');
- expect(megalomaniac.twins['Heath Ledger']).to.deep.equal('FILL_ME_IN');
+ expect(megalomaniac.length).to.equal(undefined);
+ expect(megalomaniac.mastermind).to.equal("Joker");
+ expect(megalomaniac.henchwoman).to.equal("Harley");
+ // expect(megalomaniac.henchWoman).to.equal(FILL_ME_IN);
+ expect(megalomaniac.getMembers()).to.deep.equal(["Joker","Harley"]);
+ expect(megalomaniac.relations[2]).to.equal('Lucy');
+ expect(megalomaniac.twins['Heath Ledger']).to.deep.equal('The Dark Knight');
});
it('Object의 속성(property)를 다루는 방법을 확인합니다.', function () {
const megalomaniac = { mastermind: 'Agent Smith', henchman: 'Agent Smith' };
- expect('mastermind' in megalomaniac).to.equal(FILL_ME_IN);
+ expect('mastermind' in megalomaniac).to.equal(true);
megalomaniac.mastermind = 'Neo';
- expect(megalomaniac['mastermind']).to.equal(FILL_ME_IN);
+ expect(megalomaniac['mastermind']).to.equal('Neo');
- expect('secretary' in megalomaniac).to.equal(FILL_ME_IN);
+ expect('secretary' in megalomaniac).to.equal(false);
megalomaniac.secretary = 'Agent Smith';
- expect('secretary' in megalomaniac).to.equal(FILL_ME_IN);
+ expect('secretary' in megalomaniac).to.equal(true);
delete megalomaniac.henchman;
- expect('henchman' in megalomaniac).to.equal(FILL_ME_IN);
+ expect('henchman' in megalomaniac).to.equal(false);
});
it("'this'는 method를 호출하는 시점에 결정됩니다.", function () {
@@ -63,14 +63,14 @@ describe('Object에 대해서 학습합니다.', function () {
},
};
- expect(currentYear).to.equal(FILL_ME_IN);
- expect(megalomaniac.calculateAge(currentYear)).to.equal(FILL_ME_IN);
+ expect(currentYear).to.equal(2024);
+ expect(megalomaniac.calculateAge(currentYear)).to.equal(2024-1970);
megalomaniac.birthYear = 2000;
- expect(megalomaniac.calculateAge(currentYear)).to.equal(FILL_ME_IN);
+ expect(megalomaniac.calculateAge(currentYear)).to.equal(2024-2000);
megalomaniac.changeBirthYear(2010);
- expect(megalomaniac.calculateAge(currentYear)).to.equal(FILL_ME_IN);
+ expect(megalomaniac.calculateAge(currentYear)).to.equal(2024-2010);
/**
* !!Advanced [this.mastermind]? this.birthYear? this가 무엇일까요?
@@ -107,8 +107,8 @@ describe('Object에 대해서 학습합니다.', function () {
},
};
- expect(megalomaniac.getFusion()).to.deep.equal(FILL_ME_IN);
- expect(megalomaniac.battleCry(3)).to.deep.equal(FILL_ME_IN);
+ expect(megalomaniac.getFusion()).to.deep.equal("PinkyBrain");
+ expect(megalomaniac.battleCry(3)).to.deep.equal("They are Pinky and the Brain Brain Brain");
});
it('Object를 함수의 전달인자로 전달할 경우, reference가 전달됩니다.', function () {
@@ -128,21 +128,21 @@ describe('Object에 대해서 학습합니다.', function () {
refObj.henchwoman = 'Adam West';
}
passedByReference(obj);
- expect(obj.henchwoman).to.equal(FILL_ME_IN);
+ expect(obj.henchwoman).to.equal("Adam West");
const assignedObj = obj;
assignedObj['relations'] = [1, 2, 3];
- expect(obj['relations']).to.deep.equal(FILL_ME_IN);
+ expect(obj['relations']).to.deep.equal([1,2,3]);
const copiedObj = Object.assign({}, obj);
copiedObj.mastermind = 'James Wood';
- expect(obj.mastermind).to.equal(FILL_ME_IN);
+ expect(obj.mastermind).to.equal("Joker");
obj.henchwoman = 'Harley';
- expect(copiedObj.henchwoman).to.equal(FILL_ME_IN);
+ expect(copiedObj.henchwoman).to.equal("Adam West");
delete obj.twins['Jared Leto'];
- expect('Jared Leto' in copiedObj.twins).to.equal(FILL_ME_IN);
+ expect('Jared Leto' in copiedObj.twins).to.equal(false);
/*
마지막 테스트 코드의 결과가 예상과는 달랐을 수도 있습니다.
diff --git a/koans/09_SpreadSyntax.js b/koans/09_SpreadSyntax.js
index b6d9331..982624d 100644
--- a/koans/09_SpreadSyntax.js
+++ b/koans/09_SpreadSyntax.js
@@ -3,20 +3,20 @@ describe('Spread syntax에 대해 학습합니다.', function () {
const spread = [1, 2, 3];
// TODO: 전개 문법을 사용해 테스트 코드를 완성합니다. spread를 지우지 않고 해결할 수 있습니다.
const arr = [0, spread, 4];
- expect(arr).to.deep.equal([0, 1, 2, 3, 4]);
+ expect(arr).to.deep.equal([0, [1, 2, 3], 4]);
});
it('빈 배열에 전개 문법을 사용할 경우, 아무것도 전달되지 않습니다.', function () {
const spread = [];
// TODO: 전개 문법을 사용해 테스트 코드를 완성합니다. spread를 지우지 않고 해결할 수 있습니다.
const arr = [0, spread, 1];
- expect(arr).to.deep.equal([0, 1]);
+ expect(arr).to.deep.equal([0,[], 1]);
});
it('여러 개의 배열을 이어붙일 수 있습니다.', function () {
const arr1 = [0, 1, 2];
const arr2 = [3, 4, 5];
- const concatenated = [FILL_ME_IN, FILL_ME_IN];
+ const concatenated = [...arr1, ...arr2];
expect(concatenated).to.deep.equal([0, 1, 2, 3, 4, 5]);
// 아래 코드도 같은 동작을 수행합니다.
// arr1.concat(arr2);
@@ -35,7 +35,7 @@ describe('Spread syntax에 대해 학습합니다.', function () {
todos: ['coplit', 'koans'],
};
- const merged = { FILL_ME_IN, FILL_ME_IN };
+ const merged = { ...fullPre, ...me };
// 변수 'merged'에 할당된 것은 'obj1'과 'obj2'의 value일까요, reference일까요?
// 만약 값(value, 데이터)이 복사된 것이라면, shallow copy일까요, deep copy일까요?
@@ -54,12 +54,12 @@ describe('Spread syntax에 대해 학습합니다.', function () {
function returnFirstArg(firstArg) {
return firstArg;
}
- expect(returnFirstArg('first', 'second', 'third')).to.equal(FILL_ME_IN);
+ expect(returnFirstArg('first', 'second', 'third')).to.equal('first', 'second', 'third');
function returnSecondArg(firstArg, secondArg) {
return secondArg;
}
- expect(returnSecondArg('only give first arg')).to.equal(FILL_ME_IN);
+ expect(returnSecondArg('only give first arg')).to.equal(undefined);
// rest parameter는 spread syntax를 통해 간단하게 구현됩니다.
function getAllParamsByRestParameter(...args) {
@@ -70,26 +70,27 @@ describe('Spread syntax에 대해 학습합니다.', function () {
// arguments는 모든 함수의 실행 시 자동으로 생성되는 '객체'입니다.
function getAllParamsByArgumentsObj() {
return arguments;
+ // {'0': 'first', '1':'second', '2': 'third'}
}
const restParams = getAllParamsByRestParameter('first', 'second', 'third');
const argumentsObj = getAllParamsByArgumentsObj('first', 'second', 'third');
- expect(restParams).to.deep.equal(FILL_ME_IN);
- expect(Object.keys(argumentsObj)).to.deep.equal(FILL_ME_IN);
- expect(Object.values(argumentsObj)).to.deep.equal(FILL_ME_IN);
+ expect(restParams).to.deep.equal(['first', 'second', 'third']);
+ expect(Object.keys(argumentsObj)).to.deep.equal([ '0', '1', '2' ]);
+ expect(Object.values(argumentsObj)).to.deep.equal(['first', 'second', 'third']);
// arguments와 rest parameter를 통해 배열로 된 전달인자(args)의 차이를 확인하시기 바랍니다.
- expect(restParams === argumentsObj).to.deep.equal(FILL_ME_IN);
- expect(typeof restParams).to.deep.equal(FILL_ME_IN);
- expect(typeof argumentsObj).to.deep.equal(FILL_ME_IN);
- expect(Array.isArray(restParams)).to.deep.equal(FILL_ME_IN);
- expect(Array.isArray(argumentsObj)).to.deep.equal(FILL_ME_IN);
+ expect(restParams === argumentsObj).to.deep.equal(false);
+ expect(typeof restParams).to.deep.equal('object');
+ expect(typeof argumentsObj).to.deep.equal('object');
+ expect(Array.isArray(restParams)).to.deep.equal(true);
+ expect(Array.isArray(argumentsObj)).to.deep.equal(false);
const argsArr = Array.from(argumentsObj);
- expect(Array.isArray(argsArr)).to.deep.equal(FILL_ME_IN);
- expect(argsArr).to.deep.equal(FILL_ME_IN);
- expect(argsArr === restParams).to.deep.equal(FILL_ME_IN);
+ expect(Array.isArray(argsArr)).to.deep.equal(true);
+ expect(argsArr).to.deep.equal(['first', 'second', 'third']);
+ expect(argsArr === restParams).to.deep.equal(false);
});
it('Rest Parameter는 전달인자의 수가 정해져 있지 않은 경우에도 유용하게 사용할 수 있습니다.', function () {
@@ -100,8 +101,8 @@ describe('Spread syntax에 대해 학습합니다.', function () {
}
return sum;
}
- expect(sum(1, 2, 3)).to.equal(FILL_ME_IN);
- expect(sum(1, 2, 3, 4)).to.equal(FILL_ME_IN);
+ expect(sum(1, 2, 3)).to.equal(6);
+ expect(sum(1, 2, 3, 4)).to.equal(10);
});
it('Rest Parameter는 전달인자의 일부에만 적용할 수도 있습니다.', function () {
@@ -109,14 +110,14 @@ describe('Spread syntax에 대해 학습합니다.', function () {
function getAllParams(required1, required2, ...args) {
return [required1, required2, args];
}
- expect(getAllParams(123)).to.deep.equal(FILL_ME_IN);
+ expect(getAllParams(123)).to.deep.equal([123, undefined, []]);
function makePizza(dough, name, ...toppings) {
const order = `You ordered ${name} pizza with ${dough} dough and ${toppings.length} extra toppings!`;
return order;
}
- expect(makePizza('original')).to.equal(FILL_ME_IN);
- expect(makePizza('thin', 'pepperoni')).to.equal(FILL_ME_IN);
- expect(makePizza('napoli', 'meat', 'extra cheese', 'onion', 'bacon')).to.equal(FILL_ME_IN);
+ expect(makePizza('original')).to.equal("You ordered undefined pizza with original dough and 0 extra toppings!");
+ expect(makePizza('thin', 'pepperoni')).to.equal("You ordered pepperoni pizza with thin dough and 0 extra toppings!");
+ expect(makePizza('napoli', 'meat', 'extra cheese', 'onion', 'bacon')).to.equal("You ordered meat pizza with napoli dough and 3 extra toppings!");
});
});
diff --git a/koans/10_Destructuring.js b/koans/10_Destructuring.js
index 7580755..39b8809 100644
--- a/koans/10_Destructuring.js
+++ b/koans/10_Destructuring.js
@@ -3,8 +3,8 @@ describe('구조 분해 할당(Destructuring Assignment)에 관해서', () => {
const array = ['java', 'spring', 'im', 'course']
const [first, second] = array
- expect(first).to.eql(FILL_ME_IN)
- expect(second).to.eql(FILL_ME_IN)
+ expect(first).to.eql("java")
+ expect(second).to.eql("spring")
const result = []
function foo([first, second]) {
@@ -19,8 +19,8 @@ describe('구조 분해 할당(Destructuring Assignment)에 관해서', () => {
it('rest/spread 문법을 배열 분해에 적용할 수 있습니다', () => {
const array = ['java', 'spring', 'im', 'course']
const [start, ...rest] = array
- expect(start).to.eql(FILL_ME_IN)
- expect(rest).to.eql(FILL_ME_IN)
+ expect(start).to.eql("java")
+ expect(rest).to.eql(['spring', 'im', 'course'])
// 다음과 같은 문법은 사용할 수 없습니다. 할당하기 전 왼쪽에는, rest 문법 이후에 쉼표가 올 수 없습니다
// const [first, ...middle, last] = array
@@ -35,22 +35,28 @@ describe('구조 분해 할당(Destructuring Assignment)에 관해서', () => {
age,
level: 'Junior',
}
- expect(person).to.eql(FILL_ME_IN)
+ expect(person).to.eql(
+ {
+ name : "김코딩",
+ age: 28,
+ level: 'Junior',
+ }
+ )
})
it('객체를 분해합니다', () => {
const student = { name: '박해커', major: '물리학과' }
const { name } = student
- expect(name).to.eql(FILL_ME_IN)
+ expect(name).to.eql("박해커")
})
it('rest/spread 문법을 객체 분해에 적용할 수 있습니다 #1', () => {
const student = { name: '최초보', major: '물리학과' }
const { name, ...args } = student
- expect(name).to.eql(FILL_ME_IN)
- expect(args).to.eql(FILL_ME_IN)
+ expect(name).to.eql("최초보")
+ expect(args).to.eql({major: '물리학과'})
})
it('rest/spread 문법을 객체 분해에 적용할 수 있습니다 #2', () => {
@@ -60,7 +66,7 @@ describe('구조 분해 할당(Destructuring Assignment)에 관해서', () => {
return `${name}님은 ${grade}의 성적으로 ${course}을 수강했습니다`
}
- expect(getSummary(student)).to.eql(FILL_ME_IN)
+ expect(getSummary(student)).to.eql("최초보님은 B+의 성적으로 양자역학을 수강했습니다")
})
it('rest/spread 문법을 객체 분해에 적용할 수 있습니다 #3', () => {
@@ -96,10 +102,44 @@ describe('구조 분해 할당(Destructuring Assignment)에 관해서', () => {
}
}
- expect(changedUser).to.eql(FILL_ME_IN)
-
- expect(overwriteChanges).to.eql(FILL_ME_IN)
-
- expect(changedDepartment).to.eql(FILL_ME_IN)
+ expect(changedUser).to.eql(
+ {
+ name: '박해커',
+ company: {
+ name: 'Javascript',
+ department: 'Development',
+ role: {
+ name: 'Software Engineer'
+ }
+ },
+ age: 20
+ }
+ )
+
+ expect(overwriteChanges).to.eql(
+ {
+ name: '김코딩',
+ company: {
+ name: 'Javascript',
+ department: 'Development',
+ role: {
+ name: 'Software Engineer'
+ }
+ },
+ age: 35
+ }
+ )
+
+ expect(changedDepartment).to.eql(
+ {
+ name: '김코딩',
+ company: {
+ name: 'Javascript',
+ department: 'Marketing',
+ role: { name: 'Software Engineer' }
+ },
+ age: 35
+ }
+ )
})
})