[Javascript] 키워드 총정리 | 자바스크립트의 키워드와 종류

1. 키워드의 정의

키워드(Keyword)란 프로그래밍 언어에서 특정한 의미나 기능을 가진 단어로서, 언어의 문법에서 특별한 역할을 수행하도록 사전에 정의된 예약어입니다.

특히 자바스크립트에서의 키워드는 ECMA International(ECMAScript Language Specification)에 의해 제정되고 있는 표준 중 하나인 ECMA-262(언어 표준 정의)에 정의되어 있습니다.

2. 키워드의 종류 및 예시

각 키워드들에 대한 종류들을 역할들을 기준으로 살펴보겠습니다.

• 변수 선언 및 할당:
  var (ES6 이전까지 사용되었던 변수 선언 키워드)
  let (ES6부터 사용된 변수 선언 키워드)
  const (ES6부터 사용된 상수 선언 키워드)

var x = 10; // 전역 객체의 변수
let y = 20; // 지역 변수
const PI = 3.14; // 변하지 않는 변수

• 조건문:
  if (true에 해당하는 코드문의 실행)
  else (false에 해당하는 코드문의 실행)
  else if (다른 조건문의 추가와 이에 부합하는(true) 코드문의 실행)

if (x > 5) { // 해당 조건이 참(true)일 경우 코드 블럭문 실행
  console.log("x is greater than 5");
} else if (x === 5) { // 또 다른 조건이 참(true)일 경우 코드 블럭문 실행
  console.log("x is equal to 5");
} else { // 위의 조건에 부합하지 않는 남은 조건에서의 값, 혹은 거짓(false)일 경우 코드 블럭문 실행
  console.log("x is less than 5");
}

switch (조건에 맞는 선택지를 실행시키는 키워드입니다.)
case (조건에 맞는 선택지의 코드가 실행되는 곳입니다.)
default (위의 조건에 걸리지 않을때 실행됩니다.)

switch (day) { // day에 따른 선택지를 실행시킵니다.
  case "Monday": // 해당 day의 값 상태에 따라 블록 실행
    console.log("It's Monday");
    break; // break문으로 switch문 최종 종료
  case "Tuesday":
    console.log("It's Tuesday");
    break;
  default: // 위에 걸리는 case문이 하나도 없을 때 default문이 실행.
    console.log("It's another day");
}

• 루프 및 반복문:
  for (특정 조건 범위 안에 해당 코드 블럭문을 실행)

for (let i = 0; i < 5; i++) { // i가 5보다 작을 때까지 1씩 누적시켜가며 루프를 반복
  console.log(i); // 반복할 코드문
}

while (원하는 답이 나올 때 까지 반복 실행)

let i = 0;
while (i < 5) { // i가 5보다 작은 동안 무한 반복
  console.log(i); // 반복할 코드문 1
  i++; // 반복한 코드문 2
}

do (while의 조건문에 맞지 않더라도(false 더라도) 일단 1번 실행합니다.)

let i = 0;
do { // 조건( i < 5)에 부합하더라도 일단 한 번 실행하고 while문에서 종료 됩니다.
  console.log(i);
  i++;
} while (i < 5);

break (제어문 및 반복문을 종료시키는 역할)
continue (현재 실행 중인 루프를 건너띄고 다음 루프를 실행시키는 역할)

for (let i = 0; i < 10; i++) {
  if (i === 5) { // 특정 조건에 부합(true)할 경우
    break; // loop 종료
  }
  if (i % 2 === 0) { // 특정 조건에 부합(true)할 경우
    continue; // 현재 루프를 스킵
  }
  console.log(i);
}

• 함수 및 객체:
  function (함수를 의미)
  return (반환할 값을 의미)

function add(a, b) { //함수 add를 정의
  return a + b; // return 값으로 반환 시킬 값을 작성
}

this (생성자 함수의 인스턴스 마다 들어갈 고유 속성들을 의미)
new (인스턴스를 생성하는대에 사용됩니다.)

function Person(name) {
  this.name = name; // 인스턴스마다 들어갈 고유 프로퍼티
}

const person = new Person("John"); // 해당 생성자 함수에 대한 새로운 인스턴스를 생성

class (ES6에 추가된 생성자 함수로 객체 지향을 좀 더 쉽게 구현)
extends (상위 클래스를 상속 받는 키워드)
super (상속 받은 클래스의 프로퍼티)

class Animal { // 클래스 생성
  constructor(name) {
    this.name = name;
  }
}

class Dog extends Animal { // Dog 클래스를 상속 받음
  constructor(name, breed) {
    super(name); // 상속 받는 Dog 클래스의 name 프로퍼티를 상속 받음.
    this.breed = breed;
  }
}

• 객체 및 속성 관리:
  object (객체 리터럴로 구성. 타입은 Object로 확인 됩니다. object라는 키워드는 따로 없으며 통상적으로 부르는 단어로서 타입은 Object로 확인 됩니다.)

let myObject = { key: 'value' }; // 객체 생성
console.log(myObject); // { key: 'value' } // 객체 출력

prototype(생성자 함수의 경우, 해당 생성자 함수로 인해 생성된 인스턴스들이 모두 공유할 수 있는 일종의 공유 객체(프로토타입 객체)라고 보시면 되겠습니다.)

function Dog(name) { //생성자 함수
    this.name = name;
}

Dog.prototype.bark = function() { // 생성자 함수의 프로토타입 객체의 메서드로 bark 메서드를 정의
    console.log(this.name + ' barks!');
};

let myDog = new Dog('Buddy');
let myAnotherDog = new Dog('Lucy');
myDog.bark(); // Buddy barks!
myAnotherDog.bark(); // Lucy barks!
console.log(myDog.hasOwnProperty('speak')); // 인스턴스가 해당 메서드를 가지고 있는 것이 아니므로 false를 반환.

constructor(해당 인스턴스가 어떠한 생성자 함수에 의해서 생성되었는지 확인하는 방법. 참고로 여기서의 constructor는 생성자 함수가 객체를 생성하기 위해 호출하는 내장 객체가 아니라 모든 객체들이 공통적으로 가지고 있는 프로퍼티를 의마합니다.)

function Car(make, model) {
    this.make = make;
    this.model = model;
}

let myCar = new Car('Toyota', 'Camry');
console.log(myCar.constructor); // [Function: Car]

instanceof (해당 인스턴스의 생성자 함수에 대한 진실 여부를 참, 거짓으로 반환해줌.)

function Bird(name) {
    this.name = name;
}

let myBird = new Bird('Robin');
console.log(myBird instanceof Bird); // true
console.log(myBird instanceof Object); // true, 모든 객체는 Object의 인스턴스

• 비교 및 논리 연산자:
  == (동등 비교 연산자, 피연산자 간의 타입 캐스팅 허용)
  === (엄격 비교 연산자, 피연산자 간의 타입 캐스팅 불허)

let num1 = 5;
let num2 = '5';

// 동등 비교
console.log(num1 == num2); // true, 값은 같으므로 true

// 일치 비교
console.log(num1 === num2); // false, 값은 같지만 데이터 타입이 다르므로 false

!= (부등 비교 연산자)
!== (엄격한 부등 비교 연산자)

let x = 10;
let y = '10';

// 부등 비교
console.log(x != y); // false, 값은 같으므로 false

// 부등 및 일치 비교
console.log(x !== y); // true, 값은 같지만 데이터 타입이 다르므로 true

&& (논리 AND, 비교되는 피연산자들이 전부 true여야 true를 반환, 하나라도 false일 경우 false를 반환)

let condition1 = true;
let condition2 = false;
// AND 연산
if (condition1 && condition2) { // 두 조건이 만족할 시 true를 반환.
    console.log('Both conditions are true.');
} else {
    console.log('At least one condition is false.');
} // 현재의 조건은 false이므로 At least one condition is false.를 반환

|| (논리 OR, 비교되는 피연산자들 중 하나라도 true일 경우 true를 반환, 전부 false일 경우 false를 반환)

let condition1 = true;
let condition2 = false;

// OR 연산
if (condition1 || condition2) { // 두 조건 중 하나라도 참일 경우 true를 반환.
    console.log('At least one condition is true.');
} else {
    console.log('Both conditions are false.');
} // 반환값은 'At least one condition is true.'

! (논리 NOT, boolean 값을 역전시킵니다.)

let flag = true;

// NOT 연산
if (!flag) { // 해당 값을 반전시킴.
    console.log('Flag is false.');
} else {
    console.log('Flag is true.');
} // true의 반대인 false값 'Flag is true'를 반환.

• 예외 처리:
  try (예외 발생 케이스를 정의)
  catch (해당 예외 케이스에 대한 처리를 담당)
  throw (개발자가 직접 에러를 생성하여 예외를 발생 시킴)
  finally(예외의 발생 유무와 상관 없이 무조건 실행 되는 코드문)

function divide(a, b) {
  try {
    if (b === 0) {
      throw new Error('Cannot divide by zero.'); // 조건에 맞다면 새로운 에러 객체를 생성합니다.
    }
    return a / b; // 조건에 맞지 않는, 정상적인 상황일 경우 연산 처리 결과를 반환
  } catch (error) { // 해당 에러를 캐치해서
    console.error('Error:', error.message); // 콘솔에 에러 메세지(error.message(Cannot divide by zero))를 출력합니다.
  } finally { // 무조건 실행됩니다.
    console.log('Finally block: This will be executed regardless of an error.');
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(8, 0));  // Output: Error: Cannot divide by zero. \n Finally block: This will be executed regardless of an error.

• 기타:
  delete (객체의 요소 제거)
  typeof (타입 확인)
  instanceof (인스턴스 여부 확인)
  void (값이 없음을 나타냄)

let car = { make: 'Honda', model: 'Civic' };
console.log(car, typeof(car)); // Output: { make: 'Honda', model: 'Civic' } : typeof(car)는 object로 출력.
console.log(car instanceof Object); // car는 Object의 인스턴스? : true;
console.log(void car); // undefined // car를 undefined로 만들어버림.

delete car.model; // car의 model 프로퍼티 삭제
console.log(car); // Output: { make: 'Honda' }