์๊ณ ๋ฆฌ์ฆ
์๋์ฝ๋ ์์ฑ Checklist
์ฝ๋ฉํ๊ธฐ ์ ์ ์ด๋ป๊ฒ ํ๋ก๊ทธ๋จ์ด ์๋ํ๋์ง ํ๋ฆ์ ํ์ ํ์.
์๋์ฝ๋ ์์ (ํ ์คํธ์์ foo๋ผ๋ ๋จ์ด๋ฅผ ์ฐพ์ ์ ๋ถ ๋ค๋ฅธ ๋จ์ด๋ก ๋ฐ๊ฟ์ฃผ๋ ์ฝ๋)
๊ธฐ๋ณธ
๊ตฌ์ฒดํ (์๋ฐ์คํฌ๋ฆฝํธ๊ฐ ํ ์ ์๋ ๊ฒ๊ณผ ํ ์ ์๋ ๊ฒ์ ๋ํด ์๊ฐํ๋ฉฐ ์ด๋ค ๊ธฐ๋ฅ์ ์ธ์ง ๊ตฌ์ฒดํํด ๋ณธ๋ค.)
๊ตฌํ
function replaceFoo(text) {
// foo๋ผ๋ ๊ธ์์ index๊ฐ -1์ด ์๋๋ฉด ๋จ์ด๋ฅผ ์ฐพ์ ๊ฒ์ด๋ค
while( text.indexOf('foo') !== -1 ) { // index๋ฅผ ๋ฐ๊ฒฌํ๋ฉด
let index = text.indexOf('foo');
// index๋ฅผ ์ด์ฉํด foo ๋ฐ๋ก ์๊น์ง์ ํ
์คํธ๋ฅผ ์ป์ด๋ด๊ณ
let beforeText = text.slice(0, index);
// foo ๋์ ์๋ก์ด ๋จ์ด๋ฅผ ๋ฃ๋๋ค
let replaceText = 'BAR';
// foo ์ดํ์ ํ
์คํธ๋ฅผ ๋ฃ๋๋ค
let afterText = text.slice(index + 3); // 'foo'๋ ์ธ ๊ธ์์ด๋ฏ๋ก 3์ ๋ํจ
text = beforeText + replaceText + afterText;
}
return text; // ๋ฐ๋ ๋ด์ฉ์ ๋ฆฌํดํ๋ค
}
(+) ๋ฌธ์ ๋ถํด
find(text, searchString);
replace(text, searchString, replaceString);
์ฝ๋ ์คํ์ผ๋ง
๋ค์ฌ์ฐ๊ธฐ(Indentation)
if
, while
๋ฑ ์ค๊ดํธ ์์ ์ข
์๋ ์ฝ๋๊ฐ ์๋ ๊ฒฝ์ฐ, ์ข
์๋ ์ฝ๋ ๋ธ๋ก์ ์ฃผ์ธ ์ฝ๋ ๋ธ๋ก๋ณด๋ค ๋ ์นธ ๋ค์ฌ์ฐ๊ธฐํ๋ค.if (condition) {
action();
} // ์ข
์๋ ์ฝ๋ ๋ธ๋ก ๋ง์ง๋ง ์ค์ ์ค๊ดํธ๋ ์์ํ ์ค(์ฌ๊ธฐ์๋ if ์)๊ณผ ๋์ผํ ์์น์ ๋๋๋ค.
์ด๋ฆ ์ง๊ธฐ(Naming)
๋ณ์๋ช ์ ๊ฐ์ ๋ณธ์ง์ ์ธ ์๋ฏธ๋ฅผ ์ง๋ ์ผ ํ๋ค. ๊ฐ๋ฐ ๋ถ์ผ์ ํต์ฌ์ ์ ๋ฌ์ฌํด์ค์๋ก, ํ ๋จ์ด๋ก ํํํ ์๋ก ์ข๋ค. (๊ธ์ต ๊ด๋ จ ๊ฐ๋ฐ์ ํ๋ ๊ฒฝ์ฐ ๊ทธ ๋ถ์ผ์์ ์ฌ์ฉํ๋ ์ฉ์ด ์ฌ์ฉ)
let interestRate = 0.2; //์ด์์จ์์ ์ฝ๊ฒ ์ ์ ์๋ค.
๋ณ์์ ํ ๋น๋๋ ๊ฐ์ ํ์์ด ์๋, ๊ทธ ๊ฐ์ ์๋ฏธ๊ฐ ๋ณ์ ์ด๋ฆ์ ๋ฐ์๋์ด์ผ ํ๋ค.
let animals = ['cat', 'dog', 'fish'];
//targetInput๊ณผ ๊ฐ์ด ๋ณ์๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ตฌ์กฐ๋ฅผ ํํํ๊ณ ์๋ ๋ณ์๋ช
๋ณด๋ค
//๊ฐ์ ์๋ฏธ๋ฅผ ๋ฐ์ํ animals๊ฐ ๋ซ๋ค.
๋ฐ์ดํฐ์ ๋ชจ์(collection)์ด ํ ๋น๋ ๋ณ์์ ์ด๋ฆ์ ๋ณต์ ๋ช
์ฌ๊ฐ ์ข๋ค. ์์ ์์ ์ฝ๋๋ก ์๋ฅผ ๋ค์๋ฉด, animalList๋ณด๋ค๋ animals๊ฐ ์๋ฏธ๋ฅผ ๋ ์ ํํํ๊ธฐ ๋๋ฌธ์ animals๋ฅผ ์ฌ์ฉํ๋ค. (๋จ์ animal์ NO!)
boolean์ด ํ ๋น๋ ๋ณ์๋ is
ํน์ are
์ ๋ถ์ฌ์ ์ฐธ ํน์ ๊ฑฐ์ง์์ ๋ถ๋ช
ํ ํํํ๋ค.
let isDog = true;
let ๊ฐ์์ง์
๋๋ค = true;
ํจ์์ ์ด๋ฆ์ ๋์ฌ๋ก ์์ํ๋ ๊ฒ ์ข๋ค. ๊ธฐ๋ฅ์ ๋ด์ ๋์ฌ๋ฅผ ํจ์๋ช ์ ํฌํจํ๋ฉด ์ญํ ์ ์ฝ๊ฒ ํ์ ํ ์ ์๊ณ , ํจ์์ ์ ๋ ฅ๊ฐ๊ณผ ์ถ๋ ฅ๊ฐ, ๋ ์ฌ์ด์ ๋ณํ ๊ณผ์ ์ ํ์ ํ๊ธฐ ์ฝ๋ค.
let countBlocks = function() {
// ๋ฒฝ๋์ ๊ฐ์๋ฅผ ์ธ๋ ํจ์์์ ์ฝ๊ฒ ์ ์ ์์ต๋๋ค.
}
๋ณ์ ํ ๋น ๊ฐ์ด Class์ธ ๊ฒฝ์ฐ์๋ ์ฃผ๋ก ๋ณ์์ ์ฒซ ๊ธ์๋ฅผ ๋๋ฌธ์๋ก ์ฌ์ฉํ๋ค. new
ํค์๋๋ฅผ ์ฌ์ฉํ ํจ์์ ํํด์ ๋๋ฌธ์๋ฅผ ์ฐ๊ธฐ๋ ํ๋ค. (class ์ญํ ์ ํ๊ธฐ ๋๋ฌธ)
class Animal(){
// ES6 ๋ถํฐ ์ฌ์ฉ ๊ฐ๋ฅํ class๊ฐ ํ ๋น๋๋ ๋ณ์๋ ์ฒซ ๊ธ์๋ฅผ ๋๋ฌธ์๋ก ์ ์ต๋๋ค.
}
function Animal() {
// class ์์ฑ์ ํจ์๊ฐ ๋ ํจ์์ด๋ฏ๋ก ๋๋ฌธ์๋ก ์ ์ต๋๋ค.
}
์์๋ ๋ชจ๋ ๋๋ฌธ์๋ก ์ ๋๋ค.
const MAX_ITEMS_IN_QUEUE = 100;
๊ธฐํธ ๋ฐ ๊ตฌ๋์ (Punctuation)
for
๋ฌธ์ด๋ if
๋ฌธ ๋ฑ์์ ์ข
์ ์ฝ๋๊ฐ 1์ค์ผ ๊ฒฝ์ฐ ์ค๊ดํธ๋ฅผ ์๋ตํ ์ ์์ผ๋, ์๋ตํ์ง ์๊ณ ๋ชจ๋ ์จ์ค๋ค.)let dog = 'dog';
let cat = 'cat';
let multilineText = `this is line one
this is line two
this is line three`;
// ์ํฐ๊ฐ ๋ช
ํํ๊ฒ ๋ณด์
๋๋ค.
alert('hi');
if
, for
, while
๋ฌธ์ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ์ ์ฌ์ฉํ์ง ์๋๋ค. ์ค๊ดํธ๋ก ๋๋๋ Statement๋ ์ด๋ฏธ ์ข
๋ฃ๊ฐ ์์๋์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.if (condition) {
response();
}
let greet = function () {
alert('hi');
};
์ฐ์ฐ์์ ํค์๋
์๊ฒฉํ ๋น๊ต ์ฐ์ฐ์(strict equality, ===
, !==
)๋ฅผ ์ฌ์ฉํ๋ค.
3ํญ ์ฐ์ฐ์(?
)๋ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋
์ฑ์ด ์ข์ ๊ฒฝ์ฐ๋ง ์ฌ์ฉํ๋ค. ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค์ง๋ง ๋ฆฌํด ๊ฐ์ด ์ฅํฉํ ๊ฒฝ์ฐ ๊ฐ๋
์ฑ์ด ๋จ์ด์ง๋ค.
// **BAD!**
return (actual === expected) ? 'passed' : 'FAILED ['
+ testName + '] Expected "'+expected+'",but got '+'"'+actual+'"';
};
not ์ฐ์ฐ์('!')๋ ๋ฐ๋ก ์์ ๋ถ์ฌ์ ์ฌ์ฉํ๋ค.
if (!isEqual) {
์งง๊ฒ ์ฐ๊ธฐ
if(!equalSizes || !equalValues)
์ฒ๋ผ ๋จ๋ฐํ์ง ์๋๋ค. ๋ถํ์ํ๊ฒ ์กฐ๊ฑด์ ๋ํด ๊ณ ๋ฏผํ๊ฒ ๋ง๋ ๋ค.return charSet.size > text.length;
๋น๊ต๋ฌธ์ ๋ฌด์กฐ๊ฑด true ํน์ false๋ก ํ๊ฐ๋๊ธฐ ๋๋ฌธ์ ์กฐ๊ฑด๋ฌธ์ ์์ฑํ์ง ์์๋ ๋๋ค.์ฝ๋ ๋ฌธ์ฅ๊ณผ ๊ตฌ๋ฌธ ์ฌ์ด ๊ณต๊ฐ
alert( 'I chose to put visual padding around this string' );
alert( 'I only put visual padding on one side of this string');
assertEqual(Math.pow(3, 2), 9, 'Math.pow squares properly');
'Failed [' + testName + ']'...
if(actual === expected)
์ฃผ์
CamelCase vs. snake_case
JavaScript์์๋ ๋ณ์์ ์ด๋ฆ์ ์ง์ ํ ๋ Camel Casing์ผ๋ก ์ง์ ํ๋ค. (Ruby ๊ฐ์ ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์๋ Snake Casing์ ์ฌ์ฉํ๋ค.) ๋จ, ์์ ์ด๋ฆ์ ์ง์ ๋๋ Snake Casing์ ์ฌ์ฉํ๋ค.
Camel Casing let camelCased = 'Used in javascript';
Snake Casing let snake_cased = 'Used in other languages';
์ ๋ช ํ ์ฝ๋ ์คํ์ผ ๊ฐ์ด๋
์ถ๊ฐ
String
๊ฐ์ฒด๋ฅผ ์ง์ ํ ๊ตฌ๋ถ์๋ฅผ ์ด์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ ๋ฌธ์์ด๋ก ๋๋๋ค.str.split([separator[, limit]])
String
๊ฐ์ฒด์์ ์ฃผ์ด์ง ๊ฐ๊ณผ ์ผ์นํ๋ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ค. ์ผ์นํ๋ ๊ฐ์ด ์์ผ๋ฉด -1์ ๋ฐํํ๋ค.str.indexOf(searchValue[, fromIndex])
Array
์ ๋ชจ๋ ์์๋ฅผ ์ฐ๊ฒฐํด ํ๋์ ๋ฌธ์์ด๋ก ๋ง๋ค์ด ๋ฐํํ๋ค. arr.length๊ฐ 0์ด๋ผ๋ฉด, ๋น ๋ฌธ์์ด์ ๋ฐํํ๋ค.arr.join([separator])
๋ด๊ฐ ๊ตฌ์ํ ์ฝ๋๋ฅผ ์ด๋ป๊ฒ ํ๋ฉด ์๋๋ฐฉ์๊ฒ ์ ์ค๋ช
ํ ์ ์์๊น? ์๋ง ์๋์ฝ๋ ์์ฑ ๊ฒฝํ์ด ๋ณ๋ก ์์ด์ ์ค๋ช
๋ ์ ๋๋ก ๋ชป ํ๋ ๊ฒ ๊ฐ๋ค. ํนํ ์ค๋์ ๊ธํ๊ฒ ์ค๋ช
ํ๋ ค๋ค ๋ณด๋ ๋ ํก์ค์์ค... ๋
ธํธ์ ์จ๋ณด๋ ค๊ณ ํด๋ ์ฐ๋ค ๋ณด๋ฉด ๊ทธ๋ฅ ์์ผ๋ก ํค๋ณด๋ ๋๋ค๊ธฐ๋ ๊ฒ์ฒ๋ผ ์ฝ๋๋ถํฐ ์จ ๋ด๋ ค๊ฐ๊ณ ์๋ค. ๐คท ํผ์์ ์์ฃผ ์ฐ์ตํด๋ด์ผ๊ฒ ๋ค.
์ดํดํ๋ค๊ณ ๊ธฐ์ตํ๋ค๊ณ ์๊ฐํ๋ ๊ฒ๋ค์ด ๊ธฐ์ด ์๊ณ ๋ฆฌ์ฆ์ ํ ๋์ฏค ๋๋ ํ๋ ค์ ธ ์์๋ค. ์ฃผ๋ง์ ์์ฃผ ์ฐ์๋ ๋ฉ์๋๋ค์ ์ ๋ฆฌํ์.