JavaScript: JS 기초 Ep.5 (비교,논리 연산자, 삼항연산자, If, Switch, 반복문 for, 변수 유효범위, 형 변환)

비교, 논리 연산자


  • 비교 연산자 (comparison operator)
    // 일치 연산자
    const a = 1
    const b = 1
      
    console.log(a === b) // true
    -----------------------------
    // 일치 연산자를 이용한 함수 만들기
    function isEqual(x,y) {
      return x === y
    }
      
    console.log(isEqual(1, 1)) // true
    console.log(isEqual(2, '2')) // false
    -----------------------------
    // 불일치 연산자
    const a = 1
    const b = 1
      
    console.log(a !== b) // false
    -----------------------------
    // 비교 연산자
    console.log(a < b) // false
    console.log(a > b) // false
    console.log(a >= b) // true
    console.log(a <= b) // true
    
    • 일치 연산자 (===): 왼쪽의 데이터(a)와 오른쪽의 데이터(b)를 비교하여 서로 일치하는지 확인함 데이터 타입과 값 모두 일치해야만 true가 반환됨
    • 불일치 연산자 (!==): 왼쪽의 데이터(a)와 오른쪽의 데이터(b)를 비교하여 서로 불일치하는지 확인함 데이터 타입과 값 모두 불일치해야만 true가 반환됨
  • 논리 연산자 (logical operator)
    const a = 1 === 1
    const b = 'AB' === 'AB'
    const c = true
    const d = false
      
    console.log(a) // true
    console.log(b) // true
    console.log(c) // true
      
    console.log('&&: ',a && b && c) // true
    console.log('&&: ',a && b && d) // false
    console.log('||: ',a || b || c) // true
    console.log('||: ',a || b || d) // true
    console.log('!: ', a) // true
    console.log('!: ', !a) // false
    
    • and(그리고)연산자 ( && )
      해당 값들이 모두 동일해야만 true 반환한다. 하나라도 false라면 결과값은 false가 나온다.
    • or(또는)연산자 ( || )
      ture값이 하나이상 있다면 true를 반환한다. true 값이 하나라도 없어야 (모두 false여야) false값이 나온다.
    • not(부정)연산자 ( ! )
      ‘!’ 뒤 데이터가 true면 false 반환, false면 true를 반환한다. 해당 데이터의 반대되는 데이터 값을 반환한다.

삼항 연산자 (ternary operator)


말 그대로 항이 3개가 존재한다. (a, ‘참’, ‘거짓’)
? 를 기준으로 앞의 값이 true인지 false인지 확인한다.
만약 true라면, : 의 앞부분 실행, false면 : 의 뒷부분 실행

const a = 1 < 2  // a = true

if (a) {
	console.log('')
} else {
	console.log('거짓')
} // '참'

// 삼항 연산자 사용
console.log(a ? '' : '거짓') // '참'

조건문 (If, Switch)


  • If statement

    // getRandom.js
    export default function random() {
      return Math.floor(Math.random() * 10)
    }
    
    • export default는 해당 파일 밖으로 내보내기 위한 것이다.
    • Math 수학 객체를 사용하여 랜덤한 수를 반환한다.
    • 랜덤 수 * 10에 내림(floor) => 정수값만 나오도록한다.
    // main.js
      
    import random from './getRandom'
      
    const a = random()
      
    if (a === 0) {
      console.log('a is 0')
    } else if (a === 2) {
      console.log('a is 2') 
    } else if (a === 4) {
      console.log('a is 4') 
    } else {
      console.log('rest...')
    }
    
  • Switch statement

    import random from './getRandom'
      
    const a = random()
      
    switch (a) {
      case 0: // a 값이 0일때, a is 0 출력
        console.log('a is 0')
        break // break를 하지 않으면 멈추지 않고 다음 케이스가 실행될 수 있음
      case 2: // a 값이 2 일때
        console.log('a is 2')
        break
      case 4:
        console.log('a is 4')	
        break
      default: // case가 전부 해당 안될때, 마치 else 같은 것
        console.log('rest...')
        // 맨 마지막에 실행되는 것이기 때문에 break 필요 없음
    }
    

반복문 For


반복문 (For statement)
for (시작조건; 종료조건; 변화조건) {}

<html>
<head>
	<script defer src="./main.js"></script>
</head>
<body>
	<h1>Hello world!</h1>
	<ul></ul>
</body>
</html>
const ulEl = document.querySelector('ul')

for (let i = 0; i < 3; i += 1) {
	const li = document.createElement('li')
	li.textContent = `list-${i + 1}`
	ulEl.appendChild(li)
}

// Hello world!
// * list-1
// * list-2
// * list-3
  • 클릭한 요소의 값을 반환

    for (let i = 0; i < 10; i += 1) {
      const li = document.createElement('li')
      li.textContent = `list-${i + 1}`
      li.addEventListener('click', function () {
      console.log(li.textContent)
    }) //textContent -> 요쇼의 값을 지정, 요소가 갖고 있는 값을 얻어낼 수도 있다
      ulEl.appendChild(li)
    }
    
    // Hello world!
    // * list-1
    // * list-2
    // * list-3
    // * list-4
    ...
    // * list-10
    
    // list-2 클릭시 'list-2' 반환
    
  • 짝수 반환하기
    list-7 클릭 -> 반환
    list-8 클릭 -> 반환안됨
    => 문제 발생!

    for (let i = 0; i < 10; i += 1) {
    const li = document.createElement('li')
    li.textContent = `list-${i + 1}`
    if (i % 2 === 0) {
      li.addEventListener('click', function () {
        console.log(li.textContent)
      })
    } 
    ulEl.appendChild(li)
    }
    
    // 짝수값을 클릭했을때 값이 나오게 하고 싶은데!
    
  • 해결
    list-${i + 1} => (i + 1)
    if 조건또한 i가 아닌 i + 1로 한다.
    보이는 것만 1로 시작하게 설정했지 실제로는 0부터 시작(제로 베이스)이기 때문이다.

    for (let i = 0; i < 10; i += 1) {
      const li = document.createElement('li')
      li.textContent = `list-${i + 1}`
      if ((i + 1) % 2 === 0) {
        li.addEventListener('click', function () {
          console.log(li.textContent)
        })
      } 
      ulEl.appendChild(li)
    }
    
    // if 조건 부분의 i를 i+1로 변경하면 짝수 클릭시 출력, 홀수 클릭시 미출력
    

변수 유효범위 (Variable Scope)


var(되도록 사용 X), let, const

  • let, const
    블록 레벨의 유효범위를 가진다.
    블록 ⇒ 변수가 선언되어져 있는 그 범위의 중괄호{} 부분이 하나의 블록이다.
    이 블록 내부에서의 유효한 범위를 가질 수 있다.
  • var
    함수 레벨의 유효범위를 가진다.
    함수 범위 안에서라면 어디서든지 사용이 가능하다.
    만약, 값이 지정되기 전에 사용했다면 undefined라고 나오는 것이다. ⇒ 에러가 아니다!
    블록레벨보다 범위가 더 크기 때문에 의도하지 않은 범위 내에서 사용될 수 있다. 그만큼 메모리를 차지하게 되고 이것이 개발자가 확인하지 못하는 메모리 누수로 발전할 수 있다.
    그렇기에 var를 잘 사용하지 않는 것이다!!

    // let과 const -> 블록 레벨의 유효범위를 가짐
      
    function scope() {
      if (true) {
        const a = 123
        console.log(a)
      }
    }
    scope()
      
    // 123
    ----------------------------
    
    function scope() {
      if (true) {
        const a = 123
      }
      console.log(a)
    }
    scope()
      
    // ReferenceError
    ----------------------------
    
    function scope() {
      if (true) {
        console.log(a)
        const a = 123
      }
    }
    scope()
      
    // undefined
    ----------------------------
    
    function scope() {
      console.log(a)
      if (true) {
        const a = 123
      }
    }
    scope()
      
    // ReferenceError
    
    // var -> 블록이 아닌 함수 범위의 유효범위를 가짐
      
    function scope() {
      console.log(a)
      if (true) {
        var a = 123
      }
    }
    scope()
      
    // undefined
    ----------------------------
    
    function scope() {
      if (true) {
        var a = 123
      }
      console.log(a)
    }
    scope()
      
    // 123
    

형 변환 (Type conversion)


데이터 타입(형)들의 변환

  • 동등연산자 (==)

    자바스크립트를 사용할때 되도록 사용하지 않는 것을 권장한다. 의도하지 않게 다른 값을 같다라고 나올 수 있기 때문이다.
    대부분의 다른 언어에서는 ‘==’를 사용하지만 자바스크립트에서는 동등연산자(==)를 사용하면 형 변환이 일어난다.
    1과 ‘1’은 다른 타입이지만 타입변화(형 변환)가 일어나 같다고 나오게 된다. 그렇기에 자바스크립에서 비교할때는 ‘===’ 를 사용하자!

    const a = 1
    const b = '1'
      
    console.log(a === b)
    // false
      
    console.log(a == b)
    // true
    
  • 형 변환 정리

    if (true) {
      console.log(123)
    } //123
      
    if (false) {
      console.log(123)
    } // - 아무것도 반환되지 않음 - 
      
    if ('false') {
      console.log(123)
    } //123
    // 'false'(문자열)는 true와 같은 값이라고 보면 됨
    // 이것이 바로 자바스크립트의 형 변환!
      
    if (0) {
      console.log(123)
    } // - 아무것도 반환되지 않음 - 
      
    if (undefined) {
      console.log(123)
    } // - 아무것도 반환되지 않음 - 
    
    • Truthy (참 같은 값)
      true, {}, [], 1, 2, ‘false’, -12, ‘3.14’ …
    • Falsy (거짓 같은 값)
      false, ‘’ , null, undefined, 0, -0, NaN(Not a Number)

    • NaN (Not a Number)
      숫자 데이터이긴 하지만 숫자는 아닐때이다.
      되도록 나오지 않도록 해야 한다.
      1 + undefined // NaN

JavaScript: JS 기초 Ep.4 (메소드 체이닝, 데이터 타입 확인, 산술 할당 연산자)

메소드 체이닝


  • Method Chaining
    const a = 'Hello~';
    // split: 문자를 인수 기준으로 쪼개서 배열로 반환
    // reverse: 배열을 뒤집기
    // join: 배열을 인수 기준으로 문자로 병합해서 반환
    const b = a.split('').reverse().join(''); // 메소드 체이닝...
    //메소드가 마치 체인 형식처럼 연결되어 있다고 해서...
      
    console.log(a); // Hello~
    console.log(b); // ~olleH
    

데이터 타입 확인


typeof
특정한 데이터의 타입을 확인할 수 있다.
단, 객체 데이터와 배열 데이터는 typeof만으로 확인하기는 어렵다. 따라서, 함수를 만들어서 타입을 구분해 줄 수 있도록 한다.

// **main.js** 

console.log(typeof 'Hello World!')
// string

console.log(typeof 123)
// number

console.log(typeof true)
// boolean

console.log(typeof undefined)
// undefined

console.log(typeof null)
// object

console.log(typeof {}) // 객체 데이터
// object

console.log(typeof []) // 배열 데이터
// object

// 객체, 배열 데이터 타입 구분을 위한 함수
// 해당 함수는 함수가 작성된 파일안에서만 사용이 가능함
function getType(data) {
  return Object.prototype.toString.call(data)
}

console.log(getType(123))
// [object Number]

console.log(getType(false))
// [object Boolean]

// 원하는 부분만 출력하기
function getType(data) {
  return Object.prototype.toString.call(data).slice(8, -1)
	// slice를 사용하여 앞의 8개와 뒤 1개를 없애버림
}

console.log(getType(123))
// Number

console.log(getType(false))
// Boolean

console.log(getType(null))
// Null

console.log(getType({}))
// Object

console.log(getType([]))
// Array
  • 만들어낸 함수(getType)를 다른 js파일에서 사용이 불가능 하다. (해당 함수가 작성된 파일 내에서만 사용 가능)
    ⇒ 매번 함수를 적어줘야 한다는 번거로움 발생한다.
// getType.js

//** 번거로움을 해결하기 위한 방법
export default function getType(data) {
  return Object.prototype.toString.call(data).slice(8, -1)
}
// **main.js

//** getType 불러오기
import getType from './getType' 
// getType뒤에 .js 생략 가능, 이동 경로(./) 확실하게 입력해야 함.

console.log(getType(123))
// Number
  • export: 해당 함수(getType)를 getType.js파일 밖으로 내보내기가 가능하다.
  • default: 내보낼 때, 정의된 함수가 getType이라는 자바스크립트 파일에 가장 기본적인 형태의 내보내지는 함수 데이터라고 선언한다.

산술, 할당 연산자


  • 산술 연산자 (arithmetic operator)
    // 더하기
    console.log(1 + 2) // 3
      
    // 빼기
    console.log(5 - 7) // -2
      
    // 곱하기
    console.log(3 * 4) // 12
      
    // 나누기
    console.log(10 / 2) // 5
      
    // 나머지
    console.log(7 % 5) // 2
    
  • 할당 연산자 (assigment operator)
    // '='이 할당 연산자
    let a = 2
    ----------------------
    // a = a + 1, 아래와 같은 기호
    // '+=' 할당 연산자
    a += 1
      
    console.log(a) // 3
    ------------------------
    // a = a - 1, 아래와 같은 기호
    // '-=' 할당 연산자
    a -= 1
      
    console.log(a) // 1
    -----------------------
    // a = a * 1, 아래와 같은 기호
    // '*=' 할당 연산자
    a *= 1
      
    console.log(a) // 2
    -----------------------
    // a = a / 1, 아래와 같은 기호
    // '/=' 할당 연산자
    a /= 1
      
    console.log(a) // 2
    -----------------------
    // a = a % 1, 아래와 같은 기호
    // '%=' 할당 연산자
    a %= 1
      
    console.log(a) // 0
    

JavaScript: JS 기초 Ep.3 (DOM API)

DOM API


Document Object Model, Application Programming Interface의 약자이다.
Document ⇒ HTML에 들어있는 Object model을 말한다. (div, span, input 요소 등)
API ⇒ 웹 사이트가 동작하기 위해서 입력하는 프로그래밍 명령이다.
DOM API ⇒ 자바스크립트에서 HTML을 제어하는 명령들이다.

  • 간단 defer 예시
    let boxEl = document.querySelector('.box');
      
    console.log(boxEl);
    
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>Document</title>
      <script src="./main.js"></script>
    </head>
    <body>
      <div class="box">Box!!</div>
    </body>
    </html>
      
    <!-- 출력 null -->
    
    • 위에서 아래로 해석하기 때문에 script 부분에서 .box를 요구한다. 그러나 .box는 script이후에 나온다. 그렇기에 출력한 값이 null이 나오게 된다.

      해결 방법 1

      <!DOCTYPE html>
      <html lang="en">
      <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
      </head>
      <body>
        <div class="box">Box!!</div>
        <script src="./main.js"></script>
      </body>
      </html>
            
      <!-- 출력 Box!! -->
      
      • script의 위치를 바꿔준다. script 보다 .box가 상위에 존재하기에 main.js에서 .box를 찾을 수 있어서 출력되는 값이 Box!!로 나온다.
      • 하지만 main.js를 연결해달라는 것은 “정보”이기에 head 태그 안에 작성하는 것이 좋다.

      해결 방법 2

      <!DOCTYPE html>
      <html lang="en">
      <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
        <script defer src="./main.js"></script>
      </head>
      <body>
        <div class="box">Box!!</div>
      </body>
      </html>
            
      <!-- 출력 Box!! -->
      
      • defer을 사용하여 HTML 코드를 다 읽은 상태에서 다시 main.js 내용을 실행하겠다는 것이다.
      • 이렇게 하면 script 부분을 head 태그 안에 두면서 원하는 값으로 출력이 가능하다.
  • DOM API - addEventListner
    // HTML 요소(Element) 1개 검색/찾기
    const boxEl = document.querySelector('.box');
    // documet라는 브라우저에서 제공하는 어떤 객체 데이터가 이미 정의되어 있음.
    // querySelector이라는 메소드에 찾으려는 CSS 선택자를 찾아서 반환
    // 반환한 값은 boxEl이라는 변수에 넣음 
    // 이때 boxEl은 박스인데 요소임. 그래서 이 변수는 하나의 요소라는 것을 명시적으로 나타냄
      
    // HTML 요소에 적용할 수 있는 메소드
    boxEl.addEventListener();
      
    // 인수(Arguments) 추가 가능
    boxEl.addEventListener(1, 2);
      
    // 1 - 이벤트(Event, 상황)
    boxEl.addEventListener('click', 2);
    // 사용자가 boxEl라는 것을 클릭했을 때 => 이벤트
      
    // 2 - 핸들러(Handler, 실행할 함수)
    boxEl.addEventListener('click', function() {
      console.log('Click~!');
    }); // 최종 사용하는 모습임
    // 사용자가 boxEl를 클릭하면 이 익명의 함수를 실행하겠다는 것을 의미
    // 이때 지정하는 익명의 함수를 Handler 핸들러라고 부름
    
    • 어떠한 요소에 특정한 상황 (이벤트)이 발생하는 지를 듣고 있다가 그 상황이 실제로 발생하게 되면, 함수를 실행한다. 이때, 실행하는 함수를 Handler라고 부른다.
  • DOM API - classList
    // HTML 요소(Element) 1개 검색/찾기
    const boxEl = document.querySelector('.box');
      
    // 요소의 클래스 정보 객체 활용!
      
    // classList = class 정보를 가지고 있는 객체 데이터
    // boxEl라는 클래스를 가지고 있는 요소에 active라는 클래스를 추가를 하겠다는 명령
    boxEl.classList.add('active');
    let isContains = boxEl.classList.contains('active');
    console.log(isContains); //true
    // classList라는 객체 내부에서 active라는 클래스가 포함(contains)되어 있는지 체크해주는 API
    // 있다면 True가 반환되어 반환된 값이 isContains라는 변수에 할당됨
      
    boxEl.classList.remove('active');
    isContains = boxEl.classList.contains('active');
    console.log(isContains); //false
    // remove를 통해 active라는 클래스를 삭제했기에 포함되어 있지 않다고 나옴 -> false가 나옴
    
  • DOM API - forEach
    // HTML 요소(Element) 모두 검색/찾기
    //quertSelectorAll, All이 붙었기에 뒤에 명시하는 모든 요소를 반환
    const boxEls = document.querySelectorAll('.box');
    console.log(boxEls);
      
    /// 여기서 부터 출력 전까지는 과정들임 (설명)
      
    // 여러 개의 찾은 요소들 반복(forEach)해서 함수 실행!
    // 익명 함수(function () {})를 인수로 추가!
    boxEls.forEach(function () {});
    //boxEls는 복수형태로, 배열 데이터로 만들어짐.
    //생긴 것은 배열처럼 생겼지만 정확하게는 유사 배열(Array-like)이라고 함
      
    //익명 함수의 매개변수
    // 첫 번째 매개변수(boxEls): 반복 중인 요소
    // 두 번째 매개변수(index): 반복 중인 번호
    boxEls.forEach(function (boxEl, index) {});
      
    // 출력!
    boxEls.forEach(function (boxEl, index) {
      boxEl.classList.add(`order-${index + 1}`);
      console.log(index, boxEl);
    });
    
  • DOM API - textContent
    const boxEl = document.querySelector('.box');
    // All이 붙지 않은 그냥 셀렉터이기에 제일 먼저 찾은 ()안 요소만을 넣음
      
    // Getter, 값을 얻는 용도
    console.log(boxEl.textContent); // Box!!
      
    // Setter, 값을 지정하는 용도
    boxEl.textContent = 'HEROPY?!';
    console.log(boxEl.textContent); // HEROPY?!
    

JavaScript: JS 기초 Ep.2 (예약어, 함수, 조건문)

예약어


예약어는 특별한 의미를 가지고 있어, 변수나 함수 이름 등으로 사용할 수 없는 단어이다.

  • Reserved Word
    let this = 'Hello'; // SyntaxError
    let if = 123; // SyntaxError
    let break = true; // SyntaxError
    

함수


특정 동작(기능)을 수행하는 일부 코드의 집합(부분)이다.

  • function
    // 함수 선언
    function helloFunc() {
      // 실행 코드
      console.log(1234);
    }
      
    // 함수 호출
    helloFunc(); // 1234
    ----------------------------------------
    function returnFunc() {
      return 123; // 숫자 데이터 123을 반환
    }
    // return을 통해 데이터를 함수 밖으로 내보낼 수 있다.
      
    let a = returnFunc(); // 함수가 호출(실행)되면서 변수 a에 할당된다.
      
    console.log(a); // 123
      
    
  • 매개변수(Parameters) 및 인수(Arguments)
    // 함수 선언
    function sum(a, b) { // a와 b는 매개변수 (Parameters)
      return a + b; 
    }
    // 매개변수: 함수 안에서 사용하는 데이터를 받아주는 매개체가 되어주는 변수
    // 함수 안에서만 사용이 가능하다
      
    // 재사용
    let a = sum(1,2); // 1과 2는 인수 (Arguments)
    let b = sum(7, 12); // sum이라는 함수 호출(실행)
    let c = sum(2,4);
      
    console.log(a, b, c); // 3, 19, 6
      
    // 인수: 매개변수가 받아줄 특정한 데이터들
    ------------------------------------------
    // 기명(이름이 있는) 함수
    // 함수 선언: 함수의 이름이 명시되어져 있고 내가 원하는 이름을 명시
    function hello() {
      console.log('Hello~');
    }
      
    // 익명(이름이 없는) 함수
    // 함수 표현: 이름이 없는 상태로 소괄호 시작
    // 익명함수는 데이터로서 사용되거나 변수에 할당되어 사용함
    let world = function () {
      console.log('World~');
    }
      
    // 함수 호출
    hello(); // Hello~
    world(); // World~
    
  • 메소드 (Method)
    // 객체 데이터
    const soha = {
      name: 'SOHA', //name, age은 속성
      age: 85,
      // getName, 속성 부분에 함수가 할당되어져 있음
      // 메소드(Method): 속성부분에 일반적인 데이터가 아닌 함수가 할당되어져 있다
      getName: function () {
        return this.name; // this는 this가 속해져있는 객체데이터를 의미함
        // this.name = this가 속해져 있는 데이터의 name이라는 속성을 return 반환해주세요
      }
    };
    // soha 안에서 getName을 실행하게 되면 soha안에 있는 name이라는 속성의 값이
    // getName 밖으로 빠져나올 수 있게 됨.
      
    const hisNmae = soha.getName();
    console.log(hisName); // SOHA
    // 혹은
    console.log(soha.getName()); // SOHA
    

    조건문


    조건의 결과(truthy, falsy)에 따라 다른 코드를 실행하는 구문이다.

  • if
    let isShow = true
    let checked = false
      
    if (isShow) { // 조건 = isShow / isShow가 트루라면 실행
      console.log('Show!') // Show!
    }
      
    if (checked) { // 조건 = checked / checked가 false이기에 실행되지 않음
      console.log('Checked!')  
    }
    
  • else
    let isShow = true
      
    if (isShow) { // true면 Show! 실행
      console.log('Show!')
    } else { // false라면 Hide? 실행
      console.log('Hide?')
    }
    

JavaScript: JS 기초 Ep.1 (표기법, 제로 넘버링, 주석, 데이터 종류, 변수)

표기법 (프로그래밍 표기법)


  • dash-case(kebab-case)
    dash(-)기호를 사용하는 표기법이다. HTML, CSS에서 사용한다.
    꼬챙이에 끼운게 케밥처럼 생겼다고도 해서 케밥 케이스라고도 부른다.
    dash 기호를 붙여줌으로써 띄어쓰기를 대신하고 있다.
    ex) the-quick-brown-fox-jumps-over-the-lazy-dog
  • snake_case
    단어와 단어 사이에 underscore ()를 사용하여 하나로 묶어낸다. HTML, CSS에서 사용한다. ex) the_quick_brown_fox_jumps_over_the_lazy_dog
  • camelCase
    첫 글자는 소문자로 시작 그 다음부터 오는 단어들은 대문자로 시작하는 단어이다.
    낙타 혹 같아 보여서 카멜 케이스라고 부르며 JS에서 주로 사용한다.
    ex) theQuickBrownFoxJumpsOverTheLazyDog
  • ParcelCase
    첫 단어와 다음에 오는 단어 모두 대문자로 시작한다.
    카멜 케이스와 유사하지만 처음 단어를 대문자로 작성한다는 점이 다르다.
    추후, JS에서 New라는 키워드를 가지고 있는 생성자 함수를 배울 때 파스칼 케이스를 통해 함수의 이름을 명시한다. JS에서 사용한다. (이 중에서도 특수한 경우에 사용한다.)
    ex) TheQuickBrownFoxJumpsOverTheLazyDog

Zero-based Numbering


0 기반 번호 매기기!
특수한 경우를 제외하고 0부터 숫자를 시작한다.

주석 Comments


// 한 줄 메모
/* 한 줄 메모 CSS처럼도 사용 가능*/

/* 여러줄 할 CSS형식이 좋다
 * 여러 줄
 * 메모1
 * 메모2
 */

데이터 종류 (자료형)


  • String
    // String (문자 데이터)
    // 따옴표를 사용합니다.
    let myName = "SOHA"; // 큰 따옴표
    let email = 'thesecon@gmail.com'; // 작은 따옴표
    let hello = `Hello ${myName}?!`; //빽틱(`), 
    // 그 문자 중간의 어딘가에다가 다른 데이터들을 '보간'해서 중간에 끼워넣을 수 있다.
    // 보간법이라고 하며, 안에 js의 데이터들을 넣으면 된다. false, 123을 넣어도 문자처럼 출력된다.
      
    console.log(myName); //SOHA
    console.log(email); // thesecon@gmail.com
    console.log(hello); // Hello SOHA?!
    
  • Number
    // Number (숫자 데이터)
    // 정수 및 부동소수점 숫자를 나타냅니다.
    let number = 123; //number라는 변수에 숫자(정수)를 넣음
    let opacity = 1.57; //opacity라는 변수에 숫자 (소수점)를 넣음
      
    console.log(number); //123
    console.log(opacity); //1.57
    
  • Boolean
    // Boolean (불린 데이터)
    // true, false 두 가지 값밖에 없는 논리 데이터입니다.
    let checked = true; //따옴표가 없으니 문자 데이터가 아니다!
    let isShow = false;
      
    console.log(checked); //true
    console.log(isShow); // false
    
  • Undefined
    // Undefined
    // 값이 할당되지 않은 상태를 나타냅니다. == 값이 없다
    let undef;// 값이 없는 상태 = js는 이 상태를 undefined라는 하나의 데이터로 인식
    let obj = { abc: 123 }; //obj 데이터는 {안에 속성: 값} 데이터들의 집합
      
    console.log(undef); // undefined
    console.log(obj.abc): // 123, obj라는 변수에 가서 abc라는 하나의 속성의 값이 무엇?
    console.log(obj.xyz); // undefined
    
  • Null
    // Null
    // 어떤 값이 '의도적으로' 비어있음을 의미합니다.
    // undef는 의도하지 않았지만 null은 의도적으로 비어있게 만듦
    let empty = null; // 명시적이다. null을 넣었으므로, 의도적으로 값을 넣지 않았다. 
      
    console.log(empty); // null
    
  • Object
    // Object(객체 데이터)
    // 여러 데이터를 Key:Value 형태로 저장하는 데이터들의 집합. { }
    let user = {
      // Key: Value,
      name: 'SOHA',
      age: 85,
      isValid: true
    }; // 중괄호 시작과 끝 사이의 모든 내용을 user라는 변수에 감아서 사용
    // 객체데이터 안에서 구현하는 방식을 가지고서 이러한 형태를 Key: Value라 함.
    // name, age, isValid라는 각각의 데이터들을 하나의 객체데이터로써 user에 넣는다.
      
    console.log(user.name); // SOHA , user안의 데이터를 사용할때 .을 사용하여 추출
    console.log(user.age); // 85
    console.log(user.isValid); // true
    
  • Array
    // Array (배열 데이터)
    // 여러 데이터를 순차적으로 저장합니다. [ ] (대괄호를 사용)
    let fruits = ['Apple', 'Banana', 'Cherry']; //쉼표(,)로 데이터를 구분
    // 따옴표가 있네? == 문자데이터
    console.log(fruits[0]); // 'Apple'
    console.log(fruits[1]); // 'Banana'
    console.log(fruits[2]); // 'Cherry'
    

변수


데이터를 저장하고 참조(사용)하는 데이터의 이름

  • let
    // 재사용 가능
    // 변수 선언
    let a = 2;
    let b = 5
      
    console.log(a+b); //7
    console.log(a-b); //-3
    console.log(a*b); //10
    console.log(a/b); //0.4
    -------------------------------------------------
    // 값(데이터)의 재할당 가능
    let a = 12; //let을 통해 a라는 변수 선언
    console.log(a); // 12
      
    a = 999; // a 변수에 값 재할당
    console.log(a); // 999
    
  • const
    // 값(데이터)의 재할당 불가
    const a = 12; //선언
    console.log(a); // 12
      
    a = 999; //재할당 -> 타입 에러 (재할당 불가!) 처음 선언할 때의 값을 제외하고는 값을 선언할 수 없음
    console.log(a); // TypeError: Assignment to constant variable.
      
    // 거의 대부분의 경우에 const를 사용
    // 재할당을 해야하는 부분일 때 const를 let으로 고쳐서 사용한다.
    
  • var 사용하는 것을 권장하지 않는다.