Grammar

Type

1. Primitive Types

A primitive type represents a single value, and is a data type in which the value itself is stored. Primitive types are immutable, and there are a total of 7 types.

• implements

let name = "John";       // string
  let age = 30;            // number
  let isAdult = true;      // boolean
  let largeNumber = 123456789123456789n;  // bigint
  let notDefined;          // undefined
  let emptyValue = null;   // null
  let unique = Symbol();   // symbol

2. Reference Types

Reference types can store complex data structures, storing references to objects. Reference types are mutable.

• implements

let person = { name: "Alice", age: 25 };  // 객체
  let numbers = [1, 2, 3, 4];               // 배열 (객체의 특수한 형태)
  function greet() {                        // 함수 (일급 객체)
    console.log("Hello!");
  }

3. Special object type

There are also several special object types in JavaScript.

• implements

let currentDate = new Date();  // Date 객체
  let regex = /ab+c/i;           // 정규 표현식 (RegExp)
  let map = new Map();           // Map 객체
  let set = new Set();           // Set 객체

4. Check type

How to check data type in JavaScript:

1. typeof operator: Returns the type of most primitive and reference types.
   – implements

console.log(typeof "Hello");       // "string"
     console.log(typeof 42);            // "number"
     console.log(typeof true);          // "boolean"
     console.log(typeof undefined);     // "undefined"
     console.log(typeof null);          // "object" (설계 상의 버그)
     console.log(typeof Symbol());      // "symbol"
     console.log(typeof {});            // "object"
     console.log(typeof []);            // "object" (배열도 객체)
     console.log(typeof function(){});  // "function"

2. instanceof operator: allows you to check whether an object is an instance of a specific class.
   – implements

console.log([] instanceof Array);   // true
     console.log({} instanceof Object);  // true
     console.log(function(){} instanceof Function); // true

Conditional statement

• if statement: Executes only when the condition is true.
• if...else statement: Executed when the condition is true and false.
• if...else if...else statement: Evaluates multiple conditions.
• switch statement: Handles multiple cases for one value.
• Ternary Operator: Simple condition processing.
• try...catch statement: Exception handling.

Repeat

1. Basic for statement

The basic for statement is a loop statement that repeats a given number of times. You can set three conditions: Initialization, Conditional expression, Increment expression.

• abstract

for (initialization; condition; increment) {
    // 실행할 코드
  }

• implements

for (let i = 0; i < 5; i++) {
    console.log(i); // 0, 1, 2, 3, 4 출력
  }

2. for...of statement

for...of is used to iterate over elements in an iterable object (array, string, Map, Set, etc.). Each iteration returns the value of the iterable object.

• abstract

for (variable of iterable) {
    // 실행할 코드
  }

• implements

let arr = ['a', 'b', 'c'];
  for (let element of arr) {
    console.log(element); // 'a', 'b', 'c' 출력
  }

let str = "hello";
  for (let char of str) {
    console.log(char); // 'h', 'e', 'l', 'l', 'o' 출력
  }

3. for...in statement

for...in is used to repeat **properties (keys)** of an object. It can be used on arrays as well as objects, but it iterates over the index rather than the elements of the array, so it is mainly used on objects rather than arrays.

• abstract

for (variable in object) {
    // 실행할 코드
  }

• implements

let person = { name: 'John', age: 30, city: 'New York' };
  for (let key in person) {
    console.log(key, person[key]); // name John, age 30, city New York 출력
  }

let arr = [10, 20, 30];
  for (let index in arr) {
    console.log(index, arr[index]); // 0 10, 1 20, 2 30 출력
  }

4. while statement

The while statement repeatedly executes a block of code when a given conditional expression is true. Execution continues until the condition becomes false.

• abstract

while (condition) {
    // 실행할 코드
  }

• implements

let i = 0;
  while (i < 5) {
    console.log(i); // 0, 1, 2, 3, 4 출력
    i++;
  }

5. do...while statement

do...while is a loop statement that checks the condition after the code is executed at least once. Repeat until the condition is false.

• abstract

do {
    // 실행할 코드
  } while (condition);

• implements

let i = 0;
  do {
    console.log(i); // 0, 1, 2, 3, 4 출력
    i++;
  } while (i < 5);

6. forEach Method

forEach is an array-specific iteration method that executes a callback function for each element in the array. It is executed once for each element of a given array, and can access the index and the array itself.

• abstract

array.forEach((element, index, array) => {
    // 실행할 코드
  });

• implements

let arr = [1, 2, 3, 4];
  arr.forEach((value, index) => {
    console.log(`Index: ${index}, Value: ${value}`);
  });

7. map Method

map executes the given callback function for each element of the array and returns a new array as a result. The original array is not modified.

• abstract

array.map((element, index, array) => {
    // 실행할 코드
  });

• implements

let arr = [1, 2, 3];
  let newArr = arr.map(value => value * 2);
  console.log(newArr); // [2, 4, 6]

8. for await...of statement

for await...of is used when iterating over an asynchronous iterable. In an asynchronous function, you can sequentially process the resolved value of a Promise.

• abstract

for await (variable of asyncIterable) {
    // 실행할 코드
  }

• implements

async function processItems(items) {
    for await (let item of items) {
      console.log(item);
    }
  }

  const asyncIterable = {
    [Symbol.asyncIterator]() {
      let i = 0;
      return {
        next() {
          if (i < 3) {
            return Promise.resolve({ value: i++, done: false });
          }
          return Promise.resolve({ done: true });
        }
      };
    }
  };

  processItems(asyncIterable); // 0, 1, 2 출력

Operator

1. Arithmetic Operators

Arithmetic operators are used to calculate numeric values.

2. Assignment Operators

The assignment operator is used when assigning a value to a variable.

3. Increment and Decrement Operators

The increment/decrement operator increases or decrements the value by 1.

4. Comparison Operators

Comparison operators compare two values and return true or **false**.

5. Logical Operators

Logical operators combine logical values and return a result.

6. Ternary Operator

The ternary operator is an operator that can create short conditional statements. If the condition is true, it returns the first value, and if it is false, it returns the second value.

7. Bitwise Operators

Bit operators perform bit-by-bit operations on 32-bit numbers.

8. Type Operators

Type operators are used to check or manipulate the type of a variable or expression.

9. Comma Operator

The comma operator is used to evaluate multiple expressions into one expression. The last expression is returned.

10. String Concatenation Operator

The concatenation operator is used to concatenate strings.

11. Nullish Coalescing Operator

The ?? operator returns the first operand that is not **null or undefined**.

12. Optional Chaining Operator

The optional chaining operator ?. returns undefined without generating an error if null or undefined.

13. Spread Operator

The spread operator ... is used to expand an iterable (array, string, etc.)** into individual elements, and is also useful for copying and merging of objects or arrays.

• Implements

let arr = [1, 2, 3];
  let newArr = [...arr, 4, 5]; // [1, 2, 3, 4, 5]

  let obj = {a: 1, b: 2};
  let newObj = {...obj, c: 3}; // {a: 1, b: 2, c: 3}

14. Rest Operator

The Rest operator is also used as ..., and is used when receiving the remaining arguments as an array in function parameters. It operates in the opposite way to the expansion operator.

• Implements

function sum(...numbers) {
    return numbers.reduce((acc, curr) => acc + curr, 0);
  }

  console.log(sum(1, 2, 3)); // 6

15. Pipeline Operator

Pipeline operators are operators that are currently in the proposal phase. Pipeline operators allow you to process data sequentially by connecting functions in a chaining manner.

• Not Implements

let result = double(square(increment(3))); // 3을 1 증가 -> 제곱 -> 두 배로
  console.log(result); // 32

• Implements

let result = 3
    |> increment
    |> square
    |> double;

  console.log(result); // 32

16. Logical Assignment Operators

These operators are a combination of logical operators and assignment operators, and process assignment and logical operations at once.

• Implements

let x = false;
  x ||= true; // x가 거짓일 때 true 할당 (결과: true)

  let y = null;
  y ??= 5; // y가 null 또는 undefined일 때 5 할당 (결과: 5)

Features

Number formatting

// 로케일 사용
Number('1000').toLocaleString('ko-KR'); // '1,000'

// 정규식 사용
'1000'.replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ","); // '1,000'

Sort

/**
Array.sort :
	return 0: 변경없음
	return -1: 비교대상중 a를 우선
	return 1: 비교대상중 b를 우선
*/


/*** 다중조건 정렬 Examples */
/** 정렬 수행 : 지연일 DESC */
objectList.sort((a, b) => {
    if (a.delayedDays > b.delayedDays) return -1;
    return 0;
});
/** 정렬 수행 : 작업자 미지정 우선 */
objectList.sort((a, b) => {
    if (a.delayedDays >= b.delayedDays && a.workerNm === "") return -1;
    return 0;
});
/** 정렬 수행 : 등록일 DESC */
objectList.sort((a, b) => {
    //비교대상 모두 workerNm이 없는 경우
    if (a.delayedDays >= b.delayedDays && a.workerNm === "" && b.workerNm === "" && a.createDt > b.createDt) return -1;
    //비교대상 모두 workerNm이 있는 경우
    if (a.delayedDays >= b.delayedDays && a.workerNm !== "" && b.workerNm !== "" && a.createDt > b.createDt) return -1;
    return 0;
});

Tools