์์ ์์
let myArray = [ 19, 44, 'good', 9 ]
console.log(myArray) [19 ,44 , 'good' , 9]
myArray[2] = 'bad'
console.log(myArray) [19 ,44 , 'bad' , 9]
์์ ์ถ๊ฐ
push : ๋ค์ ์์ ์ถ๊ฐ
my Array.push('kiwi')
console.log(myArray) [19 ,44 , 'bad' , 9, 'kiwi]
์์ ์ญ์
pop : ๋์์ ๋ถํฐ ํ๋์ฉ ์ญ์
myArray.pop()
shift : ์๋ถํฐ ํ๋์ฉ ์ญ์
๋ฐฐ์ด ์์ ๋ฐฐ์ด(์ค์ฒฉ๋ ๋ฐฐ์ด)
let myArray = [19, 44,'good',[100,200,500],false]
console.log(myArray[3]) [100, 200, 500]
console.log(myArray[3][0]) 100
slice
๋ฉ์๋๋ ๋ฐฐ์ด ๋ด์ ํน์ ํ ์์์ index ๋ฒ์์ ๋ฐ๋ผ ์๋ก์ด ๋ฐฐ์ด์ ๋ฆฌํดํ๋ค.
splice
๋ฉ์๋์๋ ๋ค๋ฅด๊ฒ slice
๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ๋ณํ์ํค์ง ์๋๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ด ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋๋ slice ๋ฉ์๋๋ฅผ ์ ์ฉํ ์๋ก์ด ๋ณ์๋ฅผ ์ ์ธํด์ฃผ์ด์ผ ํ๋ค.
์์ ๊ทธ๋ฆผ์์๋ ์ธ์ 2๊ฐ๊ฐ ๋ค์ด๊ฐ์ง๋ง, slice ๋ฉ์๋๋ ํ์์ ๋ฐ๋ผ ์ธ์๋ฅผ ์ต์ 1๊ฐ๋ง ์ธ ์๋ ์๋ค.
index์ ์์์
start
๋ฒ์งธ ๋ถํฐ ์ ๋ถ ๋ค ~ end
๋ฒ์งธ ์ ๊น์ง(end
๋ฒ์งธ ๊บผ๋ ๋นผ๊ณ )let nums = [1,2,3,4,5]
let nums_new = nums.slice(1,4)
console.log(nums) // [ 1, 2, 3, 4, 5 ]
console.log(nums_new) // [ 2, 3, 4 ]
nums ๋ฐฐ์ด์์, 1๋ฒ์งธ๋ถํฐ ์ ๋ถ ๋ค ~ 4๋ฒ์งธ ์ ๊น์ง(4๋ฒ์งธ ๊บผ๋ ๋นผ๊ณ )
์ธ์์ ์์๊ฐ ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ
let nums = [1,2,3,4,5]
let nums_new = nums.slice(-2)
โ
console.log(nums) // [ 1, 2, 3, 4, 5 ]
console.log(nums_new) // [ 4, 5 ]
์์๊ฐ ๋ค์ด๊ฐ ๊ฒฝ์ฐ ๋์์๋ถํฐ ํด๋นํ๋ ์ซ์ ๋งํผ
์ ์์๋ฅผ ๋ด์ ๋ฆฌํด(-2๋ฉด ๋์์ 2๊ฐ)
(
start
,end
) ์์,
๋ถํธ๊ฐ ๊ฐ์ ๋,start
๊ฐ์end
๋ณด๋ค ์์์ผ ํ๊ณ ,
๋ถํธ๊ฐ ๋ค๋ฅผ ๋๋start
๊ฐ์ด ์์์ฌ์ผ ๋ง์ด ๋จ.
Array ๊ฐ์ฅ์ ๊ฐํ 2 ๊บผ๋ด๊ธฐ
๋ฌธ์ )
let prisoners = [[0, 1],[1,2],[0,0]];
saveNumberTwo(prisoners) // 2
// slice ๋ฉ์๋์ ๊ดํธ ์์ ์์๋ง ๋ฃ๊ธฐ
// ๋ณ์ answer์ ํน์ ํ ๊ฐ์ ๋์
ํ๊ธฐ
let prisoners = [[0,1],[1,2],[0,0]];
function saveNumberTwo() {
let temp = prisoners.slice(-2,-1);
let answer;
answer = temp[0][1];
return answer;
}
saveNumberTwo(prisoners) ;
ํด๋ณด๋๊น, prisoners ๋ผ๋ ๋ฐฐ์ด์ ๋ง๋ค ๋, ํจ์ ์์์ ์ ์ธํ๋ฉด ์๋๋ ๊ฒ ํท๊ฐ๋ ธ๋ค.
splice
๋ฉ์๋๋ ๋ฐฐ์ด ๋ด์ํน์ ํ ์์๋ฅผ ์ญ์ ํ๊ฑฐ๋,๋ค๋ฅธ ์์๋ก ๋์นํ๊ฑฐ๋ ์๋ก์ด ์์๋ฅผ ์ถ๊ฐํ ๋ ์ฌ์ฉํ๋ค.
splice ๋ฉ์๋๋ฅผ ์ธ ๋๋์ธ์์ ์์์ ์ฃผ์ํด์ผ ํ๋ค.
์์ ๊ทธ๋ฆผ์์๋ ์ธ์ 3๊ฐ๊ฐ ๋ค์ด๊ฐ์ง๋ง, splice ๋ฉ์๋๋ ํ์์ ๋ฐ๋ผ ์ธ์๋ฅผ ์ต์ 1๊ฐ
๋ง ์ธ ์๋ ์๋ค.
ํ์
), ์์๊ฐ ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด ๋์์๋ถํฐ ๊ธธ์ด๋ฅผ ๋ํ๋ธ๋ค.
๊ฐ์
ex)
[1,2,3,4,5] ๋ผ๋ ์ด์์ ์ซ์ 3์ ์ ๊ฑฐํ๊ณ ๊ทธ ์๋ฆฌ์ 10์ ์ถ๊ฐํด์ฃผ์ธ์.
let num = [1,2,3,4,5];
num.splice(2,1,10);
console.log(num); // [ 1, 2, 10, 4, 5 ]
๋ณดํต ๋๊ธ ์ญ์ ๊ธฐ๋ฅ ๊ตฌํํ ๋ ๋ง์ด ์ฌ์ฉํ๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด์ for๋ฌธ์ ํ์ฉํด์ ์ฐ๋ ์์
for๋ฌธ์ ์ค๊ดํธ ์์๋ ๋ ๋ค๋ฅธ for๋ฌธ์ ์์ฑํ ์ ์์ต๋๋ค.
10 ์ด์์ ์ซ์๋ง ๋ฐฐ์ด์ ๋ด์ ๋ฆฌํดํ๋ ํจ์
let numBox = [[1,2,15,3],[4,5,6,10],[31,7,8,9,20]];
โ
function extractOverTen(list) {
let temp = [];
for(let i=0; i < list.length; i++) {
for(let j=0; j < list[i].length; j++) {
if(list[i][j] >= 10) {
temp.push(list[i][j]);
}
}
}
return temp;
}
โ
extractOverTen(numBox) // [ 15, 10, 31, 20 ]
i๊ฐ 0,1,2๋ก ์์ง์ผ๋, j๊ฐ ๊ฐ๊ฐ์ ๋ฐ๋ณต๋ฌธ ์์์ 0๋ถํฐ ์์ง์ธ๋ค. ๋ชจ๋ ์์๋ค์ ๋ฒํธ๋ฅผ ๋งค๊ฒจ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ
ex)
๋ฐ๊ตฌ๋์์ ๊ณฐํก์ด๋ฅผ ์ ๊ฑฐํ๋ ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
let basket = [['์ํ','๊ณฐํก์ด'],['๊ณฐํก์ด','๋นต','๋ธ๊ธฐ์ผ'],['๊ทค','๊ณฐํก์ด','์ฌ๊ณผ']];
let basket = [['์ํ','๊ณฐํก์ด'],['๊ณฐํก์ด','๋นต','๋ธ๊ธฐ์ผ'],['๊ทค','๊ณฐํก์ด','์ฌ๊ณผ']];
function removeGerm(arr) {
// ์ฌ๊ธฐ์ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์!
for(let i = 0; i< arr.length; i++){
for(let j = 0; j<arr[i].length; j++){
if(arr[i][j] === '๊ณฐํก์ด'){
arr[i].splice(j,1)
}
}
}
return arr
}
console.log(removeGerm(basket)); ///
>
[ [ '์ํ' ], [ '๋นต', '๋ธ๊ธฐ์ผ' ], [ '๊ทค', '์ฌ๊ณผ' ] ];
## includes()
๋ฌธ์์ด์ด ํน์ ๋ฌธ์์ด์ ํฌํจํ๋์ง ํ์ธ ํ๋ ๋ฉ์๋
`string.includes(searchString , length)`
- searchString : ๊ฒ์ํ ๋ฌธ์์ด(ํ์ ์์), ๋์๋ฌธ์ ๊ตฌ๋ถ
- length : ๊ฒ์์ `์์`ํ ์์น(์ ํ ์์), ๊ฐ์ด ์์ผ๋ฉด ์ ์ฒด ๋ฌธ์์ด ๋์
```java
ex)
'abzcd'.includes('z') true
'abzcd'.includes('z',2) true
'abzcd'.includes('z',3) false cd๊ฐ z๋ฅผ ํฌํจํ๋์ง ๊ฒ์ฌ
'abZcd'.includes('z',3) false
concat
๋ฉ์๋๋ ์ฃผ์ด์ง ๋ฐฐ์ด์ ๊ธฐ์กด ๋ฐฐ์ด์ ํฉ์ณ์ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค
์๋ณธ ๋ฐฐ์ด์ ๋ณํ์ง ์์ผ๋ฉฐ ์๋ก์ด ๋ฐฐ์ด์ด๋ ์๋ณธ ๋ฐฐ์ด์ ์์ ํด๋ ์๋ก ์ํฅ์ ๋ฐ์ง ์๋๋ค.
let alphabet = ['a', 'b', 'c'];
let hangeul = ['ใฑ', 'ใด', 'ใท'];
alphabet.concat(hangeul); // [ 'a', 'b', 'c', 'ใฑ', 'ใด', 'ใท' ]
๋ฐฐ์ด์ ๋ณ์์ ์ง์ ํด์ ์ธ์๋ฅผ ๋๊ฒจ์ค๋ค.
const alpha = ['a', 'b', 'c'];
1.
const arr = [1, [2, 3]];
alpha.concat(arr); // [ 'a', 'b', 'c', 1, [ 2, 3 ] ]
2.
alpha.concat(arr);
alpha.concat(1, [2, 3]); // [ 'a', 'b', 'c', 1, 2, 3 ]
3.
const numbers = [1, 2, 3];
const numbers2 = [3, 4, 5];
numbers.concat(numbers2); // [ 1, 2, 3, 3, 4, 5 ]
1
์ ๊ฒฝ์ฐ๋, ๋ฐฐ์ด์ ๋ณ์์ ์ง์ ํด์ ๋๊ฒจ์คฌ๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก ๋์ด๊ฐ๋ค.
2
์ ๊ฒฝ์ฐ๋, ํ๋ผ๋ฏธํฐ(์ธ์)์์ ๋ฐ๋ก ๋ฐฐ์ด์ ์์ฑํ๋๋ฐ, ์ด๋ฐ ๊ฒฝ์ฐ ๋ฐฐ์ด์์ ์์๋ค์ ๋ค ๊บผ๋ด์ ํฌํจ์ํค๊ฒ ๋๋ค.
3
์ ๊ฒฝ์ฐ์ฒ๋ผ ์ค๋ณต์ด ์์ด๋ ์๊ด์์ด ๋ค ๋์จ๋ค.
ex) num ๋ฐฐ์ด์์ ์์๋ค์ concat()์ ์ด์ฉํด์ ํ๋์ ๋ฐฐ์ด๋ก ํฉ์ณ์ง๊ฒ ํด์ฃผ์ธ์.
์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์์ผ ํฉ๋๋ค. (ํํธ: array์์ index๋ก ์ ๊ทผ)
[ 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
let num = [[11, 12, 13], [14, 15, 16], [17, 18, 19]];
function makeNewArr (a) {
return a[0].concat(a[1].concat(a[2]))
}
console.log(makeNewArr(num));
์ค๋ณต์ ๊ฑฐ ํ๋ ๋ฒ
[1, 2, 3, 4, 5, 3, 4, 5, 6, 7]
let eraseDuplicates = result.filter((el,index)=>
result.indexOf(el)===index);
console.log(eraseDuplicates);
[1, 2, 3, 4, 5, 6, 7]
๋ฐฐ์ด์์ ๊ฒ์ฌํ๊ณ ์๋ ๊ฐ(element)์ด ์ฒ์ ๋ฑ์ฅํ๋ index ๊ฐ
๊ณผ
๊ทธ ๊ฐ์ index ๊ฐ
๋น๊ต. ๋ ๋์จ ๊ฐ์ ๊ฐ์ ์ ๊ฒ ๋ค๋ฅด๋๊น ํํฐ๋ก ๊ฑธ๋ฌ์ง
ex)
ํ์คํ์ ํผ์์ ์ฌ๋ฃ๊ฐ ๋ฐฐ์ด๋ก ๋ํ๋์์ต๋๋ค. ์์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํด์ ์ค๋ณต๋ ์ฌ๋ฃ๋ฅผ ๋บ ์ ์ฒด ์ฌ๋ฃ์ ๋ฐฐ์ด ํ ๊ฐ๋ฅผ๋ง๋ค์ด์ฃผ์ธ์.
์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์์ผ ํฉ๋๋ค.
์ค๋ณต๋ ์ฌ๋ฃ๋ฅผ ๋บ ์ ์ฒด ์ฌ๋ฃ
[ 'tomato', 'basil', 'onion', 'chicken', 'cheese', 'olive', 'beef' ]
let pasta = ['tomato', 'basil', 'onion','chicken'];
let pizza = ['tomato', 'cheese', 'onion','olive','beef'];
function totalIngredients (a) {
return a.filter((element,index)=>a.indexOf(element)===index;
}
console.log(totalIngredients(pasta.concat(pizza)));
arr.indexOf(searchElement[,fromIndex])
๋ฐฐ์ด ์์์ ์ฐพ์ผ๋ ค๋ ๊ฐ(searchElement)์ ์ ํํ ์ผ์น(===)ํ๋
์ฒซ๋ฒ์งธ
element์ index๋ฅผ ๋ฆฌํดํ๋ค. ย
- fromIndex ์ ๋ ฅ ์ํ๋ฉด 0๋ถํฐ ๊ฒ์ํ๋ค.
- ์ฐพ์ผ๋ ค๋ ๊ฐ์ด ๋ฐฐ์ด์ ์์ผ๋ฉด -1์ ๋ฆฌํดํ๋ค.
['a','b','a','b']
arr.indexOf('a',1); // 2
์คํ ํ๋ก๋๋ฐ์ ํ๋ก๊ทธ๋๋ฐ์ผ๋ก ๋ฐ๊พธ์ด ์ฃผ๋ ์ฝ๋
let info = "JavaScript๋ ํ๋ก๋๋ฐ ์ธ์ด์ด๋ค.";
let firstChar = info.indexOf("ํ๋ก๋๋ฐ");
console.log(info, firstChar);
if (firstChar !== -1) {
info = info.slice(0, firstChar) + "ํ๋ก๊ทธ๋๋ฐ" + info.slice(firstChar+4, info.length);
}
console.log(info);
a๋ฅผ ๋ฐฐ์ด 1๋ฒ์งธ๋ถํฐ ์ฐพ์ผ๋ฉด ์ด๋์ ์๋?
๋ฐฐ์ด์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ []๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ๋ ์์ง๋ง, new Array() ๋ฉ์๋๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
console.log(new Array(4))
n๊ฐ์ ๊ณต๊ฐ์ ๊ฐ์ง ๋น ๋ฐฐ์ด
์ ๋ง๋ค๊ธฐ ์ํด์ ์ฐ๋ฆฌ๋new Array(n)
์ด๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. ์ด๋ ๊ฒ ๋ง๋ค์ด์ง ๋ฐฐ์ด์ ๋น ๋ฐฐ์ด์ด๊ณ ์์ ์์๋ฅผ ํฌํจํ๊ณ ์์ง ์์ง๋ง, ๊ณต๊ฐ์ ๋ง๋ค์ด์ฃผ์๊ธฐ ๋๋ฌธ์arr.length
๋ฅผ ์ฝ์์ฐฝ์ ์ฐ์ด๋ณด๋ฉด 4๊ฐ ๋์ฌ ๊ฒ์ ๋๋ค.
๋น ๋ฐฐ์ด์ ๊ฐ์ ํ ๋นํ๋ ค๋ฉด ๋ฐ๋ณต๋ฌธ์ ์ด์ฉ
let arr = new Array(4); for(let i=0; i< arr.length ; i++) { arr[i] = i+1 } console.log(arr) // [ 1, 2, 3, 4 ]
push() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ *๋ฐฐ์ด์ ๋์ ํ๋ ์ด์์ ์์๋ฅผ ์ถ๊ฐ
ํ ์ ์๋ค.
let arr = [1,2,3];
arr.push(4);
// arr is now [1,2,3,4]
push()๋ ๊ฐ์๋ฐ, ๋ฐฐ์ด์ ๋งจ ์๋ถ๋ถ์ ์ถ๊ฐ
ํ๋ค.
pop() ๋ฉ์๋๋ ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๋ฉฐ ์ ๊ฑฐ๋ ์์
๋ฅผ ๋ฐํํ๋ค.
let threeArr = [1, 4, 6];
let oneDown = threeArr.pop();
console.log(oneDown); // Returns 6
console.log(threeArr); // Returns [1, 4]
shift() ๋ฉ์๋๋ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์์๋ฅผ ์ ๊ฑฐํ๋ฉฐ ์ ๊ฑฐ๋ ์์
๋ฅผ ๋ฐํํ๋ค.
pop() , shift() ๋๋ค. ์ฒ์ ๋ฐฐ์ด์ ๋ฐ๊พธ๋ ๊ฑฐ๋ผ์, ์ฒ์ ๋ฐฐ์ด์ ๋ค์ ๋ถ๋ฌ์ค๋ฉด ์์๊ฐ ์ ๊ฑฐ๋์ด ์๋ค.
๊ทธ๋ฆฌ๊ณ .pop() ์ด๋ .shift() ์ํ๋ก ๊ทธ๋ฅ ๋ถ๋ฌ์ค๋ฉด ์ ๊ฑฐ๋ ์์๊ฐ ๋ฐํ๋จ.
join() ๋ฉ์๋๋ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ฐ๊ฒฐํด ํ๋์ ๋ฌธ์์ด๋ก ๋ง๋ ๋ค.
separator๋ ๋งค๊ฐ๋ณ์๋ก, ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ๊ตฌ๋ถํ ๋ฌธ์์ด์ด๋ค.
์ด ๊ตฌ๋ถ์๋ ํ์ํ ๊ฒฝ์ฐ ๋ฌธ์์ด๋ก ๋ณํ๋๊ณ , ์๋ตํ๋ฉด ๋ฐฐ์ด์ ์์๋ค์ ์ผํ๋ก ๊ตฌ๋ถ๋๋ค.
const arr = ['๋ฐ๋', '๋น', '๋ฌผ'];
console.log(arr.join());
// ๋ฐ๋,๋น,๋ฌผ
console.log(arr.join(''));
// ๋ฐ๋๋น๋ฌผ
console.log(arr.join('-'));
// ๋ฐ๋-๋น-๋ฌผ
๋ฌธ์ํ๋ง ๊ฐ๋ฅ.
Array.from('Tei');
//["T", "e", "i"]
Array.from('123');
//["1", "2", "3"]
sort๋ ์ ๋ ฌ ์์๋ฅผ ์ ์ํ๋ ํจ์์ธ๋ฐ, ๊ทธ ์๋ฆฌ๊ฐ a,b ๋๊ฐ์ element๋ฅผ ์ ๋ ฅ๋ฐ์์ ์ ์์ compareFunction ์ด ๋ฆฌํดํ๋ ๊ฐ์ด 0๋ณด๋ค ํฐ์ง ์์์ง์ ๋ฐ๋ผ ์์๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ํจ์
์ซ์๋ฅผ string ์ผ๋ก ๋ด์, ๊ทธ๋ฅ array.sort()ํ๋ฉด ์ซ์๋ฅผ ์ ๋๋ก ์ ๋ ฌ ๋ชปํด์ค๋ค.
๊ฐ๋จํ๊ฒ, a,b ์์ ๋. ํจ์ ๋ฆฌํด๊ฐ์ด 0๋ณด๋ค ํฌ๋ฉด b๊ฐ ์ ์์ผ๋ฉด a๊ฐ ์ 0์ผ๋ ๊ทธ๋๋ก
๊ทธ๋์ ์ฐ๋ฆฌ๋ ์ซ์ ๋น๊ต ํ๋ ค๊ณ ,
์ฌ๊ธฐ์์ ํจ์์ธ compareFunction์ ๋ฆฌํด๊ฐ์ ๊ฐ์ ๋ก ์ปค์คํ
ํด์ ๋ง๋ค์ด์ค์ ๊ทธ ๋ฆฌํด๊ฐ์ 0๊ณผ ๋น๊ตํ๊ฒ ๋ง๋ค์ด ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ ์ ํ๋ ์๋ฆฌ
callback ํจ์ : ์ธ์๋ก ์ ๋ฌ๋๋ ํจ์๋ฅผ ๋งํจ
arrow function ์ด ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ๊ฐ ์ด ํจ์ ์ธ ๋ ์ด๋ค.
arrow function์ ์กฐ๊ธ ๋ ์ฐ์ตํ๊ธฐ ์ํด array์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ฌ์ฉ๋๋ map, forEach ๋ฉ์๋๋ฅผ ํจ๊ป ๋ณด์.
map ๋ฉ์๋๋
๋ฐฐ์ด์ ๋ฐ๋ณต
ํด์ค๋ค.
callback ํจ์๋ฅผ ์คํํ๊ณ ,returnํ ๊ฐ์ผ๋ก ๋งค(each) ์์๋ฅผ ์์
ํด ์ค๋ค.
map ๋ฉ์๋์ return ๊ฐ์
์์ ๋ ๊ฐ์ผ๋ก ๋ค์ ์์ฑ๋ ๋ฐฐ์ด
์ด๋ค.
const arr = [0,1,2,3];
let squaredArr = arr.map(function(element){
return element * element;
});
// ํน์ arrow ํจ์ ๊ฐ๋ฅ
let squaredArr = arr.map(element => element * element);
console.log(squaredArr); // [ 0, 1, 4, 9 ]
์ข ์ด๋ ต๊ณ ์ค์ํ ์์ )
const arr = [0,1,2,3];
let squaredArr = arr.map(function(element, index, array){
console.log(`${array}์ ${index}๋ฒ์งธ ์ธ์ : ${element}`);
return element * element; }
);
// arr.map์, arr ๋ฐฐ์ด ์์ ํ๋ํ๋๋ก map์์ ์๋ ํจ์๋ฅผ ๋๋ค. ํจ์ ์์ ๋ด์ฉ์ ์คํ์ํค๊ณ ,
// ๋ฆฌํด์ผ๋ก ์ฐ์ธ ๊ฐ๋ค์ ํ๋ํ๋ ๋ค์ ๋์ง์ด๋ด์ ์ ๋ฐฐ์ด์ ๋ง๋ฌ.
0,1,2,3์ 0๋ฒ์งธ ์ธ์ : 0
0,1,2,3์ 1๋ฒ์งธ ์ธ์ : 1
0,1,2,3์ 2๋ฒ์งธ ์ธ์ : 2
0,1,2,3์ 3๋ฒ์งธ ์ธ์ : 3
console.log(squaredArr); // [ 0, 1, 4, 9 ]
const moreThan100 = nums => {
let a = nums.map(el => {
if(el >= 100){
return true;
}else{
return false;
}
});
return a ;
}
let nums = [100, 9, 30, 7];
console.log(moreThan100(nums)); // [true, false, false, false];
// morethan100 ์ด๋ผ๋ ํจ์๋, ๋ฐฐ์ด์ ์ธ์๋ก ๋ฐ๋๋ค.
// ๊ทธ ๋ฐฐ์ด์ map์ ๊ฑธ์ด์, ๋ฆฌํด์ผ๋ก ์๋ก๋ง๋ค์ด์ง ๋ฐฐ์ด ๊ฐ์ a ๋ผ๊ณ ํ๋ค.
// ์ด ํจ์๋ a๋ฅผ ๋ฆฌํดํ๋ค.
split ์ด๋ map ํ์ฉ ์ค์ํ ์์ !!
const formatDate = dates => {
let a = dates.map(el => {
let spt = el.split('-');
return `${spt[0]}๋
${spt[1]}์ ${spt[2]}์ผ`;
});
return a;
}
let pp = ['2019-03-21', '2019-04-21', '2019-05-21'];
console.log(formatDate(pp));
//['2019๋
03์ 21์ผ', '2019๋
04์ 21์ผ', '2019๋
05์ 21์ผ']
forEach
๋ for๋ฌธ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ๋ณต์ ์ธ ๊ธฐ๋ฅ์ ์ํํ ๋ ์ฌ์ฉํ๋ค.
ํ์ง๋ง for๋ฌธ์ฒ๋ผ index์ ์กฐ๊ฑด์, increase๋ฅผ ์ ์ํ์ง ์์๋ callback ํจ์๋ฅผ ํตํด ๊ธฐ๋ฅ์ ์ํํ ์ ์์
arr ๊ฐ์ฒด์ ๋ชจ๋ ์์๋ค์ด callback ํจ์์ ์์๋๋ก ํธ์ถ๋๋ค.
for๋ฌธ์ ๋นํด ์ข ๋ ๊น๋ํ๊ณ , ์ง๊ด์ ์ ๋๋ค.
const arr = [0,1,2,3,4,5,6,7,8,9,10];
arr.forEach(function(element){
console.log(element); // 0 1 2 3 4 5 6 7 8 9 10 ๊ฐ ์ฐจ๋ก๋๋ก ํ๋์ฉ ์ฐํ
});
// ํน์ arrow ํจ์ ๊ฐ๋ฅ
arr.forEach(element => console.log(element));
foreach() ํจ์๋ ๋ฆฌํด๊ฐ์ด ์๋ค.( map์ฒ๋ผ ๊ทธ ์์ฒด๋ก ์ฐ์์ ๋, ๊ฒฐ๊ณผ๋ก ๋์ค๋๊ฒ ์์.)
๊ทธ๋์, ๊ฒฐ๊ณผ๋ก ๋ญ๊ฐ ๋์ค๊ฒ ํ๊ณ ์ถ์ผ๋ฉด ๋ฐ์ ์ฒ๋ผ ํจ์ ๋ฐ์ ๋ณ์๋ฅผ ์ค์ ํด๋์ผ ํ๋ค.
forEach()
๊ฐ๋ฐฐ์ด ์์๋ง๋ค ํ ๋ฒ์ฉ ์ฃผ์ด์ง ํจ์(์ฝ๋ฐฑ)๋ฅผ ์คํํ๋ ๊ฒ
๊ณผ ๋ฌ๋ฆฌ,
map()
์๋ฐฐ์ด ๋ด์ ๋ชจ๋ ์์ ๊ฐ๊ฐ์ ๋ํ์ฌ ์ฃผ์ด์ง ํจ์(์ฝ๋ฐฑ)๋ฅผ ํธ์ถํ ๊ฒฐ๊ณผ๋ฅผ ๋ชจ์,
์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ
ํ๋ค๋ ํน์ง์ ๊ฐ์ง๊ณ ์๋ค.
const arr = [0,1,2,3,4,5,6,7,8,9,10];
const oddArray = [];
arr.forEach(function(element){
if(element%2==1) {
oddArray.push(element);
}
});
console.log(oddArray); // [ 1, 3, 5, 7, 9 ]
foreach() ํจ์ ๋ฐ๋ณต์์ ํ์ถํ๊ณ ์ถ์ ๋, return; ํด์ฃผ๋ฉด ๋๋ค.
let hasC = false;
let arr = ['a', 'b', 'c', 'd'];
arr.forEach(el => {
if (el === 'c') {
hasC = true;
return;
}
});
map()ํจ์๋ ๋ง์ฐฌ๊ฐ์ง๋ก,forEach์ callback ํจ์์๋ ๋ฐฐ์ด์ ์์
๋ฟ๋ง์๋๋ผ index
, ์ ์ฒด ๋ฐฐ์ด
์ ์ธ์๋ก ์ฌ์ฉํ ์ ์๋ค.
arr.forEach(function(element, index, array){
console.log(`${array}์ ${index}๋ฒ์งธ ์์ : ${element}`);
});
/*
0,1,2,3,4,5,6,7,8,9,10์ 0๋ฒ์งธ ์์ : 0
0,1,2,3,4,5,6,7,8,9,10์ 1๋ฒ์งธ ์์ : 1
0,1,2,3,4,5,6,7,8,9,10์ 2๋ฒ์งธ ์์ : 2
0,1,2,3,4,5,6,7,8,9,10์ 3๋ฒ์งธ ์์ : 3
0,1,2,3,4,5,6,7,8,9,10์ 4๋ฒ์งธ ์์ : 4
0,1,2,3,4,5,6,7,8,9,10์ 5๋ฒ์งธ ์์ : 5
0,1,2,3,4,5,6,7,8,9,10์ 6๋ฒ์งธ ์์ : 6
0,1,2,3,4,5,6,7,8,9,10์ 7๋ฒ์งธ ์์ : 7
0,1,2,3,4,5,6,7,8,9,10์ 8๋ฒ์งธ ์์ : 8
0,1,2,3,4,5,6,7,8,9,10์ 9๋ฒ์งธ ์์ : 9
0,1,2,3,4,5,6,7,8,9,10์ 10๋ฒ์งธ ์์ : 10
*/
arr.filter(callback(element[, index[, array]])[, thisArg])
filter()
๋ฉ์๋๋ array ๊ด๋ จ ๋ฉ์๋๋ก ์กฐ๊ฑด์ ๋ง๋ ์์๋ค๋ง ๋ชจ์์ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ
ํ๋ค.
๋ง์ฝ ์กฐ๊ฑด์ ๋ถํฉ๋๋ ์์๊ฐ ์๋ฌด๊ฒ๋ ์๋ค๋ฉด ๋น ๋ฐฐ์ด์ ๋ฐํ
ํ๋ค.
filter()
๋ฉ์๋๋ map() ๋ฉ์๋์ ๋ง์ฐฌ๊ฐ์ง๋ก ํฌ๊ฒ filter(callbackFunction, thisAgr) 2๊ฐ์ ์ธ์๋ฅผ ๊ฐ์ง๋ค.
๊ทธ๋ฆฌ๊ณ callbackFunction ์์์ 3๊ฐ์ ์ธ์ (element, index, array) ๋ฅผ ๊ฐ์ง๋๋ฐ
์ฒซ๋ฒ์งธ ๋ถ๋ถ์ธ element
์ธ์๋ง ํ์๋ก ์ง์ ๋์ด์ผ ํ๊ณ ๋๋จธ์ง๋ ์ ํ์ ์ด๋ค.
value > 10 ์ด๋ผ๋ ์กฐ๊ฑด์ ๋ง๋ ์์๋ค๋ก๋ง ์ด๋ฃจ์ด์ง ์๋ก์ด ๋ฐฐ์ด์ด ์๊ฒผ๋ค.
let numbers = [10, 4, 32, 17, 5, 2];
โ
// ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ (filter()์ ์ธ์์์ ๋ฐ๋ก ํจ์๋ฅผ ์จ์ฃผ๋ ๋ฐฉ๋ฒ)
let result = numbers.filter(value=> value > 10);
โ
console.log(result); // [ 32, 17 ]
โ
// ๋๋ฒ์งธ ๋ฐฉ๋ฒ (๋ฐ์์ ํจ์๋ฅผ ์ ์ธํ๊ณ filter()์ธ์์์ callbackํ๋ ๋ฐฉ๋ฒ)
function isBiggerThanTen (value) {
return value > 10;
}
โ
let result = numbers.filter(isBiggerThanTen);
โ
console.log(result); // [ 32, 17 ]
ex)
fruits ๋ผ๋ ๋ฐฐ์ด์ด ์์ต๋๋ค.
'ap'๊ฐ ๋ค์ด๊ฐ ๊ณผ์ผ๋ค๋ก ์ด๋ฃจ์ด์ง ์๋ก์ด ๋ฐฐ์ด์ filter()๋ฅผ ์ด์ฉํ์ฌ ๋ฐํํด์ฃผ์ธ์.
๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์์ผ ํฉ๋๋ค.
[ 'apple', 'grapes' ]
ํํธ : includes()๋ฅผ ์ฌ์ฉํด๋ณด์ธ์.
function filtered (value) {
return value.includes('ap');
}
let result = fruits.filter(filtered);
console.log(result);
ex2)
courses ๋ผ๋ ๋ฐฐ์ด์ด ์์ต๋๋ค. level์ด 'hard'์ธ ๊ณผ๋ชฉ๋ค๋ก๋ง ์ด๋ฃจ์ด์ง ์๋ก์ด ๋ฐฐ์ด์ filter()๋ฅผ ์ด์ฉํ์ฌ ๋ฐํํด์ฃผ์ธ์.๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์์ผ ํฉ๋๋ค.
[
{ level: 'hard', subject: 'Mathmatic' },
{ level: 'hard', subject: 'Science' }
]
function filtered(value) {
return value.level === 'hard';
}
let a = courses.filter(filtered);
console.log(a);