JavaScript 에서 모 르 는 배열 방법 들

concat

var a = [1,2,3];
a.concat([4,5,6],7,8);//[1,2,3,4,5,6,7,8]

주의 하 세 요.a 배열 은 변 하지 않 았 습 니 다.새 배열 로 돌 아 왔 을 뿐 입 니 다.
copyWithin
그것 은 세 개의 인 자 를 받아들인다.
target(필수):이 위치 에서 데 이 터 를 교체 합 니 다.
start(선택 가능):이 위치 에서 데 이 터 를 읽 기 시작 합 니 다.기본 값 은 0 입 니 다.만약 마이너스 라면,역 수 를 나타 낸다.
end(선택 가능):이 위치 에 도착 하기 전에 데 이 터 를 읽 는 것 을 중단 합 니 다.기본 값 은 배열 길이 와 같 습 니 다.만약 마이너스 라면,역 수 를 나타 낸다.
이 세 개의 매개 변 수 는 모두 수치 여야 하 며,그렇지 않 으 면 자동 으로 수치 로 전 환 됩 니 다.

//   3       0    
[1, 2, 3, 4, 5].copyWithin(0, 3, 4) 
// [4, 2, 3, 4, 5] 
// -2     3   ， -1     4    
[1, 2, 3, 4, 5].copyWithin(0, -2, -1) 
// [4, 2, 3, 4, 5] 
//   3       0    
[].copyWithin.call({length: 5, 3: 1}, 0, 3) 
// {0: 1, 3: 1, length: 5} 
//   2        ，    0    
var i32a = new Int32Array([1, 2, 3, 4, 5]); 
i32a.copyWithin(0, 2); 
// Int32Array [3, 4, 5, 4, 5] 
//        TypedArray   copyWithin       
//           
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); 
// Int32Array [4, 2, 3, 4, 5] 

entries

var a = [1,2,3];
var en = a.entries();
en.next().value;//[0.1];

교체 대상 되 돌리 기
every

function isBigEnough(element, index, array) {
 return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

모든 항목 은 테스트 함 수 를 통 해 true 로 돌아 갑 니 다.그렇지 않 으 면 false 로 돌아 갑 니 다.
fill

[1, 2, 3].fill(4)   // [4, 4, 4]
[1, 2, 3].fill(4, 1)   // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2)  // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1)  // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2) // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN) // [1, 2, 3]
Array(3).fill(4);   // [4, 4, 4]
[].fill.call({length: 3}, 4) // {0: 4, 1: 4, 2: 4, length: 3}

배열 자체 가 바 뀌 었 습 니 다.
filter

function isBigEnough(value) {
 return value >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

새 배열 로 돌아 가기
find
방법 은 배열 에서 제공 하 는 테스트 함수 의 첫 번 째 요 소 를 만족 시 키 는 값 을 되 돌려 줍 니 다.그렇지 않 으 면 undefind 로 돌아 갑 니 다.

function isBigEnough(element) {
 return element >= 15;
}
[12, 5, 8, 130, 44].find(isBigEnough); // 130

findIndex
findIndex()방법 은 배열 에서 제공 하 는 테스트 함수 의 첫 번 째 요 소 를 만족 시 키 는 색인 을 되 돌려 줍 니 다.그렇지 않 으 면 돌아 갑 니 다.-1.

function isBigEnough(element) {
 return element >= 15;
}
[12, 5, 8, 130, 44].findIndex(isBigEnough); // 3

forEach

let a = ['a', 'b', 'c'];
a.forEach(function(element) {
 console.log(element);
});
// a
// b
// c
//  
array.forEach(callback(currentValue, index, array){
 //do something
}, this)
array.forEach(callback[, thisArg])

callback

             ，         ：
currentValue(   )
            。
index(  )
               。
array
forEach()         。
thisArg  
    。           this  (    )

주의:foreach 순환 을 중단 하거나 뛰 어 내 릴 방법 이 없습니다.이상 을 던 지 는 것 을 제외 하고.만약 당신 이 이렇게 필요 하 다 면,foreach()방법 을 사용 하 는 것 은 잘못된 것 입 니 다.간단 한 순환 으로 대체 할 수 있 습 니 다.한 배열 의 요소 가 어떤 조건 에 부합 되 는 지 테스트 하고 있 으 며,불 값 을 되 돌려 야 한다 면,Array.every,Array.some 를 사용 할 수 있 습 니 다.사용 가능 하 다 면 새로운 방법 find()나 findIndex()도 진가 테스트 의 조기 종료 에 사용 할 수 있 습 니 다.
include

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

매개 변수
searchElement
찾 아야 할 요소 값 입 니 다.
fromIndex
선택 가능
이 색인 에서 searchElement 찾기 시작 합 니 다.
。마이너스 라면 array.length+from Index 의 색인 에서 오름차 순 으로 검색 합 니 다.기본 값 은 0 입 니 다.
반환 값
불 린 하나.

[1, 2, 3].includes(2);  // true
[1, 2, 3].includes(4);  // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

indexOf

arr.indexOf(searchElement)
arr.indexOf(searchElement[, fromIndex = 0])

매개 변수
searchElement
찾 을 요소
fromIndex
찾기 시작 한 위치.이 색인 값 이 배열 의 길이 보다 크 거나 같 으 면 배열 에서 찾 지 않 고-1 로 돌아 가 는 것 을 의미 합 니 다.만약 에 매개 변수 에서 제공 하 는 색인 값 이 마이너스 라면 이 를 배열 끝의 상쇄 로 한다.즉,-1 은 마지막 요소 부터 찾 는 것 을 나타 내 고-2 는 마지막 두 번 째 요소 부터 찾 는 것 을 나타 낸다.메모:매개 변수 에서 제공 하 는 색인 값 이 마이너스 라면 이전 뒤로 배열 을 조회 합 니 다.상쇄 된 색인 값 이 0 보다 적 으 면 전체 배열 이 조 회 됩 니 다.기본 값 은 0 입 니 다.
반환 값
첫 번 째 찾 은 요소 가 배열 에 있 는 색인 위치;찾 지 못 하면 되 돌리 기-1

let a = [2, 9, 7, 8, 9]; 
a.indexOf(2); // 0 
a.indexOf(6); // -1
a.indexOf(7); // 2
a.indexOf(8); // 3
a.indexOf(9); // 1
if (a.indexOf(3) === -1) {
 // element doesn't exist in array
}

join

str = arr.join()
//     ","
str = arr.join("")
//     ===      ""
str = arr.join(separator)
//    

keys
keys()방법 은 배열 의 모든 색인 키 를 포함 하 는 새로운 Array 교체 기 를 되 돌려 줍 니 다.

let arr = ["a", "b", "c"];
let iterator = arr.keys();
// undefined
console.log(iterator);
// Array Iterator {}
console.log(iterator.next()); 
// Object {value: 0, done: false}
console.log(iterator.next()); 
// Object {value: 1, done: false}
console.log(iterator.next()); 
// Object {value: 2, done: false}
console.log(iterator.next()); 
// Object {value: undefined, done: true}

map
map()방법 은 새 배열 을 만 듭 니 다.그 결 과 는 이 배열 의 모든 요소 가 제공 하 는 함 수 를 호출 한 후에 돌아 온 결과 입 니 다.

let array = arr.map(function callback(currentValue, index, array) { 
 // Return element for new_array 
}[, thisArg])
let numbers = [1, 5, 10, 15];
let doubles = numbers.map((x) => {
 return x * 2;
});
// doubles is now [2, 10, 20, 30]
// numbers is still [1, 5, 10, 15]
let numbers = [1, 4, 9];
let roots = numbers.map(Math.sqrt);
// roots is now [1, 2, 3]
// numbers is still [1, 4, 9]

callback
새 배열 요소 의 함 수 를 만 들 고 세 개의 인 자 를 사용 합 니 다:
currentValue
콜백 의 첫 번 째 인자,배열 에서 처리 하고 있 는 현재 요소 입 니 다.
index
콜백 의 두 번 째 인자,배열 에서 처리 하고 있 는 현재 요소 의 색인 입 니 다.
array
callback 의 세 번 째 인자,map 방법 이 호출 된 배열 입 니 다.
thisArg
선택 적callback 함 수 를 실행 할 때 사용 하 는 this 값 입 니 다.
반환 값
모든 요 소 는 리 셋 함수 의 결과 입 니 다.
pop 과 push
pop()방법 은 배열 에서 마지막 요 소 를 삭제 하고 이 요소 의 값 을 되 돌려 줍 니 다.이 방법 은 배열 의 길 이 를 변경 합 니 다.
push()방법 은 하나 이상 의 요 소 를 배열 의 끝 에 추가 하고 배열 의 새로운 길 이 를 되 돌려 줍 니 다.
arr.push(element1, ..., elementN)
두 배열 을 병합 하 다.
이 예제 에 서 는 apply()를 사용 하여 두 번 째 배열 의 모든 요 소 를 추가 합 니 다.
두 번 째 배열(예 를 들 어 예제 의 moreVegs)이 너무 클 때 이 방법 으로 배열 을 합병 하지 마 십시오.사실상 한 함수 가 받 아들 일 수 있 는 매개 변수 개 수 는 제한 이 있 기 때 문 입 니 다.구체 적 으로 apply()를 참고 할 수 있 습 니 다.

var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];
//               
//     vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);
console.log(vegetables); 
// ['parsnip', 'potato', 'celery', 'beetroot']

reduce 와 reduceRight
reduce()방법 은 누산기 와 배열 의 모든 요소(왼쪽 에서 오른쪽으로)에 함 수 를 적용 하여 하나의 값 으로 줄 입 니 다.

array.reduce(function(accumulator, currentValue, currentIndex, array), initialValue)
var total = [0, 1, 2, 3].reduce(function(sum, value) {
 return sum + value;
}, 0);
// total is 6
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
 return a.concat(b);
}, []);
// flattened is [0, 1, 2, 3, 4, 5]

callback
배열 의 각 값 의 함 수 를 실행 합 니 다.네 개의 매개 변 수 를 포함 합 니 다.
accumulator
지난번 에 되 돌아 오 는 값 을 호출 하거나 초기 값 을 제공 합 니 다(initialValue)
currentValue
배열 에서 처리 중인 요소
currentIndex
데이터 에서 처리 중인 요소 인덱스 입 니 다.initialValue 를 제공 하면 0 부터 시작 합 니 다.아니면 1 부터.
array
reduce 의 배열 을 호출 합 니 다.
initialValue
콜백 을 처음 호출 하 는 첫 번 째 인자 에 사용 할 수 있 는 옵션 을 선택 하 십시오.초기 값 이 설정 되 어 있 지 않 으 면 배열 의 첫 번 째 요 소 를 초기 값 으로 합 니 다.빈 배열 이 reduce 를 호출 할 때 초기 값 을 설정 하지 않 으 면 오류 가 발생 합 니 다.
PS:reduceRight()와 reduce()의 실행 방향 과 반대 입 니 다.
reverse
reverse 방법 은 배열 의 요소 위 치 를 바 꾸 고 이 배열 의 인용 을 되 돌려 줍 니 다.
shift 와 unshift
shift()방법 은 배열 에서 첫 번 째 요 소 를 삭제 하고 이 요소 의 값 을 되 돌려 줍 니 다.이 방법 은 배열 의 길 이 를 변경 합 니 다.
unshift()방법 은 하나 이상 의 요 소 를 배열 의 시작 에 추가 하고 새 배열 의 길 이 를 되 돌려 줍 니 다.
slice
slice()방법 은 처음부터 끝까지 선택 한 배열 의 일부분 을 새 배열 대상 으로 복사 합 니 다.원본 배열 은 수정 되 지 않 습 니 다.

arr.slice();
//[0,end];
arr.slice(start);
//[start,end];
arr.slice(start,end);
//[start,end];

slice 는 원래 배열 을 수정 하지 않 고 원래 배열 의 요 소 를 간단하게 복사 한 새 배열 만 되 돌려 줍 니 다.원래 배열 의 요 소 는 다음 규칙 에 따라 복사 합 니 다.
이 요소 가 대상 참조(실제 대상 이 아 닌)라면 slice 는 이 대상 을 복사 하여 새로운 배열 에 참조 합 니 다.두 대상 의 인용 은 모두 같은 대상 을 인용 했다.인 용 된 대상 이 바 뀌 면 새로운 것 과 원래 배열 의 이 요소 도 달라 집 니 다.
문자열,숫자,불 값 은 String,Number 또는 Boolean 이 아 닙 니 다.slice 는 이 값 을 새로운 배열 로 복사 합 니 다.다른 배열 에서 이 문자열 이나 숫자 나 불 값 을 수정 하면 다른 배열 에 영향 을 주지 않 습 니 다.
두 배열 의 어느 하나 에 새로운 요 소 를 추가 하면 다른 하 나 는 영향 을 받 지 않 습 니 다.
some
some()방법 은 배열 의 일부 요소 가 제 공 된 함수 로 이 루어 지 는 지 테스트 합 니 다.

const isBiggerThan10 = (element, index, array) => {
 return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10); 
// false
[12, 5, 8, 1, 4].some(isBiggerThan10); 
// true

toLocaleString 과 toString
toLocaleString()은 배열 의 요 소 를 나타 내 는 문자열 을 되 돌려 줍 니 다.배열 의 요 소 는 각자 의 toLocaleString 방법 을 사용 하여 문자열 로 바 꿉 니 다.이 문자열 들 은 특정한 언어 환경의 문자열(예 를 들 어 쉼표",")을 사용 하여 격 리 됩 니 다.

var number = 1337;
var date = new Date();
var myArr = [number, date, "foo"];
var str = myArr.toLocaleString(); 
console.log(str); 
//    "1,337,2017/8/13   8:32:24,foo"
//        （zh-CN）  ，    
var a=1234
a.toString()
//"1234"
a.toLocaleString()
//"1,234"
//          ，toLocaleString()           ，                
var sd=new Date()
sd
//Wed Feb 15 2017 11:21:31 GMT+0800 (CST)
sd.toLocaleString()
//"2017/2/15   11:21:31"
sd.toString()
//"Wed Feb 15 2017 11:21:31 GMT+0800 (CST)"

splice
splice()방법 은 기 존 요소 와/또는 새로운 요 소 를 삭제 하여 배열 의 내용 을 변경 합 니 다.

array.splice(start)
array.splice(start, deleteCount) 
array.splice(start, deleteCount, item1, item2, ...)

start​
수 정 된 시작 위 치 를 지정 합 니 다.배열 의 길 이 를 초과 하면 배열 의 끝 부터 내용 을 추가 합 니 다.마이너스 라면 배열 의 끝 에서 시작 하 는 몇 번 째(1 에서 계산)를 나타 낸다.
deleteCount 선택 가능
정수,제거 할 배열 요소 의 개 수 를 표시 합 니 다.deleteCount 가 0 이면 요 소 를 제거 하지 않 습 니 다.이런 상황 에서 적어도 하나의 새로운 요 소 를 추가 해 야 한다.deleteCount 가 start 이후 요소 의 총수 보다 크 면 start 뒤의 요소 가 삭 제 됩 니 다(start 위 포함).
deleteCount 가 생략 되면(arr.length-start)에 해당 합 니 다.
item 1,item 2,...선택 가능
배열 에 들 어 갈 요 소 를 추가 하려 면 start 위치 부터 시작 합 니 다.지정 하지 않 으 면 splice()는 배열 요소 만 삭제 합 니 다.
반환 값
삭 제 된 요소 로 구 성 된 배열한 요소 만 삭제 하면 한 요소 만 포함 하 는 배열 로 돌아 갑 니 다.요 소 를 삭제 하지 않 으 면 빈 배열 로 돌아 갑 니 다.