Skip to content

Latest commit

Β 

History

History
1344 lines (875 loc) Β· 24 KB

TIL_221130.md

File metadata and controls

1344 lines (875 loc) Β· 24 KB

❀️‍πŸ”₯ TIL DAY 15 ❀️‍πŸ”₯

πŸ“† 2022λ…„ 11μ›” 30일 μˆ˜μš”μΌ




ν”Όκ³€.. 아직도 λͺ¨κΈ°κ°€ ν™œκ°œμΉ˜λŠ”κ²Œ 말이 λ˜λ‚˜..
빨리 λͺΈ νšŒλ³΅ν•˜κ³  λ‹€μ‹œ μ—΄μ‹¬νžˆ ν•  수 μžˆλŠ” μ»¨λ””μ…˜μ΄ λŒμ•„μ™”μœΌλ©΄ μ’‹κ² μŒ πŸ₯²




πŸ“š JavaScript_Basic

Homebrew μ΄μš©ν•΄μ„œ node.js μ„€μΉ˜


πŸ’‘ Node.js λŒ€ν™”ν˜• λͺ¨λ“œ

  • 터미널에 node μž…λ ₯

communication




πŸ’‘ Node.js νŒŒμΌμ„ 읽어 λ“€μ—¬μ„œ μ‹€ν–‰

  • ν„°λ―Έλ„μ—μ„œ $ node /파일경둜 μž…λ ₯

jsFile




πŸ’‘ 문자 μ½”λ“œ

  • μœ λ‹ˆμ½”λ“œ 문자둜 μž‘μ„±



πŸ’‘ λŒ€λ¬Έμžμ™€ μ†Œλ¬Έμž

  • JavaScriptλŠ” μ•ŒνŒŒλ²³ λŒ€λ¬Έμžμ™€ μ†Œλ¬Έμžλ₯Ό ꡬ별함
    • a와 A
    • consoleκ³Ό Console

  • ex) 였λ₯˜
    (console.log μ½”λ“œλ₯Ό Console.log 둜 μž…λ ₯ μ‹œ)

    ConsoleErr




πŸ’‘ 토큰

  • ν”„λ‘œκ·Έλž¨μ„ κ΅¬μ„±ν•˜λŠ” μ΅œμ†Œ λ‹¨μœ„
  • μžλ°”μŠ€ν¬λ¦½νŠΈ μΈν„°ν”„λ¦¬ν„°λŠ” ν”„λ‘œκ·Έλž¨ μ‹€ν–‰ μ „ ν”„λ‘œκ·Έλž¨μ„ ν† ν°μœΌλ‘œ λΆ„ν•΄(μ–΄νœ˜ 뢄석)
  • μ˜μ–΄ λ¬Έμž₯μ—μ„œλŠ” 단어가 토큰
  • 'JavaScript is powerful.'
    • JavaScript, is, powerfulλΌλŠ” 단어 μ„Έ κ°œμ™€ λ§ˆμΉ¨ν‘œ(.)κ°€ 토큰
  • 의미λ₯Ό κ°€μ§€λŠ” μ΅œμ†Œν•œμ˜ 문자 덩어리
  • return n*fact(n-1); -> return | n | * | fact | ( | n | - | 1 | ) | ;

πŸ“ νŒŒμ‹±(ꡬ문 뢄석)

  • μ–΄νœ˜ 뢄석 ν›„ 토큰을 ν•œ μ€„λ‘œ λ‚˜μ—΄ν•˜κ³  μ˜¬λ°”λ₯Έ ν”„λ‘œκ·Έλž¨μΈμ§€ νŒμ •ν•˜λŠ” λ™μž‘
  • νŒŒμ‹± ν›„ λ¬Έμ œκ°€ μ—†μœΌλ©΄ ν”„λ‘œκ·Έλž¨ μ‹€ν–‰



πŸ’‘ ν‘œν˜„μ‹κ³Ό λ¬Έμž₯

  • ν‘œν˜„μ‹

    273
    10 + 20 + 30 * 2
    "JavaScript Programming"
    
  • λ¬Έμž₯ : ν‘œν˜„μ‹μ΄ ν•˜λ‚˜ 이상 λͺ¨μΌ 경우, λ§ˆμ§€λ§‰ μ’…κ²° 의미둜 μ„Έλ―Έμ½œλ‘ (;)

  • ν”„λ‘œκ·Έλž¨ : λ¬Έμž₯이 λͺ¨μ΄λ©΄ ν”„λ‘œκ·Έλž¨μ΄ 됨




πŸ’‘ μ‹λ³„μž

  • 이름을 뢙일 λ•Œ μ‚¬μš©ν•˜λŠ” 단어

  • λ³€μˆ˜μ™€ ν•¨μˆ˜ 이름 λ“±μœΌλ‘œ μ‚¬μš©

  • ν‚€μ›Œλ“œλ₯Ό μ‚¬μš©ν•  수 μ—†μŒ

  • νŠΉμˆ˜λ¬ΈμžλŠ” _ 와 $ 만 μ‚¬μš© κ°€λŠ₯

  • 숫자둜 μ‹œμž‘ν•  수 μ—†μŒ

  • 곡백을 μž…λ ₯ν•  수 μ—†μŒ

    # μ‹λ³„μžλ‘œ μ‚¬μš© κ°€λŠ₯ν•œ 단어
    alpha
    alpha10
    _alpha
    $alpha
    AlPha
    ALPHA
    
    # μ‹λ³„μžλ‘œ μ‚¬μš© λΆˆκ°€ν•œ 단어
    break
    273alpha
    has space
    
  • μƒμ„±μž ν•¨μˆ˜μ˜ 이름은 항상 λŒ€λ¬Έμžλ‘œ μ‹œμž‘

  • λ³€μˆ˜, ν•¨μˆ˜, 속성, λ©”μ†Œλ“œμ˜ 이름은 항상 μ†Œλ¬Έμžλ‘œ μ‹œμž‘

  • μ—¬λŸ¬ λ‹¨μ–΄λ‘œ 된 μ‹λ³„μžλŠ” 각 λ‹¨μ–΄μ˜ 첫 κΈ€μžλ₯Ό λŒ€λ¬Έμžλ‘œ 함

    will out      //  willOut
    will return   //  willReturn
    i am a boy    //  iAmABoy
    
  • μ‹λ³„μž 뒀에 κ΄„ν˜Έκ°€ 없을 경우

    • 단독 μ‚¬μš© μ‹œ : λ³€μˆ˜ λ˜λŠ” μƒμˆ˜
    • λ‹€λ₯Έ μ‹λ³„μžμ™€ μ‚¬μš© μ‹œ : 속성
  • μ‹λ³„μž 뒀에 κ΄„ν˜Έκ°€ μžˆλŠ” 경우

    • 단독 μ‚¬μš© μ‹œ : ν•¨μˆ˜
    • λ‹€λ₯Έ μ‹λ³„μžμ™€ μ‚¬μš© μ‹œ : λ©”μ†Œλ“œ
  • example

    alert('Hello World')          //  ν•¨μˆ˜
    Array.length                  //  속성
    input                         //  λ³€μˆ˜ λ˜λŠ” μƒμˆ˜
    propmt('Message', 'Defstr')   //  ν•¨μˆ˜
    Math.PI                       //  속성
    Math.abs(-273)                //  λ©”μ†Œλ“œ
    



πŸ’‘ 곡백 문자 μƒλž΅

곡백 λ¬Έμžκ°€ 없어도 토큰을 νŒλ³„ν•  수 μžˆλŠ” 경우

    a = 1 + 2 * 3 ;     -> a=1+2*3;
    function fact( n )  -> function fact(n)
    { x : 1 , y : 2 }   -> {x:1,y:2}
    obj . x             -> obj.x
    [ 1 , 2 , 3 ]       -> [1,2,3]
    a [ 0 ] = 10;       -> a[0]=10;
  • =, +, *, / 같은 μ‚°μˆ  μ—°μ‚°μž μ•žλ’€μ˜ 곡백 문자
  • (, ), {, }, [, ] 같은 κ΄„ν˜Έ μ•žλ’€μ˜ 곡백 문자
  • ;, ,, :, . μ•žλ’€μ˜ 곡백 문자
  • μ΄λŸ¬ν•œ 토큰은 λΆ„λ¦¬μž λ˜λŠ” κ΅¬λΆ„μž 라고 뢀름
  • .의 μ•žλ’€, [의 μ•žλΆ€λΆ„ 곡백 λ¬ΈμžλŠ” λ°˜λ“œμ‹œ μƒλž΅ν•¨



πŸ’‘ μ΄μŠ€μΌ€μ΄ν”„ μ‹œν€€μŠ€

  • \0 -> null 문자
  • \b -> 백슀페이슀 문자
  • \t -> μˆ˜ν‰ νƒ­ 문자
  • \n -> κ°œν–‰ 문자
  • \v -> 수직 νƒ­ 문자
  • \f -> λ‹€μŒ νŽ˜μ΄μ§€ 문자
  • \r -> 캐리지 리턴 문자(CR)
  • \' -> μž‘μ€λ”°μ˜΄ν‘œ 문자
  • \" -> ν°λ”°μ˜΄ν‘œ 문자
  • \\ -> μ—­μŠ¬λž˜μ‹œ 문자
  • \xXX -> 두 자릿수 16μ§„μˆ˜ XX둜 μ§€μ •λœ Latin-1 문자
  • \uXXXX -> λ„€ 자릿수 16μ§„μˆ˜ XXXX둜 μ§€μ •λœ μœ λ‹ˆμ½”λ“œ 문자
  • \u{XXXXXX} -> 16μ§„μˆ˜ μ½”λ“œ 포인트 XXXXXX둜 μ§€μ •λœ μœ λ‹ˆμ½”λ“œ 문자



πŸ’‘ 주석

  • ν”„λ‘œκ·Έλž¨ 진행에 영ν–₯을 주지 μ•ŠλŠ” μ½”λ“œ

  • ν•œ 쀄 주석 처리 -> // 주석

  • μ—¬λŸ¬ 쀄 주석 처리 -> /* 주석 */

    // 주석은 μ½”λ“œμ˜ 싀행에 영ν–₯을 주지 μ•ŠμŒ
    /*
    console.log("JavaScript Programming")
    console.log("JavaScript Programming")
    console.log("JavaScript Programming")
    */
    



πŸ’‘ 좜λ ₯

πŸ“ 좜λ ₯ λ©”μ†Œλ“œ

  • console 객체의 log() λ©”μ†Œλ“œ μ‚¬μš©

  • console.log() λ©”μ†Œλ“œ

    console.log("λ¬Έμžμ—΄")
    console.log("JavaScript Programming");
    -> JavaScript Programming 좜λ ₯
    

πŸ“ REPL을 μ‚¬μš©ν•œ 좜λ ₯

  • κ³§λ°”λ‘œ λ¬Έμž₯을 μž…λ ₯ν•΄μ„œ 좜λ ₯

    > λ¬Έμž₯
    좜λ ₯_κ²°κ³Ό
    

    REPL




πŸ’‘ κΈ°λ³Έ μžλ£Œν˜•

πŸ“ 숫자

  • κ°€μž₯ 기본적인 μžλ£Œν˜•

    console.log(52);
    console.log(52.271);
    
    > 52 + 273
    325
    

    num1

  • + : λ§μ…ˆ μ—°μ‚°μž

  • - : λΊ„μ…ˆ μ—°μ‚°μž

  • * : κ³±μ…ˆ μ—°μ‚°μž

  • / : λ‚˜λˆ—μ…ˆ μ—°μ‚°μž

  • μ—°μ‚°μž μš°μ„ μˆœμœ„

    console.log(5 + 3 * 2);
    

    num2

  • %λ‚˜λ¨Έμ§€ μ—°μ‚°μž

    > 10 % 5
    0
    > 7 % 3
    1
    

    num3
    num4




πŸ“ λ¬Έμžμ—΄

  • 문자의 집합

  • λ¬Έμžμ—΄ μƒμ„±μ‹œ ν°λ”°μ˜΄ν‘œλ‚˜ μž‘μ€λ”°μ˜΄ν‘œ μ‚¬μš©

    > "μ•ˆλ…•ν•˜μ„Έμš”"
    'μ•ˆλ…•ν•˜μ„Έμš”'
    > 'μ•ˆλ…•ν•˜μ„Έμš”'
    'μ•ˆλ…•ν•˜μ„Έμš”'
    
    > console.log("This is 'String'")
    This is 'String'
    undefined
    > console.log('This is "String"')
    This is "String"
    undefined
    

    hello
    thisIs


πŸ“ μ΄μŠ€μΌ€μ΄ν”„ 문자

  • λ”°μ˜΄ν‘œλ₯Ό 문자 κ·ΈλŒ€λ‘œ μ‚¬μš© κ°€λŠ₯

  • λ¬Έμžμ—΄ μ€„λ°”κΏˆ ν•  경우 μ‚¬μš©

    > console.log("This is \"String\"")
    This is "String"
    undefined
    > console.log('This is \'String\'')
    This is 'String'
    undefined
    
    > console.log("동해물과 백두산이\n마λ₯΄κ³  닳도둝");
    동해물과 백두산이
    마λ₯΄κ³  닳도둝
    undefined
    

    escape1
    escape2

  • \t - μˆ˜ν‰ νƒ­

  • \n - μ€„λ°”κΏˆ

  • \' - μž‘μ€λ”°μ˜΄ν‘œ

  • \" - ν°λ”°μ˜΄ν‘œ

  • \\ - μ—­μŠ¬λž˜μ‹œ

    escapleEx


πŸ“ λ¬Έμžμ—΄ ν•©ν•˜κΈ°

  • + : λ¬Έμžμ—΄ μ—°κ²° μ—°μ‚°μž

    +


πŸ“ 문자 선택 μ—°μ‚°μž

  • λ¬Έμžμ—΄[숫자] : 문자 선택 μ—°μ‚°μž

    string[num]


πŸ“ ν…œν”Œλ¦Ώ λ¬Έμžμ—΄

> `μ•ˆλ…•ν•˜μ„Έμš”`
'μ•ˆλ…•ν•˜μ„Έμš”'

>`52 + 273 = ${52 + 273}`
'52 + 273 = 325'

template




πŸ“ 뢈(boolean)

  • μ°Έκ³Ό κ±°μ§“μ˜ ν‘œν˜„ : true와 false

    > true
    true
    > false
    false
    
    52 < 273
    52 > 273
    

    boolean


  • 비ꡐ μ—°μ‚°μž
    • == : κ°™λ‹€.
    • != : λ‹€λ₯΄λ‹€.
    • > : μ™Όμͺ½ ν”Όμ—°μ‚°μžκ°€ 크닀.
    • < : 였λ₯Έμͺ½ ν”Όμ—°μ‚°μžκ°€ 크닀.
    • >= : μ™Όμͺ½ ν”Όμ—°μ‚°μžκ°€ ν¬κ±°λ‚˜ κ°™λ‹€.
    • <= : 였λ₯Έμͺ½ ν”Όμ—°μ‚°μžκ°€ ν¬κ±°λ‚˜ κ°™λ‹€.

  • booleanκ³Ό 비ꡐ μ—°μ‚°μž

    console.log(52 < 273);          //  true
    console.log(52 > 273);          //  false
    console.log("ν•˜λ§ˆ" < "κ°€λ°©");     //  false
    

    boolean2


  • ! : 논리 λΆ€μ • μ—°μ‚°μž

  • || : 논리합 μ—°μ‚°μž (이항 μ—°μ‚°μž)

    μ™Όμͺ½ ν”Όμ—°μ‚°μž 였λ₯Έμͺ½ ν”Όμ—°μ‚°μž κ²°κ³Ό
    true true true
    true false true
    flase true true
    false false false
  • && : 논리곱 μ—°μ‚°μž (이항 μ—°μ‚°μž)

    μ™Όμͺ½ ν”Όμ—°μ‚°μž 였λ₯Έμͺ½ ν”Όμ—°μ‚°μž κ²°κ³Ό
    true true true
    true false false
    false true false
    false false false

  • 논리 μ—°μ‚°μžλŠ” λ²”μœ„ νŒλ‹¨μ—μ„œ 주둜 μ‚¬μš©

    ex) 비ꡐ μ—°μ‚°μžμ˜ 잘λͺ»λœ μ‚¬μš©
    30 > 20 > 10
    
    30 > 20 > 10
    (30 > 20) > 10
    true > 10
    1 > 10
    false
    
    비ꡐ μ—°μ‚°μžκ°€ μ—¬λŸ¬ 개 μžˆμ„ λ•Œ,
    μ™Όμͺ½λΆ€ν„° μ°¨λ‘€λŒ€λ‘œ μ—°μ‚°ν•˜λ©΄μ„œ λ°œμƒν•˜λŠ” 문제
    

  • x < 3 λ˜λŠ” 8 < x의 λ²”μœ„ x1
  • 3 < x 그리고 x < 8의 λ²”μœ„ x2

  • ν˜„μž¬ μ‹œκ°„μ„ κ΅¬ν•˜λŠ” 방법

    let hours = (new Date()).getHours();
    
    console.log(hours < 3 || 8 < hours);
    console.log(3 <= hours && hours <=8);
    

    boolean3




πŸ’‘ λ³€μˆ˜

πŸ“ λ³€μˆ˜ μ΄ˆκΈ°ν™”

> let pi = 3.14159265;
undefined

let1


πŸ“ λ³€μˆ˜ ν™œμš©

> let pi = 3.14159265;
undefined
> console.log(pi);
3.14159265
undefined

let2


πŸ“ λ³€μˆ˜ κΈ°λ³Έ μ‚¬μš© 방법

  • λ°˜μ§€λ¦„κ³Ό 파이 값을 μ €μž₯ν•˜κ³ , μ›μ˜ λ‘˜λ ˆμ™€ 넓이λ₯Ό 계산

    let pi = 3.14159265;
    let radius = 10;
    
    console.log(`λ‘˜λ ˆ: ${2 * pi * radius}`);
    console.log(`넓이: ${pi * radius * radius}`);
    
    # μ‹€ν–‰ κ²°κ³Ό
    λ‘˜λ ˆ: 62.831853
    넓이: 314.159265
    

    let1 let4 let3




πŸ’‘ 볡합 λŒ€μž… μ—°μ‚°μž

  • λ³€μˆ˜μ— μ‚¬μš©ν•  수 μžˆλŠ” λͺ‡ 개의 νŠΉλ³„ν•œ μ—°μ‚°μž
    • a += 10κ³Ό a = a + 10의 κ²°κ³ΌλŠ” κ°™μŒ

  • += : 숫자 λ§μ…ˆ ν›„ λŒ€μž… μ—°μ‚°μž
  • -= : 숫자 λΊ„μ…ˆ ν›„ λŒ€μž… μ—°μ‚°μž
  • *= : 숫자 κ³±μ…ˆ ν›„ λŒ€μž… μ—°μ‚°μž
  • /= : 숫자 λ‚˜λˆ—μ…ˆ ν›„ λŒ€μž… μ—°μ‚°μž
  • += : λ¬Έμžμ—΄ μ—°κ²° ν›„ λŒ€μž… μ—°μ‚°μž

πŸ“ μˆ«μžμ™€ κ΄€λ ¨λœ 볡합 λŒ€μž… μ—°μ‚°μž

let output = 0;
output += 52;
output += 273;
output += 103;

console.log(output);

let5

let output = 0;
output = output + 52;
output = output + 273;
output = output + 103;

console.log(output);

let6


πŸ“ λ¬Έμžμ—΄κ³Ό κ΄€λ ¨λœ 볡합 λŒ€μž… μ—°μ‚°μž

let output = "hello ";
output += "world ";
output += "!";

console.log(output);
-> hello world !

let7


let output = "hello ";
output = output + "world ";
output = output + "!";

console.log(output);

let8




πŸ’‘ 증감 μ—°μ‚°μž

  • λ³€μˆ˜ numberλ₯Ό μ΄ˆκΈ°ν™”ν•˜κ³ , ++ μ—°μ‚°μžμ™€ -- μ—°μ‚°μžλ₯Ό μ‚¬μš©
  • 각 μ—°μ‚°μžμ—μ„œ λ³€μˆ˜ 값이 1만큼 변경됨

μ—°μ‚°μž μ„€λͺ…
λ³€μˆ˜++ κΈ°μ‘΄ λ³€μˆ˜ 값에 1을 더함(ν›„μœ„)
++λ³€μˆ˜ κΈ°μ‘΄ λ³€μˆ˜ 값에 1을 더함(μ „μœ„)
λ³€μˆ˜-- κΈ°μ‘΄ λ³€μˆ˜ κ°’μ—μ„œ 1을 뺌(ν›„μœ„)
--λ³€μˆ˜ κΈ°μ‘΄ λ³€μˆ˜ κ°’μ—μ„œ 1을 뺌(μ „μœ„)
let number = 10;

number++;
console.log(number);
number--;
console.log(number);

# μ‹€ν–‰ κ²°κ³Ό
11
10

num_1


πŸ“ 증감 μ—°μ‚°μž μ „μœ„

let number = 10;

console.log(number);
console.log(number++);
console.log(number--);
console.log(number);

numF


πŸ“ 증감 μ—°μ‚°μž ν›„μœ„

let number = 10;

console.log(number);
console.log(++number);
console.log(--number);
console.log(number);

numB


  • λ¬Έμž₯을 μ‹€ν–‰ν•˜κΈ° 전에 값을 λ³€κ²½ν•˜λΌλŠ” 의미

  • console.log(++number) μ½”λ“œλŠ” console.log(number)λ₯Ό μ‹€ν–‰ν•˜κ³  λ³€μˆ˜ number에 1을 더함

    num_2


  • μ°¨λ‘€λŒ€λ‘œ 10, 12, 12, 10 을 좜λ ₯ν•˜λŠ” μ½”λ“œ

    let number = 10;
    
    console.log(number++);
    console.log(++number);
    console.log(number--);
    console.log(--number);
    

    num_3

    let number = 10;
    
    console.log(number);
    number++;
    number++;
    console.log(number);
    console.log(number);
    number--;
    number--;
    console.log(number);
    

    num_4




πŸ’‘ μžλ£Œν˜• 검사

πŸ“ μžλ£Œν˜• 확인 μ—°μ‚°μž

  • typeof : ν•΄λ‹Ή λ³€μˆ˜μ˜ μžλ£Œν˜•μ„ μΆ”μΆœ

    > typeof 10
    'number'
    > typeof "λ¬Έμžμ—΄"
    'string'
    

    typeof1


  • 보톡 μ—°μ‚°μž 뒀에 κ΄„ν˜Έλ₯Ό λΆ™μž„

    > typeof (10)
    'number'
    > typeof ("λ¬Έμžμ—΄")
    'string'
    

    typeof2


  • μžλ°”μŠ€ν¬λ¦½νŠΈμ˜ μ—¬μ„― 가지 μžλ£Œν˜•

    > // λ¬Έμžμ—΄
    > typeof('String')
    'string'
    
    > // 숫자
    > typeof(273)
    'number'
    
    > // 뢈
    > typeof(true)
    'boolean'
    
    > // ν•¨μˆ˜
    > typeof(function () {})
    'function'
    
    > // 객체
    > typeof({})
    'object'
    
    > // undefined
    > let alpha
    > typeof(alpha)
    'undefined'
    

    typeof3




πŸ’‘ undefined μžλ£Œν˜•

  • λ³€μˆ˜λ₯Ό μ„ μ–Έν–ˆμœΌλ‚˜ μ΄ˆκΈ°ν™”ν•˜μ§€ μ•Šμ€ μžλ£Œν˜•

    > let a       //  μ΄ˆκΈ°ν™”ν•˜μ§€ μ•Šμ€ λ³€μˆ˜
    undefined
    > typeof(a)
    'undefined'
    
    > typeof(b)   //  μ„ μ–Έν•˜μ§€ μ•Šμ•˜λ˜ μ‹λ³„μž
    'undefined'
    

    typeof4




πŸ’‘ κ°•μ œ μžλ£Œν˜• λ³€ν™˜

πŸ“ κ°•μ œ μžλ£Œν˜• λ³€ν™˜ ν•¨μˆ˜

  • Number() : 숫자둜 μžλ£Œν˜• λ³€ν™˜
  • String() : λ¬Έμžμ—΄λ‘œ μžλ£Œν˜• λ³€ν™˜
  • Boolean() : 뢈둜 μžλ£Œν˜• λ³€ν™˜

πŸ“ String() ν•¨μˆ˜

// μˆ«μžλŠ” κ·ΈλŒ€λ‘œ λ¬Έμžμ—΄λ‘œ λ°”λ€œ
> String(52)
'52'
> String(273)
'273'

// λΆˆλ„ κ·ΈλŒ€λ‘œ λ¬Έμžμ—΄λ‘œ λ°”λ€œ
> String(true)
'true'
> String(false)
'false'

string


πŸ“ Number() ν•¨μˆ˜

console.log(Number("52"));
console.log(Number("52.273"));
console.log(Number(true));
console.log(Number(false));
console.log(Number("μ•ˆλ…•ν•˜μ„Έμš”"));  //  숫자둜 λ³€ν™˜ν•  수 μ—†λŠ” λ¬Έμžμ—΄

Number


πŸ“ NaN

  • 숫자둜 λ³€ν™˜ν•  수 μ—†λŠ” λ¬Έμžμ—΄μ„ Number() ν•¨μˆ˜λ‘œ λ³€ν™˜ν•˜λ©΄ NaN을 좜λ ₯

  • NaN(Not a Number) : 숫자 μžλ£Œν˜•μ΄μ§€λ§Œ μˆ«μžκ°€ μ•„λ‹Œ 것

  • NaN은 무쑰건적으둜 닀름

  • NaN인지 확인할 λ•ŒλŠ” isNaN() ν•¨μˆ˜ μ‚¬μš©

    // NaN λ³€μˆ˜λ₯Ό λ§Œλ“¬
    let nan = Number("μ•ˆλ…•ν•˜μ„Έμš”");
    
    // nan끼리 비ꡐ
    console.log(nan == nan);
    console.log(nan != nan);
    
    // isNaN() ν•¨μˆ˜λ‘œ NaN인지 확인
    console.log(isNaN(nan));
    

    NaN


πŸ“ Boolean() ν•¨μˆ˜

  • Boolean() ν•¨μˆ˜ μ‚¬μš© μ‹œ false λ³€ν™˜λ˜λŠ” μš”μ†Œ

    • 0
    • NaN
    • ""(빈 λ¬Έμžμ—΄)
    • null
    • undefined
  • 이 μ™Έμ—λŠ” λͺ¨λ‘ true둜 λ³€ν™˜

    // λ³€μˆ˜ μ„ μ–Έ
    let nan = Number("μ•ˆλ…•ν•˜μ„Έμš”");
    let undefinedVariable;
    
    // Boolean() ν•¨μˆ˜ μ‚¬μš©
    console.log(Boolean(0));
    console.log(Boolean(nan));
    console.log(Boolean(""));
    console.log(Boolean(null));
    console.log(Boolean(undefinedVariable));
    

    Boolean()




πŸ’‘ μžλ™ μžλ£Œν˜• λ³€ν™˜

πŸ“ μˆ«μžμ™€ λ¬Έμžμ—΄ μžλ£Œν˜• μžλ™ λ³€ν™˜

  • μˆ«μžμ™€ λ¬Έμžμ—΄μ— + μ—°μ‚°μžλ₯Ό μ μš©ν•˜λ©΄
    μžλ™μœΌλ‘œ μˆ«μžκ°€ λ¬Έμžμ—΄λ‘œ λ³€ν™˜λ¨

    console.log(52 + 273);
    console.log("52" + 273);
    console.log(52 + "273");
    console.log("52" + "273");
    

    52273


  • ex) λ‹€λ₯Έ μ—°μ‚°μž λŒ€μž…

    console.log("52" - 273);
    console.log("52" * 273);
    console.log("52" / 273);
    console.log("52" % 273);
    

    52273_2


πŸ“ 뢈 μžλ£Œν˜• μžλ™ λ³€ν™˜

  • ! μ—°μ‚°μžλ₯Ό 두 번 μ‚¬μš©ν•΄ Boolean() ν•¨μˆ˜λ₯Ό μ‚¬μš©ν•˜λŠ” 것과 같은 효과

    let nan = Number("μ•ˆλ…•ν•˜μ„Έμš”");
    let undefinedVariable;
    
    console.log(!!0);
    console.log(!!nan);
    console.log(!!"");
    console.log(!!null);
    console.log(!!undefinedVariable);
    

    !!




πŸ’‘ 일치 μ—°μ‚°μž

πŸ“ μžλ£Œν˜•κΉŒμ§€ 검사

  • === : μžλ£Œν˜•κ³Ό 값이 같은지 비ꡐ

  • !== : μžλ£Œν˜•κ³Ό 값이 λ‹€λ₯Έμ§€ 비ꡐ

    console.log(`52 == "52": ${52 == "52"}`);
    console.log(`52 === "52": ${52 === "52"}`);
    console.log();
    console.log(`0 == "": ${0 == ""}`);
    console.log(`0 === "": ${0 === ""}`);
    

    ===




πŸ’‘ μƒμˆ˜

  • 항상 같은 μˆ˜λΌλŠ” 의미, λ³€μˆ˜μ™€ λ°˜λŒ€λ˜λŠ” κ°œλ…
  • const : μƒμˆ˜(constant)λ₯Ό λ§Œλ“œλŠ” ν‚€μ›Œλ“œ
  • λ³€ν•˜μ§€ μ•Šμ„ λŒ€μƒμ— μƒμˆ˜λ₯Ό 적용

  • μƒμˆ˜μ™€ 였λ₯˜

    // μƒμˆ˜ μ„ μ–Έ
    const constant = "λ³€κ²½ν•  수 μ—†μ–΄μš”";
    constant = "";
    
    // 좜λ ₯
    console.log(constant);
    

    constErr

    const a = "처음 μ„ μ–Έν•  λ•Œ 값을 ν• λ‹Ήν•΄μ•Ό 함";
    const b;
    

    constErr2




πŸ“š JavaScript_쑰건문

πŸ’‘ if 쑰건문

  • κΈ°λ³Έ ν˜•νƒœ

    if (뢈_ν‘œν˜„μ‹) {
    
    }
    
  • 뢈 ν‘œν˜„μ‹μ΄ trueλ©΄ λ¬Έμž₯을 μ‹€ν–‰, falseλ©΄ λ¬Έμž₯을 λ¬΄μ‹œ

if_1


πŸ“ ν™€μˆ˜ 짝수 ꡬ뢄

let input = 32;

if (input % 2 == 0) {
    console.log("μ§μˆ˜μž…λ‹ˆλ‹€!");
}

if (input % 2 == 1) {
    console.log("ν™€μˆ˜μž…λ‹ˆλ‹€!");
}

if_2


πŸ“ μ˜€μ „ μ˜€ν›„ ꡬ뢄

  • ν˜„μž¬ μ‹œκ°„ κ΅¬ν•˜κΈ°

    let date = new Date();
    
    console.log(date.getFullYear());
    console.log(date.getMonth());
    console.log(date.getDay());
    console.log(date.getHours());
    console.log(date.getMinutes());
    console.log(date.getSeconds());
    

    letDate_1

  • μ˜€μ „κ³Ό μ˜€ν›„ κ΅¬λΆ„ν•˜κΈ°

    let date = new Date();
    
    if (date.getHours() < 12) {
        console.log("μ˜€μ „μž…λ‹ˆλ‹€.");
    }
    
    if (12 <= date.getHours()) {
        console.log("μ˜€ν›„μž…λ‹ˆλ‹€.");
    }
    

    letDate_2




πŸ’‘ if else 쑰건문

  • κΈ°λ³Έ ν˜•νƒœ

    if (뢈_ν‘œν˜„μ‹) {
      // 뢈_ν‘œν˜„μ‹μ΄ 참일 λ•Œ μ‹€ν–‰ν•  λ¬Έμž₯
    } else {
      // 뢈_ν‘œν˜„μ‹μ΄ 거짓일 λ•Œ μ‹€ν–‰ν•  λ¬Έμž₯
    }
    

    ifElse_1


πŸ“ ν™€μˆ˜, 짝수 ꡬ뢄

let input = 32;

if (input % 2 == 0) {
    console.log("μ§μˆ˜μž…λ‹ˆλ‹€!");
} else {
    console.log("ν™€μˆ˜μž…λ‹ˆλ‹€!");
}

ifElse_2


πŸ“ μ˜€μ „, μ˜€ν›„ ꡬ뢄

let date = new Date();

if (date.getHours() < 12) {
    console.log("μ˜€μ „μž…λ‹ˆλ‹€.");
} else {
    console.log("μ˜€ν›„μž…λ‹ˆλ‹€.");
}

ifElse_3




πŸ’‘ 쀑첩 쑰건문

  • κΈ°λ³Έ ν˜•νƒœ

    if (뢈_ν‘œν˜„μ‹) {
      λ¬Έμž₯;
    } else {
      if (뢈_ν‘œν˜„μ‹) {
        λ¬Έμž₯;
      } else {
        λ¬Έμž₯;
      }
    }
    

πŸ“ Example

let date = new Date();
let hours = date.getHours();

if (hours < 11) {
    console.log("μ•„μΉ¨ 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
} else {
  if (hours < 15) {
      console.log("점심 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
  }
  else {
      console.log("저녁 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
  }
}

ifElse_4

  • DateTime.Now.Hour < 11 쑰건을 비ꡐ
  • false이면 DateTime.Now.Hour < 15 쑰건을 ν•œ 번 더 비ꡐ



πŸ’‘ if else if 쑰건문

μ€‘λ³΅λ˜μ§€ μ•ŠλŠ” μ„Έ 가지 μ΄μƒμ˜ 쑰건을 ꡬ뢄할 λ–„ μ‚¬μš©


  • κΈ°λ³Έ ν˜•νƒœ

    if (뢈_ν‘œν˜„μ‹) {
    
    } else if (뢈_ν‘œν˜„μ‹) {
    
    } else if (뢈_ν‘œν˜„μ‹) {
    
    } else {
    
    }
    

πŸ“ Example_if else is 쑰건문

let date = new Date(); let hours = date.getHours();

if (hours < 11) {
    console.log("μ•„μΉ¨ 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
} else if (hours < 15) {
    console.log("점심 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
} else {
    console.log("저녁 먹을 μ‹œκ°„μž…λ‹ˆλ‹€.");
}

ifElseIf_1




πŸ’‘ switch 쑰건문

  • κΈ°λ³Έ ν˜•νƒœ

    swith (비ꡐ할_κ°’) {
      case κ°’:
          λ¬Έμž₯
          break;
      case κ°’:
          λ¬Έμž₯
          break;
      default :
          λ¬Έμž₯
          break;
    }
    

    swtich_0


πŸ“ ν™€μˆ˜μ™€ 짝수 ꡬ뢄

let input = 32;

switch (input % 2) {
    case 0 : 
        console.log("μ§μˆ˜μž…λ‹ˆλ‹€.");
        break;
    case 1 :
        console.log("ν™€μˆ˜μž…λ‹ˆλ‹€.");
        break;
}

switch_1


πŸ“ break ν‚€μ›Œλ“œλ₯Ό μ‚¬μš©ν•˜μ§€ μ•ŠλŠ” switch 쑰건문

let date = new Date();

switch (date.getMonth() + 1) {
    case 12 :
    case 1 :
    case 2 :
        console.log("κ²¨μšΈμž…λ‹ˆλ‹€.");
        break;
    case 3 :
    case 4 :
    case 5 :
        console.log("λ΄„μž…λ‹ˆλ‹€.");
        break;
    case 6 :
    case 7 :
    case 8 :
        console.log("μ—¬λ¦„μž…λ‹ˆλ‹€.");
        break;
    case 9 :
    case 10 :
    case 11 :
        console.log("κ²¨μšΈμž…λ‹ˆλ‹€.");
        break;
    dafault :
        console.log("λŒ€μ²΄ μ–΄λ–€ 행성에 μ‚΄κ³  κ³„μ‹ κ°€μš”?");
        break;
}

switch_2




πŸ’‘ 쑰건 μ—°μ‚°μž

  • κΈ°λ³Έ ν˜•νƒœ

    뢈_ν‘œν˜„μ‹ ? 참일_λ•Œ_μ‹€ν–‰ν•˜κ³ _λ°–μœΌλ‘œ_λ‚Ό_κ°’ : 거짓일_λ•Œ_μ‹€ν–‰ν•˜κ³ _λ°–μœΌλ‘œ_λ‚Ό_κ°’
    

πŸ“ 쑰건 μ—°μ‚°μžλ₯Ό ν™œμš©ν•œ λ³€μˆ˜ μ΄ˆκΈ°ν™”

  • λ³€μˆ˜κ°€ undefined일 λ•Œ μƒˆλ‘œμš΄ κ°’μœΌλ‘œ μ΄ˆκΈ°ν™”

    // λ³€μˆ˜ μ„ μ–Έ
    let test;
    
    // μ‚Όν•­ μ—°μ‚°μžλ‘œ ν•΄λ‹Ή λ³€μˆ˜κ°€ undefined인지 ν™•μΈν•˜κ³  μ΄ˆκΈ°ν™”
    test = typeof(test) != 'undefined' ? test : "μ΄ˆκΈ°ν™”_1";
    console.log(test)
    
    // μ‚Όν•­ μ—°μ‚°μžλ‘œ ν•΄λ‹Ή λ³€μˆ˜κ°€ undefined인지 ν™•μΈν•˜κ³  μ΄ˆκΈ°ν™”
    test = typeof(test) != 'undefined' ? test : "μ΄ˆκΈ°ν™”_2";
    console.log(test)
    

    undefined_1


  • 쑰건문으둜 λ³€κ²½ν•œ μ½”λ“œ

    let test;
    
    if (typeof(test) != 'undefined') {
        test = "μ΄ˆκΈ°ν™”_1"
    }
    console.log(test)
    
    if (typeof(test) != 'undefined') {
        test = "μ΄ˆκΈ°ν™”_2"
    }
    console.log(test)
    



πŸ’‘ prompt()

  • μž…λ ₯ λ°›λŠ” ν•¨μˆ˜
  • μ›Ή λΈŒλΌμš°μ €μ—μ„œ μ‚¬μš© κ°€λŠ₯

❗️ Node.jsμ—μ„œ μž‘λ™ν•˜λŠ” μžλ°”μŠ€ν¬λ¦½νŠΈλŠ” μž…λ ₯을 받을 수 μ—†μŒ


πŸ“ μž…λ ₯ λ°›λŠ” 방법

// λͺ¨λ“ˆ μΆ”μΆœ
const repl = requir('repl');

// μž…λ ₯ μ‹œμž‘
repl.start({
    prompt : "μž…λ ₯_λ•Œ_μ•žμ—_좜λ ₯ν• _λ¬Έμžμ—΄",
    eval : (command, context, filename, callback) => {
        // μž…λ ₯(command)을 λ°›μ•˜μ„ λ–„ 처리λ₯Ό μˆ˜ν–‰

        // 처리 μ™„λ£Œ
        callback();
    }
})

πŸ“ μž…λ ₯을 받은 λŒ€μƒμ΄ μˆ«μžμΈμ§€ μ•„λ‹Œμ§€ ν™•μΈν•˜λŠ” 예제

// λͺ¨λ“ˆ μΆ”μΆœ
const repl = require('repl');

// μž…λ ₯ μ‹œμž‘
repl.start({
    prompt : "숫자 μž…λ ₯> ",
    eval : (command, context, filename, callback) => {
        // μž…λ ₯(command)을 λ°›μ•˜μ„ λ•Œ 처리λ₯Ό μˆ˜ν–‰
        let number = Number(command);

        // μž…λ ₯이 μˆ«μžμΈμ§€ 확인
        if(isNaN(number)) {
            console.log("μˆ«μžκ°€ μ•„λ‹™λ‹ˆλ‹€.");
        } else {
            console.log("μˆ«μžμž…λ‹ˆλ‹€.");
        } 

        // 처리 μ™„λ£Œ
        callback();
    }
});

prompt

μ™œ λ‘λ²ˆμ”© μž…λ ₯이 λ˜λŠ”κ±°μ§€..??




πŸ“• Task_221130

  • 3자리 숫자 두 개λ₯Ό κ³±ν•΄μ„œ λ§Œλ“  수 μ€‘μ—μ„œ λŒ€μΉ­μˆ˜(palindrome) μ΄λ©΄μ„œ κ°€μž₯ 큰 값을 κ΅¬ν•˜μ‹œμ˜€.