๊ณ์ udemy ๊ฐ์๋ง ์ซ์๊ฐ๋ค๋ณด๋ ๋ฌธ๋ฒ์ ์ธ ๋ถ๋ถ์์ ๋์น๋ ๊ฒ ๋ง์๋ค
๊ฐ์ฒด์ ํด๋์ค๋ ์ ๋๋ก ๊ตฌ๋ถ ๋ชปํ๊ณ ํจ์์ ๋ฉ์๋ ์์ ๋ง ๋ฐ๋ผ ํจ...
๊ฒ๋ค๊ฐ ๊ณ์ ์์ด๋ก ๊ฐ์ ๋ฃ๋ค ๋ณด๋ ํ์คํ๊ฒ ์ดํดํ์ง ๋ชปํ๊ณ ๋๊ธฐ๋ ๋ถ๋ถ๋ ์์์
๋น๋ถ๊ฐ์ ์๋ฐ์คํฌ๋ฆฝํธ ๋ฌธ๋ฒ ๊ณต๋ถ + udemy ๊ฐ์ ๋ณต์ต + ๊ธฐ๋ณธ ๊ฐ๋ฐ ์์์ ๋ํด ์ด๋์ ๋ ๊ณต๋ถํ๊ณ ๋ ํ ๋ค์ udemy ๊ฐ์๋ก ๋์๊ฐ๋ ค ํ๋ค.
๋คํํ ์ข์ ๊ฐ์๊ฐ ๋ง์์ ์ดํด๊ฐ ๋๋ฌด ์ ๋จ~
๐ ์ดํํ ์ฝ๋ฉ ์๊ฐ 9hour
๐๐ผ -
๐๐ผ -
[๋งํฌ ๋ชฉ๋ก]
Web Developer Bootcamp 2021
winningScoreSelect.addEventListener("change", function () {
winningScore = parseInt(this.value);
reset();
});
//์ฒซ๋ฒ์งธ ๋ฉ์๋
//this is the callback
//passing this anonymous function as a callback and excute reset inside
resetButton.addEventListener("click", reset);
//๋๋ฒ์งธ ๋ฉ์๋
//not executing, passing a reference
//it will execute reset when time is come
//passing as callback
function reset() {
isGameOver = false;
p1Score = 0;
p2Score = 0;
p1Display.textContent = 0;
p2Display.textContent = 0;
p1Display.classList.remove("winner", "loser");
p2Display.classList.remove("winner", "loser");
}
์๋ฌธ์
winningScoreSelect.addEventListener("change", changeScore);
function changeScore() {
winningScore = parseInt(this.value);
reset();
};
-> ์คํ์ด ๋๋ค... ์ฒซ๋ฒ์งธ ๋ฉ์๋์์ ์ต๋ช
ํจ์๋ ํธ์ถ์ด ์๋ ์ ์ธํ๋ ๊ฒ.
-> ์๋ฐ์คํฌ๋ฆฝํธ๋ ํจ์๋ ์ค๋ธ์ ํธ๋ผ๋ฉด, ์ฒซ๋ฒ์งธ ๋ฉ์๋์ ์ต๋ช
ํจ์์ reset ํจ์๋ ๋ชจ๋ ์ ์ธ๋ ๋ reference์ ์ ์ฅ๋๋ ๊ฒ..?
-> ์๋ฐ์คํฌ๋ฆฝํธ์์๋ ํจ์ ์์ฒด๊ฐ 1๊ธ ๊ฐ์ฒด, ๊ฐ์ผ๋ก ์ทจ๊ธ๋์ด ํ๋ผ๋ฏธํฐ๋ก๋ ์ ๋ฌ๋ ์ ์๋ค. ๊ทธ๋ ๋ค๋ฉด, reset์ด ๋๋ฒ์งธ ๋ฉ์๋์์ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ๋์ ๋,reset()์ addEventListener()๋ฅผ ์ฌ์ฉํ์ฌ ๋ฑ๋ก๋ click ์ด๋ฒคํธ์ ๋ํ ๋ฆฌ์ค๋์ด๋ค.
์ดํดํ ๊ฒฐ๊ณผ
-> ํจ์ ํํ์์ ๋ํ ์ดํด ๋ถ์กฑ์ผ๋ก ์๊ธด ์ผ
์ฒซ๋ฒ์งธ ๋ฉ์๋์์ ์ต๋ช
ํจ์๋ฅผ ์์ฑํด์ ๋ณ์๋ฅผ ํ ๋นํ๋ ๋ฐฉ์์ผ๋ก ํจ์ ํํ์ ๋ฐฉ์์ผ๋ก ํจ์๋ฅผ ์ ์ํ๊ณ ์๋ค.
๋ฐ๋ผ์ ์ฒซ๋ฒ์งธ ๋ฉ์๋ ๋๋ฒ์งธ ๋ฉ์๋ ๋ชจ๋ ๋ฆฌ์ค๋์ ํจ์ ์คํ์ด ์๋ ํจ์๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌํ๊ณ ์๋ค. ์ด๋ ๊ฒ ์ธ์๋ก ๋๊ฒจ์ง๋ ํจ์๋ฅผ ์ฝ๋ฐฑ ํจ์๋ผ๊ณ ๋ถ๋ฅธ๋ค.
์ฝ๋ฐฑ ํจ์๋ ์คํฌ๋ฆฝํธ์ ์ด๋ ๋ถ๋ถ์์๋ผ๋ ์ ์๋ ์ ์๋ค. ํจ์๋ฅผ ์ฝ๋ฐฑ ํจ์๋ก ์ฌ์ฉํ ๊ฒฝ์ฐ, ํจ์์ ์ด๋ฆ๋ง ์ธ์๋ก ๋๊ฒจ์ฃผ๋ฉด ๋๋ค.
ํจ์์ ์ธ์๋ก ์ ๋ฌ๋ ์ฝ๋ฐฑ ํจ์๋ ์ํ๋ ์์ ์ ์คํํ ์ ์๋ค
๋งค๊ฐ๋ณ์(parameter)
ํจ์์ ์ ์ ๋ถ๋ถ์ ๋์ด๋ผ ์๋ ๋ณ์(variable)
ํจ์์ ์ ์
def plus(a,b):
return a+b; //-> a, b
์ ๋ฌ์ธ์(argument)
ํจ์๋ฅผ ํธ์ถํ ๋ ์ ๋ฌ๋๋ ์ค์ ๊ฐ(value)
ํจ์์ ํธ์ถ
result = plus(1,2) //-> 1, 2
<script>
var a = { name: 'kim' }
var b = { name: 'jang' }//object ์๋ฃํ
//๋น์ทํ object๊ฐ ์์ ๊ฒฝ์ฐ class๋ฅผ ๋ง๋ ๋ค / class๋ object๋ฅผ ๋ฝ์๋ด๋ ๊ธฐ๊ณ
function ๊ธฐ๊ณ(){ //์์ ์๋ฐ์คํฌ๋ฆฝํธ ๋ฌธ๋ฒ์๋ ํด๋์ค๊ฐ ์์์ผ๋ function์ผ๋ก ํด๋์ค ๋ง๋ค์ด๋
this.name = 'kim'; //object ์์ฑ ๊ธฐ๊ณ = constructor ๋ผ๊ณ ํ๋ค
}
var a = new ๊ธฐ๊ณ(); //object ์์ฑ ํ์ค ์ปท
//this๋ ๊ธฐ๊ณ๋ก๋ถํฐ ์์ฑ๋๋ ์ค๋ธ์ ํธ (instance๋ผ๊ณ ํ๊ธฐ๋)
</script>
//ํ๋ผ๋ฏธํฐ ํ์ฉ๋ฒ
function ๊ธฐ๊ณ(i){
this.name = i;
}
var a = new ๊ธฐ๊ณ(kim);
//์ต๊ทผ class ๋ฌธ๋ฒ
class ๊ธฐ๊ณ {
constructor(i){
this.name = i;
}
new ๊ธฐ๊ณ();
single page application - react, angular, vue.js / node.js(๋ฐฑ์๋)
head ์์ script
์๊ฐ ์ค๋ ๊ฑธ๋ฆผ
body ์์ script
์ฝํ
์ธ ๋นจ๋ฆฌ ๋ณด๊ธด ํ๋ ์๋ฐ์คํฌ๋ฆฝํธ ์์กด ํ์ด์ง์ ์ ์ข์
head + async
async๋ boolean ํ์
์ ์์ฑ๊ฐ์ด๊ธฐ ๋๋ฌธ์ ์ ์ธํ๋ ๊ฒ๋ง์ผ๋ก๋ true๊ฐ ๋๋ค / ๋ณ๋ ฌ
์๊ฐ ์ ๊ฒ ๊ฑธ๋ฆฌ๋ js ์คํ๋๊ณ ์๋๋ฐ html ๋ด์์ ์ํ๋ ์์๊ฐ ์ ์๋ผ ์์ง ์์ ์๋ ์๋ค
์ ์๋ ์คํฌ๋ฆฝํธ ์์์ ์๊ด์์ด ๋ค์ด๋ก๋ ๋จผ์ ๋, fetching๋ ์คํฌ๋ฆฝํธ๋ฅผ ๋จผ์ ์คํ, excuteํ๋ค
-> ์์์ ์์กด์ ์ธ ์๋ฐ์คํฌ๋ฆฝํธ๋ ๋ฌธ์ ๊ฐ ๋จ
head + defer
<head>
<script defer src="main.js"></script>
</head>
defer์ ๊ฐ์ฅ ์ข์ ์ต์
์คํฌ๋ฆฝํธ ์์๋๋ก ์คํ๋๋ค
ํ์
์คํฌ๋ฆฝํธ ์ธ ๋๋ ์ ์ธํ ํ์ ์์
added in es 5
a=6; //strict ๋ชจ๋ ์๋ ๋์๋ ํ์ฉ
let a;
a = 6; //strict ๋ชจ๋์์๋ ๋ฐ๋์ ์ ์ธ๋ ๋ณ์๋ง ๊ฐ ํ ๋นํ ์ ์๋๋ก ํจ
์ ๋ ฅ - ์ฐ์ฐ - ์ถ๋ ฅ
variable - rw(read/write)
๋ณ๊ฒฝ๋ ์ ์๋ ๊ฐ
๋ณ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ ์ฝ๊ณ ์ฐ๋ ๊ฒ ๊ฐ๋ฅํ๋ค
let ํค์๋ (added in es6)
let name = 'ellie'; //let ์ด๋ผ๋ keyword๋ก name์ด๋ผ๋ variable๋ณ์๋ฅผ ์ ์ธdeclarationํ๋ค
name = 'hello';//name์ด๋ผ๋ ๋ณ์์ hello๋ผ๋ ๊ฐ์ ํ ๋นํ๋ค
์ ํ๋ฆฌ์ผ์ด์ ๋ง๋ค ์ธ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋๋ค - ํ ํ ๋น ๋ฐ์ค๋ผ๊ณ ์๊ฐํ์
let name -> ๋ฉ๋ชจ๋ฆฌ ํ ์นธ์ ์ธ ์ ์๋ ํฌ์ธํฐ๊ฐ ์๊ธฐ๊ฒ ๋๋ ๊ฒ
let name = 'ellie'; //๋ฉ๋ชจ๋ฆฌ์ ellie๋ผ๋ ๊ฐ์ ์ ์ฅํ ์ ์๊ฒ ๋๋ ๊ฒ
name = 'hello'; //๋ค๋ฅธ ๊ฐ์ ๋ฃ์ด์ ์ ์ฅํ ์ ์๋ค
block scope
{
//์ด ๋ธ๋ก ๋ฐ์์๋ ๋ธ๋ก ์์ ๋ณ์์ ์ ๊ทผํ ์ ์๋ค
}
//๋ธ๋ก ๋ฐ์์ ์ ์ํด์ ์ฐ๋ ๋ณ์๋ global scope์ด๋ค, ์ด๋ ๊ณณ์์๋ ์ ๊ทผ ๊ฐ๋ฅ
//global value๋ ์ ํ๋ฆฌ์ผ์ด์
์์๋ถํฐ ๋๊น์ง ๊ณ์ ๋ฉ๋ชจ๋ฆฌ ์์ ํ์ฌ๋ผ ์๊ธฐ ๋๋ฌธ์ ์ต์ํ์ผ๋ก ์ฐ๋ ๊ฒ์ด ์ข๋ค
์๋ฐ์คํฌ๋ฆฝํธ์์ ๋ณ์๋ฅผ ์ ์ธํ ์ ์๋ ํค์๋๋ ๋จ ํ๋, let - mutable
๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์๋ ๋ณ์๋ฅผ ์ ์ธํ๊ณ ๋์ ๊ฐ์ ํ ๋นํ๋ ๊ฒ ์ ์์
var์ ์ฐ์ง ๋ง! - ์ฐ๋ฉด ์ ๋๋ ์ด์
constant - r(read only)
ํ ๋ฒ ํ ๋นํ๋ฉด ๊ฐ์ด ์ ๋ ๋ฐ๋์ง ์๋๋ค
constant๋ ์ฝ๊ธฐ๋ง ๊ฐ๋ฅํ๊ณ ๋ค๋ฅธ ๊ฐ์ ์ฐ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค
favor immutable data type always for a few resons:
ํฌ์ธํฐ๊ฐ ์ ๊ธฐ๋ ๊ฒ
immutable data type๊ณผ mutable data type
immutable data type: primitive type, frozen object(object.freeze())
-> 'ellie'๋ผ๋ ์คํธ๋ง ์์ฒด๋ฅผ ๋ค๋ฅธ ์คํธ๋ง์ผ๋ก ๋ณ๊ฒฝ ๊ฐ๋ฅ, ํ์ง๋ง ์คํธ๋ง ๋ฐ์ดํฐ ์์ฒด๋ฅผ 'ellee'์์ผ๋ก ๋ณ๊ฒฝ์ ๋ถ๊ฐ๋ฅํจ
mutable data type: all objects by default are mutable in JS
-> object, array๋ mutable data type
variable types
primitive type (๋ ์ด์ ์์ ๋จ์๋ก ๋๋ ์ง ์ ์๋ ํ ๊ฐ์ง ํ์
, single item, number, string, boolean, null, undefiend, symbol)
-> ๊ฐ value ์์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ค
objective type (single item๋ค์ ๋ฌถ์ด์ ํ ๋ฐ์ค๋ก ๊ด๋ฆฌํ ์ ์๊ฒ ํด์ฃผ๋ ๊ฒ, box container, function, first-class function)
-> object๋ฅผ ๊ฐ๋ฆฌํค๋ reference๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ค
first-class function์ด๋ : function๋ ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์ ์ฒ๋ผ ๋ณ์์ ํ ๋น์ด ๊ฐ๋ฅํ ๊ฒ, ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํจ์์ parameter๋งค๊ฐ์ธ์๋ก์จ ์ ๋ฌ๋ ์ ์์, ํจ์์์ function์ returnํ ์๋ ์์
c์ธ์ด์ ๋ฐ์ดํฐ ํ์ ๊ณผ ๋น๊ตํด๋ณด์
c์ธ์ด๋ ๋ก์ฐ ๋ ๋ฒจ์ ์ธ์ด๋ก ๊ฐ๋ฐ์๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ํ ์ ์๋ ์ธ๋งค๋์ง๋ ์ธ์ด
-> short, int, long, float, double
์๋ฐ์๋ byte, short, long, int, float, double ๋ฑ์ number data type์ด ์์
์๋ฐ์คํฌ๋ฆฝํธ์์๋ number ์ด๋ผ๊ณ data type์ ์ ์ธํ์ง ์์๋ type์ด dynamicํ๊ฒ ๊ฒฐ์ ๋๋ค
integer(์ ์)์ decimal number(์์) ๋ชจ๋ ์๊ด์์ด number type์ผ๋ก ํ ๋น๋๋ค
ํน์ํ ์๋ฐ์คํฌ๋ฆฝํธ number ๊ฐ(special numeric values)
const infinity = 1 / 0; // Infinity
const negativeInfinity = -1 / 0; // -Infinity
const nAn = 'not a number' / 2; // NaN
//validํ ๊ฐ์ธ์ง ํ์ธํ๊ณ ์ฐ์ฐํ๋๋ก ํ์
bigInt
const bigInt = 1232343423n;
string
const helloBob = `hi ${brendon}`; //template literals(string)
boolean
false: 0, null, undefined, NaN, ''
true: any other value
null ๊ณผ undefined
null์ empty value ๋ผ๊ณ ์ง์ ํ๋ ๊ฒ
undefined๋ ์ ์ธ๋์ง๋ง ๊ฐ์ด ์ง์ ๋ผ์ง ์์ ๊ฒ (let x; or let x=undefined;)
symbol
๋งต์ด๋ ๋ค๋ฅธ ์๋ฃ ๊ตฌ์กฐ์์ ๊ณ ์ ํ ์๋ณ์๊ฐ ํ์ํ๊ฑฐ๋ ๋์ ๋ค๋ฐ์ ์ผ๋ก ์ผ์ด๋ ์ ์๋ ์ฝ๋์์ ์ฐ์ ์์๋ฅผ ์ฃผ๊ณ ์ถ์ ๋ ๊ณ ์ ํ ์๋ณ์๊ฐ ํ์ํ ๋ ์ฐ์ด๋ ๊ฒ
create unique identifiers for objects
๋์ผํ string์ ์์ฑํ์ด๋ ๊ณ ์ ํ๊ฒ ์ฃผ์ด์ง
const symbol1 = Symbol('id');
const symbol2 = Symbol('id');
console.log(symbol1 === symbol2); //false
cos
dynamic typing : dynamically typed language
c๋ jave์ธ์ด๋ statically typed language๋ผ๊ณ ํ๋ค
-> ๋ณ์๋ฅผ ์ ์ธํ ๋ ์ด๋ค ํ์
์ธ์ง ๊ฒฐ์ ํด์ ํ์
๋ ๊ฐ์ด ์ ์ธํ๋ค
javascript -> ์ ์ธํ ๋ ํ์
์ ์ ์ธํ๋ ๊ฒ์ด ์๋๋ผ runtime, ํ๋ก๊ทธ๋จ์ด ๋์ํ ๋ ํ ๋น๋ ๊ฐ์ ๋ฐ๋ผ์ ํ์
์ด ๋ณ๊ฒฝ๋ ์ ์๋ค
-> ๊ท๋ชจ๊ฐ ํฐ ํ๋ก๊ทธ๋จ ์งค ๋๋ ๋ฌธ์ ๊ฐ ๋ ์ ์์
let text = 'hello';
console.log(text.charAt(0)); //h //์ธ๋ฑ์ค์ ์์นํ๋ ์ ๋์ฝ๋ ๋จ์ผ๋ฌธ์ ๋ฐํ
console.log(`${text}, ${typeOf text}`); // hello, string //value, type ๋ฐํ
text=1;
console.log(`${text}, ${typeOf text}`); // 1, number
text = '7' + 5 //
console.log(`${text}, ${typeOf text}`); // 75, string
text = '8' / '2' ;
console.log(`${text}, ${typeOf text}`); // 4, number
console.log(text.charAt(0)); //error
object
๋ฌผ๊ฑด๊ณผ ๋ฌผ์ฒด๋ฅผ ๋ํํ ์ ์๋ ๋ฐ์ค ํํ
const ellie = {name: 'ellie', age: 20};
ellie.age=21;
ellie๋ผ๋ ์ค๋ธ์ ํธ ์์ name ๊ณผ age๋ผ๋ ๋ณ์๊ฐ ์กด์ฌํ๊ณ ๊ฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ด ํ ๋น๋จ
String concatenation (๋ฌธ์์ด ๊ฒฐํฉ)
console.log('my'+' cat'); //my cat
console.log('1'+2); //12
console.log(`string literals: 1+2 = ${1+2}`); //string literals: 1+2 = 3
console.log('ellie\'s \n \t book'); //ํน์ ๋ฌธ์์ด \n์ค๋ฐ๊ฟ \tํญ
Numeric operators
Increment and decrement operators
let counter = 2;
const preIncrement = ++counter;
//counter = counter + 1;
//preIncrement = counter;
console.log(`${preIncrement}, ${counter}); //3,3
const postIncrement = counter++;
//postIncrement = counter;
//counter = counter + 1;
console.log(`${preIncrement}, ${counter}); //3,4
-> preDecrement๋ ๊ฐ์ ์๋ฆฌ
Assignment operators (ํ ๋นํ๋ ์คํผ๋ ์ดํฐ)
x+=y; //x=x+y;
Comparison operators (๋น๊ตํ๋ ์คํผ๋ ์ดํฐ)
<=, >=, <, >
Logical operator
|| (or) -> finds the first truthy value, true ๋ค์ ๊ฐ์ด ๋์ค์ง ์์
๋ฐ๋ผ์ simpleํ value๋ ์์ ๋๋ ๊ฒ์ด ์ข๋ค
&& (and) -> finds the first falsy value, false ๋ค์ ๊ฐ์ด ๋์ค์ง ์์
๋ฐ๋ผ์ heavyํ operation์ผ ์๋ก ์ ์ผ ๋ค์์ ์ฒดํฌํ๋ค
๊ฐํธํ๊ฒ null์ฒดํฌ๋ฅผ ํ ๋๋ ์ฐ์ธ๋ค
often used to compress long if-statement
nullableObject && nullableObject.something (nullObject๊ฐ null์ด ์๋ ๋๋ง something์ด๋ผ๋ value๋ฅผ ๋ฐ์์ฌ ์ ์๋๋ก ํ๋ค)
if (nullableObject !== null) { nullableObject.something; }
! (not)
Equality operator
const stringFive = '5';
const numberFive = 5;
// == loose equality, with type conversion
console.log(stringFive==numberFive); //true
console.log(stringFive!=numberFive); //false
// === strict equality, no type conversion
console.log(stringFive===numberFive); //false
console.log(stringFive!==numberFive); //true
//object equality by reference
const ellie1 = {name: 'ellie};
const ellie2 = {name: 'ellie};
const ellie3 = ellie1;
console.log(ellie1 == ellie2); //false, referene๊ฐ ๋ค๋ฅด๋ค
console.log(ellie1 === ellie2); //false, refernce ๊ฐ์ด ๋ค๋ฅด๋ค
console.log(ellie1 === ellie3); //true, ๊ฐ์ referene
//equality puzzle
console.log(0==false); //t
console.log(0===false); //f
console.log(''==false); //t
console.log(''===false); //f
console.log(null==undefined); //f๋ผ๊ณ ์๊ฐํ์ง๋ง t
console.log(null===undefined); //f
Conditional operator : if
if, else if, else
Ternary operator : ?
๊ฐ๋จํ ๋๋ง ์ฐ๊ธฐ, nestingํ ๋๋ if๋ switch ์ฐ๊ธฐ
condition ? value1 : value2; //value1์ true์ผ ๋, value2๋ false์ผ ๋
console.log(name==='ellie'? 'yes':'no');
Switch statement
multiple if checks
enum-like value checks
multiple type checks in TS
break; ์ฐ์ง ์์ผ๋ฉด ๋ค์ ๊ฒ ๋ค ๋์ด
const browser = 'IE';
switch (browser) {
case 'IE':
console.log('go away');
break;
case 'Chrome':
case 'Firefox':
console.log('love you');
break;
default:
console.log('same all');
break;
}
While loop & do while loop
๋ฐ๋ณต๋ฌธ, statement๊ฐ false๊ฐ ๋์ค๊ธฐ ์ ๊น์ง ๋ฌดํ๋๋ก ํ๋ค
while loop, while the condition is truthy, body code is executed
do while loop, body code is executed first, then check the condition.
let i = 3;
while (i>0) {
console.log(`${i}`);
i--;
} //3 //2 //1
do {
console.log(`${i}`);
i--;
} while (i>0); //0
For loop
for(begin; condition; step)
for (i=3; i>0; i--) {
console.log(`${i}`);
}
// incline variable declaration, for loop ์์์ ์ง์ญ ๋ณ์ ์ ์ธ ๊ฐ๋ฅ
for (let i=3; i>0; i--) {
console.log(`${i}`);
}
Nested loop
-> ๋๋๋ก์ด๋ฉด ํผํ๋ ๊ฒ ์ข๋ค
loop๋ฅผ ๋๋ด๋ keyword: break์ continue
break: ๋ฃจํ๋ฅผ ์์ ํ ๋๋
continue: ์ง๊ธ ๊ฒ๋ง ์คํตํ๊ณ ๋ค์ ์คํ
์ผ๋ก ๋์ด๊ฐ๋ค
for (let i=0; i<=10; i++) {
if (i%2===1) {
continue;
} else {
console.log(i);
}
}
for (let i=0; i<=10; i++) {
if (i===9) { //i > 8
break;
} else {
console.log(i);
}
};