Array.from
- Array.from() 메서드는 유사 배열 객체(array-like object)나 반복 가능한 객체(iterable object)를 얕게 복사해 새로운Array 객체를 만듭니다.
Array.from(arrayLike[, mapFn[, thisArg]])
//배열로 변환하고자 하는유사 배열 객체나 반복 가능한 객체.
//배열의 모든 요소에 대해 호출할 맵핑 함수.
//mapFn 실행 시에 this로 사용할 값.
console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]
console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]
const m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]
const mapper = new Map([['1', 'a'], ['2', 'b']]);
Array.from(mapper.values());
// ['a', 'b'];
Array.from(mapper.keys());
// ['1', '2'];
// Using an arrow function as the map function to
// manipulate the elements
Array.from([1, 2, 3], x => x + x);
// [2, 4, 6]
// Generate a sequence of numbers
// Since the array is initialized with `undefined` on each position,
// the value of `v` below will be `undefined`
Array.from({length: 5}, (v, i) => i);
// [0, 1, 2, 3, 4]
// Sequence generator function (commonly referred to as "range", e.g. Clojure, PHP etc)
const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));
// Generate numbers range 0..4
range(0, 4, 1);
// [0, 1, 2, 3, 4]
// Generate numbers range 1..10 with step of 2
range(1, 10, 2);
// [1, 3, 5, 7, 9]
// Generate the alphabet using Array.from making use of it being ordered as a sequence
range('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x));
// ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
2차원 배열
- Array.from()
// arr[5][2] (빈 배열 생성)
const arr1 = Array.from(Array(5), () => new Array(2)
// arr[5][2] (null로 초기화하여 생성)
const arr2 = Array.from(Array(5), () => Array(2).fill(null))
- 함수
function create2DArray(rows, columns) {
var arr = new Array(rows);
for (var i = 0; i < rows; i++) {
arr[i] = new Array(columns);
}
return arr;
}
// arr[5][2]
var arr = create2DArray(5, 2);
- 반복문
// arr[5][2]
var arr = new Array(5);
for (var i = 0; i < arr.length; i++) {
arr[i] = new Array(2);
}
for in, for of, forEach
-
for in : 객체의 프로퍼티 키 열거 전용
-
for of : 이터러블 순회 전용
-
forEach(): 배열 순회 전용 메서드
for in
- for in 문: 객체의 프로퍼티 키 열거 전용
for(const key in 객체){...반복 수행 코드...}
- (주의)해당 객체가 상속받는 프로토타입 체인상의 모든 프로퍼티 키를 열거한다.(단, [[Enumerable]] 값이 false인 프로퍼티는 제외)
const obj = {
name: 'curryyou',
job: 'engineer'
}
for (const key in obj){
console.log(`${key} : ${obj[key]}`);
}
// name : curryyou
// job : engineer
for of
- for of 문: 이터러블 순회 전용
for(const item of 이터러블){...반복 수행 코드...}
const arr = [10, 20, 30];
for (const item of arr){
console.log(item); // 10, 20, 30 출력
}
- (참고) 이터러블에는 String, Array, Map, Set, DOM컬렉션(HTMLColletion, NodeList) 등이 있다.
forEach
- forEach(): 배열 순회 전용 메서드
배열.forEach( function(value, index, array){...반복 수행 코드...} )
- 콜백함수의 매개변수로 value에 요소값, index에 인덱스, array에 원본 배열이 들어온다.
[10, 20, 30].forEach((value, index, array)=>{
console.log(`${index} : ${value}`); // 0 : 10, 1 : 20, 2: 30 출력
})
배열 정렬
-
ASCII 문자 순서로 정렬되어 숫자의 크기대로 나오지 않는다.
-
아래와 같은 방법을 사용하면 원하는 결과를 얻을 수 있습니다.
[1,10,2,20,3,4,5].sort(function(a, b) { return a - b; }); // [1,2,3,4,5,10,20]
- 내림차순으로 정렬하고 싶은 경우는 아래와 같이 코드를 작성합니다.
[1,10,2,20,3,4,5].sort(function(a, b) { return b - a; }); // [1,2,3,4,5,10,20]
객체 정렬
var items = [
{ name: 'Edward', value: 21 },
{ name: 'Sharpe', value: 37 },
{ name: 'And', value: 45 },
{ name: 'The', value: -12 },
{ name: 'Magnetic', value: 13 },
{ name: 'Zeros', value: 37 }
];
// value 기준으로 정렬
items.sort(function (a, b) {
if (a.value > b.value) {
return 1;
}
if (a.value < b.value) {
return -1;
}
// a must be equal to b
return 0;
});
// name 기준으로 정렬 - 오름차순
items.sort(function(a, b) {
var nameA = a.name.toUpperCase(); // ignore upper and lowercase
var nameB = b.name.toUpperCase(); // ignore upper and lowercase
if (nameA < nameB) {
return -1;
}
if (nameA > nameB) {
return 1;
}
// 이름이 같을 경우
return 0;
});
배열이나 문자열에서 중복을 제거할 때
// 배열
const arr = [1,3,2,4,3,1,5,6,2,1];
const newArr = [...new Set(arr)];
console.log(newArr); // [1,3,2,4,5,6] 중복이 제거된 배열을 얻을 수 있다.
// 문자열
const str = "abcdacbe";
const newStr = [...new Set(str)].join('');
console.log(newStr); // "abcde" 중복이 제거된 문자열을 얻을 수 있다.
배열이나 문자열에서 유니크한 원소 뽑아내기
- filter 메소드를 활용해 유니크한 값을 뽑아낼 수 있다.
const arr = [1,1,4,1,1]
arr.filter( el => arr.indexOf(el) === arr.lastIndexOf(el) ) // [4]
//문자열에서도 마찬가지로 split 후 filter를 사용하면 같은 결과를 얻을 수 있다.
const str = '11411'
str.split('').filter( el => str.indexOf(el) === str.lastIndexOf(el) ) // ['4']
- 배열로 결과값을 리턴하기 때문에 문자열을 원하면 toString()을 뒤에 붙여주면 되고, 넘버타입을 원하면 Number()로 감싸주면 된다.
배열이나 문자열에서 i 번째 인덱스 내용을 삭제하고 싶을 때
- 원본을 보존하면서 잘라내는 방법
const arr = [1,2,3,4,5];
const newArr1 = [...arr.slice(0,2), ...arr.slice(3)]; // 2번 인덱스 삭제
console.log(newArr1); // [1,2,4,5]
console.log(arr); // [1,2,3,4,5]
- 원본을 훼손하며 잘라내는 방법
const arr = [1,2,3,4,5];
arr.splice(2,1); // 2번 인덱스부터 1개를 삭제하겠다는 의미
console.log(arr); // [1,2,4,5]
배열에 규칙적인 연속된 값 할당하기
Array(5).fill(1) // [1,1,1,1,1]
Array(5).fill(1).map( (el,i) => el+i ) // [1,2,3,4,5]
형변환 ( 문자 > 숫자, 숫자 > 문자 )
// 문자를 숫자로 변환
const str = '1234'
const strToNum = +str
console.log(strToNum) // 1234
// 숫자를 문자로 변환
const num = 1234
const numToStr = ''+num
console.log(numToStr) // '1234'
배열에서 조합 구하기
function getAllCombinations(arr, m) {
const combinations = [];
const picked = [];
const used = []; //중복되는 조합이 거듭 combinations에 추가되는 것을 막기 위해 사용
for (item of arr) used.push(0);
function find(picked) {
if (picked.length === m) { //종료 조건
const rst = [];
for (let i of picked) {
rst.push(arr[i]);
}
combinations.push(rst);
return;
} else {
//picked에 이미 인덱스가 있다면 그 인덱스보다 1 큰 수를, 없다면 0
let start = picked.length ? picked[picked.length-1] + 1 : 0;
for (let i = start; i < arr.length; i++) {
//used[i-1]이 이미 뽑혀서 1인 경우, i를 뽑는다.
if (i === 0 || arr[i] !== arr[i-1] || used[i-1]) {
picked.push(i);
used[i] = 1;
find(picked);
picked.pop();
used[i] = 0;
}
}
}
}
find(picked);
return combinations;
}
- 간단한 버전
function combination(arr, selectNum) {
const result = [];
if (selectNum === 1) return arr.map((v) => [v]);
arr.forEach((v, idx, arr) => {
const fixed = v;
const restArr = arr.slice(idx + 1);
const combinationArr = combination(restArr, selectNum - 1);
const combineFix = combinationArr.map((v) => [fixed, ...v]);
result.push(...combineFix);
});
return result;
}
- 더 간단한 버전
let answer = [];
const dfs = (nums, num, arr = []) => {
//3개를 선택한다는가정에 3개가 선택 됐다면 출력
if (num === 3) answer.push([...arr]);
else {
for (let i = 0; i < nums.length; i++) {
arr.push(nums[i]);
dfs(nums.slice(i + 1), num + 1, arr);
arr.pop();
}
}
};
dfs([1, 2, 3, 4], 0);
console.log(answer); //[ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ]
배열에서 순열 구하기
function permutation(arr, selectNum) {
let result = [];
if (selectNum === 1) return arr.map((v) => [v]);
arr.forEach((v, idx, arr) => {
const fixer = v; //1
const restArr = arr.filter((_, index) => index !== idx); // [2,3,4]
const permuationArr = permutation(restArr, selectNum - 1); // [[2],[3],[4]]
const combineFixer = permuationArr.map((v) => [fixer, ...v]); //[[1,2],[1,3],[1,4]]
result.push(...combineFixer);
});
return result;
}
배열에서 중복 순열 구하기
function permutation(arr, selectNum) {
const result = [];
if (selectNum === 1) return arr.map((v) => [v]);
arr.forEach((v, idx, arr) => {
const fixed = v;
const restArr = arr;
const permutationArr = permutation(restArr, selectNum - 1);
const combineFix = permutationArr.map((v) => [fixed, ...v]);
result.push(...combineFix);
});
return result;
}
For the sake of someone who studies computer science