• ์ฝ”์–ด์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ - ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๊ธฐ๋ณธ

    2022. 1. 2.

    by. ๋‚˜๋‚˜ (nykim)

    320x100
    ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ ๊ธฐ๋ณธ
    https://ko.javascript.info/first-steps

     

     

    ์—„๊ฒฉ ๋ชจ๋“œ

    • ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ๋Š” ๊ธฐ์กด ๊ธฐ๋Šฅ์„ ๋ณ€๊ฒฝํ•˜์ง€ ์•Š๊ณ  ์ถ”๊ฐ€๋งŒ ํ•˜๋Š” ์‹์œผ๋กœ ํ˜ธํ™˜์„ฑ ๋ฌธ์ œ๋ฅผ ํšŒํ”ผํ–ˆ์Šต๋‹ˆ๋‹ค.
    • ๊ทธ๋Ÿฐ๋ฐ ES5(2009)์—์„œ ๊ธฐ์กด ๊ธฐ๋Šฅ ์ผ๋ถ€๋ฅผ ๋ณ€๊ฒฝํ•˜๊ฒŒ ๋˜์—ˆ๋Š”๋ฐ์š”, ํ˜น์‹œ๋‚˜ ์‹ถ์€ ๋ฌธ์ œ๋ฅผ ํ”ผํ•˜๊ธฐ ์œ„ํ•ด ์ด ์ƒˆ๋กœ์šด ๊ธฐ๋Šฅ๋“ค์€ ๊ธฐ๋ณธ์ ์œผ๋กœ ๋น„ํ™œ์„ฑํ™” ์ƒํƒœ์ž…๋‹ˆ๋‹ค.
    • ์ƒˆ๋กญ๊ฒŒ ์ถ”๊ฐ€๋œ ๊ธฐ๋Šฅ์„ ์“ฐ๊ณ  ์‹ถ๋‹ค๋ฉด, use strict๋ผ๊ณ  ์™ธ์ณ์ฃผ์„ธ์š”. ๊ทธ๋Ÿผ '์—„๊ฒฉ ๋ชจ๋“œ'๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
    • ์ด ์ฃผ๋ฌธ์€ ์ฃผ๋กœ ์Šคํฌ๋ฆฝํŠธ ์ตœ์ƒ๋‹จ์—์„œ ์™ธ์นฉ๋‹ˆ๋‹ค. ๊ทธ๋ž˜์•ผ ์Šคํฌ๋ฆฝํŠธ ์ „์ฒด๊ฐ€ ์—„๊ฒฉ ๋ชจ๋“œ๋กœ ์ ์šฉ๋˜๋‹ˆ๊นŒ์š”.
    • ๋งŒ์•ฝ ํด๋ž˜์Šค์™€ ๋ชจ๋“ˆ์„ ์‚ฌ์šฉํ•ด ์Šคํฌ๋ฆฝํŠธ๋ฅผ ์ž‘์„ฑํ–ˆ๋‹ค๋ฉด ์ด๋ฏธ ์—„๊ฒฉ๋ชจ๋“œ๊ฐ€ ์ ์šฉ๋œ ๊ฑฐ๋‚˜ ๋‹ค๋ฆ„ ์—†์–ด์„œ ๊ตณ์ด ์ ์ง€ ์•Š์•„๋„ ๋ฉ๋‹ˆ๋‹ค.

     

     

    ๊ธฐ๋ณธ ์—ฐ์‚ฐ์ž์™€ ์ˆ˜ํ•™

    • %(๋‚˜๋จธ์ง€ ์—ฐ์‚ฐ์ž): x % b ๋Š” x๋ฅผ b๋กœ ๋‚˜๋ˆ„๊ณ  ๊ทธ ๋‚˜๋จธ์ง€๋ฅผ ์ •์ˆ˜๋กœ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
    • **(๊ฑฐ๋“ญ์ œ๊ณฑ ์—ฐ์‚ฐ์ž): x ** b๋Š” x๋ฅผ b๋ฒˆ ๊ณฑํ•œ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. (2**3 = 8) ๋‹จ, ์ด๋Š” ES7์—์„œ ์ถ”๊ฐ€๋œ ์ŠคํŽ™์ž…๋‹ˆ๋‹ค.
    • ์ดํ•ญ ์—ฐ์‚ฐ์ž(+)์™€ ํ•จ๊ป˜ ์“ฐ์ธ ํ”ผ์—ฐ์‚ฐ์ž ์ค‘ ๋ฌธ์ž์—ด์ด ์žˆ์œผ๋ฉด ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค.
      alert( 2+2+'1' ) //๊ฒฐ๊ณผ: '41'
    • ๋ง์…ˆ ์—ฐ์‚ฐ์ž(+)๊ฐ€ ์ˆซ์ž๊ฐ€ ์•„๋‹Œ ๊ฒฝ์šฐ ์ˆซ์žํ˜•์œผ๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค.
      alert( +"" ); //๊ฒฐ๊ณผ: 0
      let a=5; let b=1; alert( +a + +b ); //๊ฒฐ๊ณผ: 6
    • ++/--๋Š” ํ”ผ์—ฐ์‚ฐ์ž์˜ ์•ž๋’ค ์–ด๋””์—๋„ ์œ„์น˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ „์œ„ํ˜•์€ ์ฆ๊ฐ€/๊ฐ์†Œ ํ›„ ์ƒˆ๋กœ์šด ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜๊ณ , ํ›„์œ„ํ˜•์€ ์ฆ๊ฐ€/๊ฐ์†Œ ์ „ ๊ธฐ์กด๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
      let counter = 1; let a = ++counter; alert(a); //๊ฒฐ๊ณผ: 2
      let counter = 1; let a = counter++; alert(a); //๊ฒฐ๊ณผ: 1
    • ๋”ฐ๋ผ์„œ ๊ฐ’์„ ์ฆ๊ฐ€์‹œํ‚ค๊ณ  ์ฆ๊ฐ€ํ•œ ๊ฐ’์„ ๋ฐ”๋กœ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ์ „์œ„ํ˜•์„, ๊ฐ’์„ ์ฆ๊ฐ€์‹œํ‚ค๋˜ ๊ธฐ์กด ๊ฐ’์„ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ํ›„์œ„ํ˜•์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

     

    ๋น„๊ต ์—ฐ์‚ฐ์ž

    • ๋ฌธ์ž์—ด ๋น„๊ต: JS๋Š” ๋Œ€์†Œ๋ฌธ์ž๋ฅผ ๋”ฐ์ ธ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค. "A"์™€ "a" ์ค‘ "a"๊ฐ€ ๋” ํฌ๋‹ค๊ณ  ํŒ๋‹จํ•˜๋ฉฐ, ์ด๋Š” JS ๋‚ด๋ถ€์—์„œ ์‚ฌ์šฉ๋˜๋Š” ์ธ์ฝ”๋”ฉ ํ‘œ์ธ ์œ ๋‹ˆ์ฝ”๋“œ์—์„œ ์†Œ๋ฌธ์ž๊ฐ€ ๋” ํฐ ์ธ๋ฑ์Šค๋ฅผ ๊ฐ–๊ณ  ์žˆ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.
    • ๋น„๊ตํ•˜๋ ค๋Š” ๊ฐ’์˜ ์ž๋ฃŒํ˜•์ด ๋‹ค๋ฅด๋ฉด ๊ด€๋Œ€ํ•˜์‹  JS๋Š” ์ด๋“ค์„ ์ˆซ์žํ˜•์œผ๋กœ ๋ฐ”๊ฟ”์ค๋‹ˆ๋‹ค.
      alert( '2' > 1 ); //๊ฒฐ๊ณผ: true
    • null๊ณผ undefined๋Š” ===๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด false, ==๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด true๊ฐ€ ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.
      null === undefined //๊ฒฐ๊ณผ: false
      null == undefined //๊ฒฐ๊ณผ: true
    • ๋งŒ์•ฝ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋‚˜ ๊ธฐํƒ€ ๋น„๊ต ์—ฐ์‚ฐ์ž(<, > ๋“ฑ)์„ ์‚ฌ์šฉํ•  ๊ฒฝ์šฐ ์ˆซ์žํ˜•์œผ๋กœ ๋ณ€ํ™˜๋˜๋Š”๋ฐ, null์€ 0, undefined๋Š” NaN์ด ๋ฉ๋‹ˆ๋‹ค. ๋‹จ, ๋™๋“ฑ ์—ฐ์‚ฐ์ž(==)๋Š” ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ null ๋˜๋Š” undefined์ผ ๋•Œ ํ˜• ๋ณ€ํ™˜์„ ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
      null == 0 //๊ฒฐ๊ณผ: false

     

     

    ๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž

    1. OR (||)
      • ์ธ์ˆ˜ ์ค‘ ํ•˜๋‚˜๋ผ๋„ true๋ผ๋ฉด true๋ฅผ ๋ฐ˜ํ™˜. ๊ทธ๋ ‡์ง€ ์•Š๋‹ค๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        if (1 || 0) {}; //๊ฒฐ๊ณผ: true
      • OR ์—ฐ์‚ฐ์ž๊ฐ€ ์—ฌ๋Ÿฌ ๊ฐœ๋ผ๋ฉด ์™ผ์ชฝ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ˆœ์„œ๋Œ€๋กœ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ, ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋ถˆ๋ฆฐํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š”๋ฐ ๊ทธ ๊ฐ’์ด true๋ฉด ์—ฐ์‚ฐ์„ ๋ฉˆ์ถ”๊ณ  ๋ณ€ํ™˜ ์ „ ์›๋ž˜ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๋ชจ๋‘ ํ‰๊ฐ€ํ•œ ํ›„์—๋„ false๋ผ๋ฉด ๋งˆ์ง€๋ง‰ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        alert(null || 0 || 1); //๊ฒฐ๊ณผ: 1 (1์€ truthy์ž„)
        alert(undefined || null || 0); //๊ฒฐ๊ณผ: 0 (๋ชจ๋‘ falsy์ž„)
    2. AND (&&)
      • ํ”ผ์—ฐ์‚ฐ์ž ๋ชจ๋‘๊ฐ€ ์ฐธ์ผ ๋•Œ true๋ฅผ ๋ฐ˜ํ™˜. ๊ทธ๋ ‡์ง€ ์•Š๋‹ค๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        if (1 && 0) {}; //๊ฒฐ๊ณผ: false
      • AND ์—ฐ์‚ฐ์ž๊ฐ€ ์—ฌ๋Ÿฌ ๊ฐœ๋ผ๋ฉด ์™ผ์ชฝ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ˆœ์„œ๋Œ€๋กœ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ณผ์ •์€ OR ์—ฐ์‚ฐ์ž์™€ ์œ ์‚ฌํ•˜๋ฉฐ, ๋ณ€ํ™˜๋œ ๊ฐ’์ด false๋ฉด ์—ฐ์‚ฐ์„ ๋ฉˆ์ถ”๊ณ  ๋ณ€ํ™˜ ์ „ ์›๋ž˜ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        alert( 1 && null && 5 ); //๊ฒฐ๊ณผ: null
        alert( 1 && 2 && 3 ); //๊ฒฐ๊ณผ: 3
    3. NOT (!)
      • ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋ถˆ๋ฆฐํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•œ ๋’ค ๊ทธ ๊ฐ’์˜ ์—ญ์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        alert ( !true ); //๊ฒฐ๊ณผ: flase
      • NOT์„ ์—ฐ๋‹ฌ์•„ ๋‘ ๊ฐœ ์‚ฌ์šฉ(!!)ํ•˜๋ฉด ๊ฐ’์„ ๋ถˆ๋ฆฐํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Š” ๋‚ด์žฅ ํ•จ์ˆ˜์ธ Boolean์„ ์‚ฌ์šฉํ•œ ๊ฒƒ๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.
        alert ( !!"non-empty string" ); //๊ฒฐ๊ณผ: true
        alert ( Boolean(null) ); //๊ฒฐ๊ณผ: false

     

    ์˜ˆ์ œ

    [1] ` alert( alert(1) || 2 || alert(3) ); ` ์˜ ๊ฒฐ๊ณผ๋Š”?

    • ๋‹ต: ์–ผ๋Ÿฟ ์ฐฝ์—” 1, 2๊ฐ€ ์ฐจ๋ก€๋Œ€๋กœ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    • ๋จผ์ € alert(1)์„ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ ์ฒซ ๋ฒˆ์งธ ์–ผ๋Ÿฟ ์ฐฝ์— 1์ด ์ถœ๋ ฅ๋˜์ฃ .
    • alert() ๋ฉ”์„œ๋“œ๋Š” undefined๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” falsy ์ด๋ฏ€๋กœ OR ์—ฐ์‚ฐ์ž๋Š” ๋‹ค์Œ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
    • ๋‹ค์Œ์œผ๋กœ ํ‰๊ฐ€๋˜๋Š” 2๋Š” truthy์ด๋ฏ€๋กœ ์‹คํ–‰์ด ๋ฉˆ์ถ”๊ณ  2๊ฐ€ ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค. ๋ฐ˜ํ™˜๋œ 2๋Š” ๋ฐ”๊นฅ์ชฝ alert() ๋ฉ”์„œ๋“œ์˜ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ๋˜์–ด ์–ผ๋Ÿฟ ์ฐฝ์— 2๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    • ํ‰๊ฐ€๊ฐ€ alert(3)๊นŒ์ง€ ์ง„ํ–‰๋˜์ง€ ์•Š์œผ๋ฏ€๋กœ 3์€ ์ถœ๋ ฅ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

     

    [2] `alert( alert(1) && alert(2) ); `์˜ ๊ฒฐ๊ณผ๋Š”?

    • ๋‹ต: ์–ผ๋Ÿฟ ์ฐฝ์—” 1, undefined๊ฐ€ ์ฐจ๋ก€๋Œ€๋กœ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    • ๋จผ์ € alert(1)์„ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ ์ฒซ ๋ฒˆ์งธ ์–ผ๋Ÿฟ ์ฐฝ์— 1์ด ์ถœ๋ ฅ๋˜์ฃ .
    • alert() ๋ฉ”์„œ๋“œ๋Š” undefined๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” falsy ์ด๋ฏ€๋กœ AND ์—ฐ์‚ฐ์ž๋Š” ํ‰๊ฐ€๋ฅผ ๋ฉˆ์ถฅ๋‹ˆ๋‹ค.
    • ๋ฐ˜ํ™˜๋œ undefined๋Š” ๋ฐ”๊นฅ์ชฝ alert() ๋ฉ”์„œ๋“œ์˜ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ๋˜์–ด ์–ผ๋Ÿฟ ์ฐฝ์— undefined๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.

     

    [3] `alert( null || 2 && 3 || 4 );`์˜ ๊ฒฐ๊ณผ๋Š”? โœ”๏ธ

    • ๋‹ต: ์–ผ๋Ÿฟ ์ฐฝ์—” 3์ด ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    • &&์˜ ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋†’์œผ๋ฏ€๋กœ ์šฐ์„  2 && 3์ด ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ๋‘˜ ๋‹ค truthy์ด๋ฏ€๋กœ 3์ด ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.
    • ๋จผ์ € null์„ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” falsy์ด๋ฏ€๋กœ OR์—ฐ์‚ฐ์ž๋Š” ๋‹ค์Œ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
    • ์ดํ›„ 3์„ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” truthy์ด๋ฏ€๋กœ OR์—ฐ์‚ฐ์ž๋Š” ํ‰๊ฐ€๋ฅผ ๋ฉˆ์ถฅ๋‹ˆ๋‹ค.
    • ๋ฐ˜ํ™˜๋œ 3์€ ๋ฐ”๊นฅ์ชฝ alert() ๋ฉ”์„œ๋“œ์˜ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ๋˜์–ด ์–ผ๋Ÿฟ ์ฐฝ์— 3์ด ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.

     

     

    null ๋ณ‘ํ•ฉ ์—ฐ์‚ฐ์ž '??'

    • ES2020(ES11)์— ์ถ”๊ฐ€๋œ ์ŠคํŽ™์ž…๋‹ˆ๋‹ค.
      ??๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์—ฌ๋Ÿฌ ํ”ผ์—ฐ์‚ฐ์ž ์ค‘ ๊ทธ ๊ฐ’์ด 'ํ™•์ •๋œ' ๋ณ€์ˆ˜๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. (=๊ฐ’์ด null ๋˜๋Š” undefined๊ฐ€ ์•„๋‹Œ ๋ณ€์ˆ˜)
      ex) a ?? b ํ‰๊ฐ€ ์‹œ, a๊ฐ€ null ๋˜๋Š” undefined๊ฐ€ ์•„๋‹ˆ๋ผ๋ฉด a. ๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ๋Š” b
    • ๋”ฐ๋ผ์„œ ์•„๋ž˜ ๋‘ ์ฝ”๋“œ๋Š” ๋™์ผํ•œ ๊ธฐ๋Šฅ์„ ํ•ฉ๋‹ˆ๋‹ค.
      [1] let name = ( realName !== null && realName !== undefined ) ? realName : nickName;
      [2] let name = realName ?? nickName ์œผ๋กœ ์ค„์—ฌ์„œ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • ์ด๋Š” || ์—ฐ์‚ฐ์ž์™€ ์œ ์‚ฌํ•˜์ง€๋งŒ ์ฐจ์ด์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค. ||๋Š” ์ฒซ ๋ฒˆ์งธ truthy์˜ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜๊ณ , ??๋Š” ์ฒซ ๋ฒˆ์งธ truthy์˜ '์ •์˜๋œ' ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
      let height = 0;
      let myHeight = height || 180; //๊ฒฐ๊ณผ: 180
      let yourHeight = height ?? 180; //๊ฒฐ๊ณผ: 0
      • height || 180์€ 0์„ falsy ๊ฐ’์œผ๋กœ ํŒ๋‹จํ•˜์—ฌ ์ด๋ฅผ null์ด๋‚˜ undefined์™€ ๋™์ผํ•˜๊ฒŒ ์ทจ๊ธ‰ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ฒซ ๋ฒˆ์งธ truthy๋Š” 180์ด ๋ฉ๋‹ˆ๋‹ค.
      • ํ•˜์ง€๋งŒ height ?? 180์€ height๊ฐ€ ์ •ํ™•ํ•˜๊ฒŒ null์ด๋‚˜ undefined์ผ ๋•Œ๋งŒ์„ falsy๋ผ๊ณ  ํŒ๋‹จํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ฒซ ๋ฒˆ์งธ truthy๋Š” height์ด๋ฉฐ ์—ฌ๊ธฐ์— ์ •์˜๋œ 0์ด ๋ฉ๋‹ˆ๋‹ค.
      •  ์ด๋Ÿฌํ•œ ํŠน์ง• ๋•Œ๋ฌธ์— 0์ด ํ• ๋‹น๋  ์ˆ˜ ์žˆ๋Š” ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ๋Š” ??๊ฐ€ ์ ํ•ฉํ•ฉ๋‹ˆ๋‹ค.
    • ํ˜„์žฌ JS์—์„œ๋Š” ์•ˆ์ •์„ฑ ๊ด€๋ จ ์ด์Šˆ ๋•Œ๋ฌธ์— ??๋ฅผ ||๋‚˜ &&์™€ ํ•จ๊ป˜ ์‚ฌ์šฉํ•˜์ง€ ๋ชปํ•˜๋„๋ก ์ œ์•ฝ์ด ๊ฑธ๋ ค ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹จ, ๊ด„ํ˜ธ๋กœ ๋ฌถ์œผ๋ฉด ํ•จ๊ป˜ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

     

     

     

    ๋ฐ˜๋ณต๋ฌธ

    1. while
      • ์กฐ๊ฑด์ด truhty์ธ ๋™์•ˆ ๋ฐ˜๋ณต๋ฌธ ๋ณธ๋ฌธ ๋‚ด์šฉ์„ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค.
      • ๋ฐ˜๋ณต๋ฌธ ๋ณธ๋ฌธ์ด ํ•œ ๋ฒˆ ์‹คํ–‰๋˜๋Š” ๊ฒƒ์„ iteration์ด๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค.
        let i = 0;
        while (i < 3) {
          alert( i ); // 0, 1, 2๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
          i++;
        }
       
    2. do..while
      • condition์ด ๋ณธ๋ฌธ ๋‹ค์Œ์— ๋‚˜์˜ค๋Š” ํ˜•ํƒœ๋กœ, ๋ณธ๋ฌธ์ด '์ตœ์†Œํ•œ ํ•œ ๋ฒˆ ์ด์ƒ ์‹คํ–‰๋˜์–ด์•ผ'ํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.
        let i = 0;
        do {
          alert( i ); // 0, 1, 2๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
          i++;
        } while (i < 3);โ€‹
       
    3. for
      • begin; condition; step;์œผ๋กœ ์ด๋ค„์ง„ ๋ฐ˜๋ณต๋ฌธ์ž…๋‹ˆ๋‹ค.
        for (begin; condition; step) {
          // ... ๋ฐ˜๋ณต๋ฌธ ๋ณธ๋ฌธ ...
        }
      • ์„ธ๋ฏธ์ฝœ๋ก  `;` ๋งŒ ๋‚จ๊ธฐ๊ณ  ๋ถˆํ•„์š”ํ•œ ๋‚ด์šฉ์„ ์ƒ๋žตํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
        let i = 0;
        for (; i < 3; i++) {
          alert( i );
        }
       
    4. ๋ฐ˜๋ณต๋ฌธ ๋น ์ ธ๋‚˜์˜ค๊ธฐ
      • `break`๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฐ˜๋ณต๋ฌธ์„ ์ข…๋ฃŒํ•ฉ๋‹ˆ๋‹ค.
      • ๋ณธ๋ฌธ ๊ฐ€์šด๋ฐ๋‚˜ ๋ณธ๋ฌธ ์—ฌ๋Ÿฌ ๊ณณ์—์„œ ์กฐ๊ฑด์„ ํ™•์ธํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ, '๋ฌดํ•œ ๋ฐ˜๋ณต๋ฌธ + break' ์กฐํ•ฉ์„ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹์Šต๋‹ˆ๋‹ค.
      • ์—ฌ๋Ÿฌ ๊ฐœ์˜ ์ค‘์ฒฉ ๋ฐ˜๋ณต๋ฌธ์„ ๋น ์ ธ๋‚˜์™€์•ผ ํ•œ๋‹ค๋ฉด, ๋‹จ์ˆœํžˆ break ์„ ์–ธ๋งŒ์œผ๋ก  ๋ถ€์กฑํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿด ๋•Œ๋Š” `{๋ผ๋ฒจ์ด๋ฆ„}:`์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋ฐ˜๋ณต๋ฌธ ์•ž์— ์‹๋ณ„์ž๋ฅผ ๋ถ™์ด๊ณ , ํ•ด๋‹น ๋ฐ˜๋ณต๋ฌธ์„ ์ข…๋ฃŒ์‹œํ‚ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
        outer: for (let i = 0; i < 3; i++) {
          for (let j = 0; j < 3; j++) {
            let input = prompt(`(${i},${j})์˜ ๊ฐ’`, '');
            if (!input) break outer; 
            // ์‚ฌ์šฉ์ž๊ฐ€ ์•„๋ฌด๊ฒƒ๋„ ์ž…๋ ฅํ•˜์ง€ ์•Š๊ฑฐ๋‚˜ Cancel ๋ฒ„ํŠผ์„ ๋ˆ„๋ฅด๋ฉด ๋‘ ๋ฐ˜๋ณต๋ฌธ ๋ชจ๋‘๋ฅผ ๋น ์ ธ๋‚˜์˜ต๋‹ˆ๋‹ค.
          }
        }
        alert('์™„๋ฃŒ!');โ€‹
       
    5. ๋‹ค์Œ ๋ฐ˜๋ณต์œผ๋กœ ๋„˜์–ด๊ฐ€๊ธฐ
      • `continue`๋Š” ์ „์ฒด ๋ฐ˜๋ณต๋ฌธ์„ ๋ฉˆ์ถ”์ง€ ์•Š๊ณ , ํ˜„์žฌ ์‹คํ–‰ ์ค‘์ธ ์ดํ„ฐ๋ ˆ์ด์…˜๋งŒ ์ข…๋ฃŒ์‹œํ‚จ ๋’ค ๋‹ค์Œ ์ดํ„ฐ๋ ˆ์ด์…˜์œผ๋กœ ๋„˜์–ด๊ฐ€๋„๋ก ํ•ฉ๋‹ˆ๋‹ค.
      • ์˜ˆ๋ฅผ ๋“ค์–ด ํ™€์ˆ˜๋งŒ ์ถœ๋ ฅ์‹œํ‚ค๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ,
        for (let i=0; i<10; i++) {
          if (i % 2) {
            alert(i);
          }
        }โ€‹

        ์œ„์™€ ๊ฐ™์ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, continue๋ฅผ ์“ธ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
        for (let i=0; i<10; i++) {
          if (i % 2 ==) continue;
        }โ€‹

     

    ์˜ˆ์ œ

    [1] ์•„๋ž˜ ์ฝ”๋“œ์˜ ์‹คํ–‰ ๊ฒฐ๊ณผ๋Š”?

    let i = 0;
    while (i++ < 5) alert( i );
    • ๋‹ต: ์–ผ๋Ÿฟ ์ฐฝ์— 1,2,3,4,5๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    • ++๊ฐ€ ๋’ค์— ๋‚˜์˜ค๋Š” ๊ฒฝ์šฐ๋Š” ๊ฐ’์„ ์ฆ๊ฐ€ํ•˜๋˜ ๊ธฐ์กด๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ๋น„๊ต๋Š” (0<5)๊ฐ€ ๋˜๋ฉฐ ์ด๋Š” ์ฐธ์ž…๋‹ˆ๋‹ค. ํ•œํŽธ, alert()๋Š” ์กฐ๊ฑด๋ฌธ๊ณผ ๋ณ„๊ฐœ์ด๋ฏ€๋กœ ์ด๋ฏธ ์ฆ๊ฐ€ํ•ด์„œ ๋„˜์–ด์˜จ i๋ฅผ ๋ฐ›๊ณ  1์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

     

    [2] ์•„๋ž˜ ๋‘ ์ฝ”๋“œ์˜ ์‹คํ–‰ ๊ฒฐ๊ณผ๋Š” ๋™์ผํ• ๊นŒ์š”?

    //1
    for (let i = 0; i < 5; i++) alert( i );
    
    //2
    for (let i = 0; i < 5; ++i) alert( i );
    • ๋‹ต: ๋™์ผํ•˜๊ฒŒ 0,1,2,3,4๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.
    • ์™œ๋ƒํ•˜๋ฉด i++๋‚˜ ++i๋Š” ์กฐ๊ฑด ํ™•์ธ๊ณผ ๋ณ„๊ฐœ์˜ ๊ตฌ๋ฌธ์ด๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. for๋ฌธ์€ ๊ทธ์ € ์ฆ๊ฐ€๋œ i๋ฅผ ์กฐ๊ฑด ํ™•์ธ์— ์‚ฌ์šฉํ•  ๋ฟ์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ฆ๊ฐ€ ์—ฐ์‚ฐ์ž๊ฐ€ ๋ฐ˜ํ™˜ํ•œ ๊ฐ’์€ ์–ด๋””์—๋„ ์“ฐ์ด์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

     

    [3] ์‚ฌ์šฉ์ž๊ฐ€ 100๋ณด๋‹ค ํฐ ์ˆซ์ž๋ฅผ ์ž…๋ ฅํ•  ๋•Œ๊นŒ์ง€ ํ”„๋กฌํ”„ํŠธ ์ฐฝ์„ ๋„์šฐ๊ณ , ์•„๋ฌด๊ฒƒ๋„ ์ž…๋ ฅํ•˜์ง€ ์•Š๊ฑฐ๋‚˜ ์ทจ์†Œํ•œ ๊ฒฝ์šฐ ํ”„๋กฌํ”„ํŠธ ์ฐฝ์„ ์ทจ์†Œํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด ๋ณด์„ธ์š”.

    • ๋‹ต:
      let num;
      do {
        num = prompt("100์„ ์ดˆ๊ณผํ•˜๋Š” ์ˆซ์ž๋ฅผ ์ž…๋ ฅํ•ด์ฃผ์„ธ์š”.", 0);
      } while (num <= 100 && numโ€‹
    • num์ด null์ธ ๊ฒฝ์šฐ num <= 100์€ true๊ฐ€ ๋˜๋ฏ€๋กœ ๋‘ ๋ฒˆ์งธ ์กฐ๊ฑด์ด ์—†์œผ๋ฉด ์ทจ์†Œ ๋ฒ„ํŠผ์„ ๋ˆŒ๋Ÿฌ๋„ ๋ฐ˜๋ณต๋ฌธ์ด ๊ณ„์†ํ•ด์„œ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์œ„ ๋‘ ์กฐ๊ฑด์„ ๋ชจ๋‘ ํ™•์ธํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

     

     

     

     

    ํ•จ์ˆ˜

    1. ๋งค๊ฐœ๋ณ€์ˆ˜
      • ๋งค๊ฐœ๋ณ€์ˆ˜์™€ ์ธ์ž๋Š” ๋‹ค๋ฆ…๋‹ˆ๋‹ค!
        • (1) ๋งค๊ฐœ๋ณ€์ˆ˜/ํŒŒ๋ผ๋ฏธํ„ฐ(parameter): ํ•จ์ˆ˜๋ฅผ ์‹คํ–‰ํ•˜๊ธฐ ์œ„ํ•ด ํ•„์š”ํ•˜๋‹ค๊ณ  ์ง€์ •ํ•˜๋Š” ๊ฐ’
          ๐Ÿ‘‰ ์ž…์žฅ์„ ์œ„ํ•ด ๋งˆ๋ จํ•ด๋‘๋Š” ์˜์ž
        • (2) ์ธ์ˆ˜/์ธ์ž(arguments): ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋„˜๊ธฐ๋Š” ๊ฐ’
          ๐Ÿ‘‰ ์‹ค์ œ๋กœ ์ž…์žฅํ•œ ์‚ฌ๋žŒ
      • ํ•จ์ˆ˜๋Š” ๋ณต์‚ฌ๋œ ๊ฐ’์„ ์‚ฌ์šฉํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์™ธ๋ถ€ ๋ณ€์ˆ˜์— ์˜ํ–ฅ์„ ์ฃผ์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ฆ‰, ํ•จ์ˆ˜์— ์ „๋‹ฌ๋œ ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ๋ณต์‚ฌ๋œ ํ›„ ํ•จ์ˆ˜์˜ ์ง€์—ญ๋ณ€์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
      • ํ•จ์ˆ˜๋Š” ์™ธ๋ถ€ ๋ณ€์ˆ˜์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, ๋ฐ”๊นฅ์—์„œ ํ•จ์ˆ˜ ๋‚ด๋ถ€์˜ ์ง€์—ญ๋ณ€์ˆ˜์—๋Š” ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
        let num = 22;
        add = (x, y) => { return x + y; } //(x,y)๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜
        add(num,2); //(num,2)๋Š” ์ธ์ˆ˜โ€‹
      • ๋งค๊ฐœ๋ณ€์ˆ˜์— ๊ฐ’์„ ์ „๋‹ฌํ•˜์ง€ ์•Š์œผ๋ฉด ๊ทธ ๊ฐ’์€ `undefined`๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
      • ํ•จ์ˆ˜๋ฅผ ์ •์˜ํ•  ๋•Œ ๋งค๊ฐœ ๋ณ€์ˆ˜ ์˜ค๋ฅธ์ชฝ์— `=`์„ ๋ถ™์—ฌ ๊ธฐ๋ณธ๊ฐ’์„ ์„ค์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
        someFunc = () => { return 'hello' };
        showMsg = (name, msg = someFunc()) => { alert(name+' says '+msg); };
        showMsg('nana'); //๊ฒฐ๊ณผ: 'nana says hello'โ€‹
      • ๋˜๋Š” ์„ ์–ธ๋ถ€ ๋Œ€์‹ , ํ•จ์ˆ˜ ์‹คํ–‰ ๋„์ค‘์— ๊ธฐ๋ณธ๊ฐ’์„ ์„ค์ •ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
        showMsg = (text) => {
          text = text || 'Hey!';
          ...
        }โ€‹
       
    2. ๋ฆฌํ„ด
      • ํ•จ์ˆ˜๋Š” ๋ฌด์กฐ๊ฑด ๋ญ”๊ฐ€๋ฅผ ๋Œ๋ ค์ค๋‹ˆ๋‹ค. (๋„ค! ํ•ญ์ƒ ๋ฌด์–ธ๊ฐ€๋ฅผ ์‹ธ์š”! ๐Ÿ’ฉ)
      • return๋ฌธ์ด ์—†๊ฑฐ๋‚˜ return ์ง€์‹œ์ž๋งŒ ์žˆ๋Š” ๊ฒฝ์šฐ๋ผ๋„ undefined๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
        (์ฆ‰, return; === return undefined;์ธ ๊ฑฐ์ฃ )
       
    3. ํ•จ์ˆ˜ ์ด๋ฆ„์ง“๊ธฐ
      • ํ•จ์ˆ˜ ์ด๋ฆ„์€ ๋Œ€๊ฐœ ๋™์‚ฌ๋กœ ์ง“์Šต๋‹ˆ๋‹ค. ํ•จ์ˆ˜ ์ด๋ฆ„๋งŒ ๋ณด๊ณ ๋„ ํ•จ์ˆ˜๊ฐ€ ์–ด๋–ค ๊ธฐ๋Šฅ์„ ํ•˜๋Š”์ง€ ์•Œ ์ˆ˜ ์žˆ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
        • get: ๊ฐ’ ๋ฐ˜ํ™˜
        • calc: ๊ณ„์‚ฐ
        • create: ์ƒ์„ฑ
        • check: ํ™•์ธ ํ›„ ๋ถˆ๋ฆฐ๊ฐ’ ๋ฐ˜ํ™˜
        • show: ๋ฌด์–ธ๊ฐ€๋ฅผ ํ‘œ์‹œํ•จ
      • ํ•จ์ˆ˜๋Š” ๋™์ž‘ ํ•˜๋‚˜๋งŒ ๋‹ด๋‹นํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, ์ด๋ฆ„์— ์–ธ๊ธ‰๋œ ๋™์ž‘๋งŒ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
        • ex) getAge() ํ•จ์ˆ˜๋Š” ๋‚˜์ด๋ฅผ ์–ป์–ด์˜ค๊ธฐ๋งŒ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. alert()๋กœ ์ถœ๋ ฅํ•ด์ฃผ๋Š” ๋™์ž‘์€ ๋‹ค๋ฅธ ํ•จ์ˆ˜๊ฐ€ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
        • ex) createForm() ํ•จ์ˆ˜๋Š” form ์ƒ์„ฑ ํ›„ ๋ฐ˜ํ™˜ํ•˜๊ธฐ๋งŒ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. form์„ ๋ฌธ์„œ์— ์ถœ๋ ฅํ•˜๋Š” ๋™์ž‘์€ ๋‹ค๋ฅธ ํ•จ์ˆ˜๊ฐ€ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
      • ํ•จ์ˆ˜๋Š” ์ฃผ์„์ด ์—†์–ด๋„ ๊ทธ ์กด์žฌ ์ž์ฒด๊ฐ€ ๋ฌด์Šจ ์—ญํ• ์„ ํ•˜๋Š”์ง€ ์„ค๋ช…ํ•  ์ˆ˜ ์žˆ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ฝ”๋“œ๋ฅผ ๋ถ„๋ฆฌํ•ด ์ž‘์„ฑํ•˜๋ฉด ๋” ๋‚˜์€ ์ฝ”๋“œ ๊ตฌ์กฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
       
    4. ํ•จ์ˆ˜ ํ‘œํ˜„์‹ vs. ํ•จ์ˆ˜ ์„ ์–ธ๋ฌธ
      • ํ•จ์ˆ˜ ์„ ์–ธ๋ฌธ์€ ๋…์ž์ ์ธ ๊ตฌ๋ฌธ ํ˜•ํƒœ๋กœ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.
        function sum(a, b) {
          return a + b;
        }โ€‹
      •  ํ•จ์ˆ˜ ํ‘œํ˜„์‹์€ ๊ตฌ๋ฌธ ๊ตฌ์„ฑ(syntax construct) ๋‚ด๋ถ€์— ์ƒ์„ฑ๋ฉ๋‹ˆ๋‹ค. ์ด๋•Œ ์‹ค์ œ ์‹คํ–‰ ํ๋ฆ„์ด ํ•ด๋‹น ํ•จ์ˆ˜์— ๋„๋‹ฌํ–ˆ์„ ๋•Œ ํ•จ์ˆ˜๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.
        let sum = function(a, b) {
          return a + b;
        };โ€‹
      • ๋”ฐ๋ผ์„œ ํ•จ์ˆ˜ ์„ ์–ธ๋ฌธ์€ ์ •์˜ ์ „์— ํ˜ธ์ถœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์™œ๋ƒ๋ฉด JS๋Š” ์Šคํฌ๋ฆฝํŠธ๋ฅผ ์‹คํ–‰ํ•˜๊ธฐ ์ „, ์ „์—ญ์— ์„ ์–ธ๋œ ํ•จ์ˆ˜ ์„ ์–ธ๋ฌธ์„ ์ฐพ์•„ ํ•ด๋‹น ํ•จ์ˆ˜๋ฅผ ์ƒ์„ฑํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.
      • ๋˜ํ•œ '์—„๊ฒฉ ๋ชจ๋“œ'๋ฅผ ์‚ฌ์šฉ ์ค‘์ด๋ผ๋ฉด, ํ•จ์ˆ˜ ์„ ์–ธ๋ฌธ์œผ๋กœ ์„ ์–ธ๋œ ์ฝ”๋“œ๋Š” ๋ธ”๋ก ๋‚ด์—์„œ๋งŒ ์œ ํšจํ•˜๊ณ , ๋ธ”๋ก ๋ฐ–(์ค‘๊ด„ํ˜ธ ๋ฐ–)์—์„œ๋Š” ํ˜ธ์ถœํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

     

     

     

    +++

    prompt()
    - ํ™•์ธ์„ ๋ˆ„๋ฅด๋ฉด ํ•ด๋‹น ๊ฐ’(๋ฌธ์ž์—ด)์„ ๋ฐ˜ํ™˜
    - ์ทจ์†Œ๋ฅผ ๋ˆ„๋ฅด๋ฉด null์„ ๋ฐ˜ํ™˜
    - ์•„๋ฌด ๊ฒƒ๋„ ์ž…๋ ฅํ•˜์ง€ ์•Š์œผ๋ฉด ๋นˆ ๋ฌธ์ž์—ด์„ ๋ฐ˜ํ™˜

    confirm()
    - ํ™•์ธ์„ ๋ˆ„๋ฅด๋ฉด true๋ฅผ ๋ฐ˜ํ™˜
    - ์ทจ์†Œ๋ฅผ ๋ˆ„๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜
    728x90

    ๋Œ“๊ธ€

Designed by Nana