알고리즘 치트시트 (1) - JS 자주 쓰이는 문법들

순회

map, forEach

• Index, Row 사용하는 순회
• Array전용 메소드
  • 다른 반복과 달리 continue/break 못씀
  • event loop를 통해 새로운 콜백을 넣으며 돌아가므로 Promise, async 동기 코드를 쓸 수 없음

// foreach : for(var i; i<nums.length; i++)를 선언하지 않아도 인덱스 활용 가능.
const nums=[1, 2, 3];
nums.forEach((x, index) => { if(index == 0) return; else num[index]*=num[index] });
console.log(nums); //[1, 4, 9]

// map : foreach와 같지만 return된 요소들을 배열로 반환해줌
const nums=[1,2,3];
const doubleNums = nums.map(x => x * 2);
console.log(doubleNums); //[2, 4, 6]

// 두 반복문은 row(약한복사)를 호출하여 call by reference 가능함
const nums=[1, 2, 3];
nums.forEach((n, index, row) => { row[0] = 0; });
console.log(nums); //[0, 2, 3]

 

for...in

• 모든 객체에 대해 key 반환 순회, iterate 범용 반복문
• key를 활용하는 Object에 어울림
• 다른 반복문과 달리 insertion 순서를 신경쓰지 않기 때문에 반복 도중 순서에 의해 누락되지 않는다.

// Object
const obj1 = {1:'a', 2:'b'}
for (let key in obj1) {
    console.log(key, "=>", obj1[key])
}

// String, Array
for (var i in "asd"){
	console.log(i) // 인덱스 0,1,2 반환
}
for (var i in ["a", "b", "c"]){
	console.log(i) // 인덱스 0,1,2 반환
}

 

for...of

• Value 반환 순회
• Array를 Promise, async 동기코드 작성시 주로 활용
• insertion을 기록하는 String, Array, Map, DOM컬렉션 등 모든 컬렉션이 쓰는 순회, insertion이 없는 Object는 못씀.

const str = "asd"
for (let c of str) {
    console.log(c, "=>", str[c]) // "a", "b", "c";
}

const str = ["a", "b", "c"]
for (let c of str) {
	if (c == "a") continue;
    console.log(c, "=>", str[c]) // "a", "c";
}

 

문자 처리 관련

/* 타입 변환 */
let n = 1234;
let arr = [...n.toString()]; // ['1','2','3','4']
let arr2= [..."1234"]; // ['1','2','3','4']

var result = arr.join(); // "1,2,3,4"
var result = arr.join(''); // "1234"
var result = Number(arr.join('')); // 1234

var word = "asdf asdf".split(' '); // ["asdf", "asdf"]
var word = {..."asdf asdf".split(' ')}; // {0: 'asdf', 1: 'asdf'}

/* 한 글자씩 순회 */
let word = "asdf asdf"
for (const c of word){...}

/* 아스키 */
"a".charCodeAt() // 97
String.fromCharCode('97') // 'a'

/* String 전용 정렬 우선순위 */
let a = "acd"
let b = "bcd"
a.localeCompare(b) // -1 (a가 b보다 우선순위에 있음)
b.localeCompare(a) // 1 (b가 a보다 후순위에 있음

/* 문자 삭제와 탐색 */
"...bcb.asd...".split(".").filter(v=>v!="").join(".");
"FIND_N_COUNT".split("N").length -1;

 

수 처리 관련

/* Math함수 */
Math.abs(n) // 절대값
Math.floor(a/b) // 몫
Math.sqrt(n) // 제곱근 (소수 판별시 활용)
Math.max(a,b) // 큰 값
Math.min(a,b) // 작은 값

/* 진법 변환 */
Number("31").toString(2) // "11111"
Number("31").toString(16) // "1f"
parseInt("11111",2) // 31

/* 비구조화 할당 */
var a = 7;
var b = 2;
[q,m] = [Math.floor(a/b), a%b]; // q=3, m=1

 

배열 처리 메소드

new Set(array)

• 중복 제거 배열

// set 객체는 iterable, unique한 배열
const duplicated = [1, 2, 3, 1, 2, 3];
const deduplicated = [...new Set(duplicated)];

 

slice, splice

• slice는 파이썬 슬라이스와 동일
• splice는 원본을 간섭, slice + split + concat

let arr = [0,1,2,3,4];
arr.slice(-1)[0]; // [4]
arr = arr.slice(0,-2); // [0,1,2]

arr = [0,1,2,3,4];
arr.splice(-2,2,'a'); // return [3,4]
console.log(arr); // [0,1,2,'a']

 

Object - Array - Map 자료형 변환과 value 기준 정렬

• Map : 삽입 순서를 기억하는 object

// array and object
var obj = {1:1, 2:2, 3:3};
var arr = Object.entries(obj); // [['1',1], ['2',2], ['3',3]]
var obj = Object.fromEntries(arr) // {1:1, 2:2, 3:3}

// array and map
let rate = [0.75, 0.5, 0.7]
let map = new Map();
rate.forEach((v,i) => map.set(i+1, v)); // {1=>0.75, 2=>0.5, 3=>0.7}

// sort with insertion number
var map_to_arr = [...map]; // [[1, 0.75], [2, 0.5], [3, 0.7]]
map_to_arr.sort((a,b) => b-a); // [[1, 0.75], [3, 0.7], [2, 0.5]]

 

filter

• 순회하며 true 반복된 요소 반환

const sourceArr = [0,1,2,3];
const evenArr = sourceArr.filter((element, index, row) => {
    if (index % 2 == 0) return true;
}); // [0, 2]

 

reduce

• temp 변수 하나 두고 반복하는 반복문을 편리하게 쓰기 위한 메소드.
  • 배열을 순회하며 합산하는 행위
  • 배열을 다른타입으로 변환하는 행위
  • 콜백함수 다음 initialValue를 입력하여 타입과 초기값을 선언

/* counting */
const sum = [1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array) {
  return accumulator + currentValue;
}); // sum = 10

const sum = [1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array) {
  return accumulator + currentValue;
}, 10); // sum = 20


/* counting with value, 배열타입은 타입초기화 필수 */
var sum = [{x: 1}, {x:2}, {x:3}].reduce(
    (accumulator, currentValue) => accumulator + currentValue.x
    , 0
);

/* array to dict, 배열타입은 타입초기화 필수 */
var dict = ['a','b','c'].reduce(
    (accumulator, currentValue) => {accumulator[currentValue] = 0; return accumulator}
    , {}
) // {'a':0, 'b':0, 'c':0}