Array.isArray(obj) 수조 여부, 판단!

이것은 Array 대상의 정적 함수로 하나의 대상이 수조인지 아닌지를 판단한다.

var a = []
undefined
var b = new Date()
undefined
console.log(Array.isArray(a))
 true
undefined
console.log(Array.isArray(b))
 false
undefined

.indexOf(element) / .lastIndex Of (element) 값을 찾습니다. 그룹에 나무가 있습니다.

indexOf는 처음부터 끝까지 검색하고 lastIndexOf는 반대로 검색합니다.첫 번째를 찾은 후 색인을 되돌려줍니다. 1 을 찾지 못했습니다.

var arr =[3,4,'hello','haha']
undefined
arr.indexOf('haha')
3
arr.indexOf('ha')
-1
arr.lastIndexOf('haha')
3
arr.splice(1,0,8,8,8,)
[]
arr
(7) [3, 8, 8, 8, 4, "hello", "haha"]
arr.indexOf(8)
1
arr.lastIndexOf(8)
3

만약 이 함수 명령이 없다면, 단독으로 스스로 쓰겠는가?

function hasWord(arr,item){
  for(var i =0;i

그룹의 반복.forEach(element,index,array)

역행은 모든 원소의 확장성을 더욱 강하게 하고 조작성을 더욱 편리하게 하기 위해 함수 각도에서 문제를 보는 것과 같다.배열을 반복합니다. 매개변수는 콜백 함수이고 콜백 함수에는 세 가지 매개변수가 있습니다.

현재 요소

현재 요소 인덱스 값

전체 그룹용

arr.forEach(function(){
console.log(arguments)
})

forEach의 세 가지 매개 변수의 순서를 알 수 있습니다: 원소, 위치, 그룹.

var arr =[3,4,'hello','haha']
arr.forEach(function(){
console.log(arguments)
})
 (3) [3, 0, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) [4, 1, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) ["hello", 2, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) ["haha", 3, Array(4), callee: function, Symbol(Symbol.iterator): function]
arr.forEach(function(value,index){
        console.log(value + '' + value )
})
 33
 44
 hellohello
 hahahaha

 for ？
for(var i=0;i

.every(function(element,index,array))/.me(function(element, index,array)) 수조의 원소가 어떤 조건을 충족시키는지 진짜와 가짜를 되돌려줍니다

every 모든 함수의 모든 리셋 함수는 진실로 돌아가고 진실로 돌아가며 가짜를 만나면 실행을 중지하고 가짜로 돌아간다.

some 함수는 리셋 함수가 존재하기 때문에 실행을 중지하고 리셋을 중지합니다. 그렇지 않으면 가짜를 반환합니다.

var arr =[3,4,-1,0,5]       // ？
arr.every(function(element,i){
      if(arr[i]>0)  
      return true  
})
false
 ：
arr.every(function(val){
       return val>0?true:false
})
false

 ？
arr.some(function(val){
      return val>0?true:false
})
true

.map (function (element) 은 그룹을 반복하고, 리셋 함수 반환 값은 새로운 그룹을 구성합니다.

새 수조는 원수조 인덱스 구조와 마찬가지로 원수조는 변하지 않는다.

var arr =[1,2,3,4,5,6]     // 
var a = arr.map(function(val){
  return val*val
})
a
(6) [1, 4, 9, 16, 25, 36]

.filter(function(element) 배열의 필터

그룹의 하위 집합을 되돌려줍니다. 리셋 함수는 되돌려줄지 여부를 판단합니다.true로 돌아가는 요소는 되돌려주는 그룹에 추가됩니다. 색인이 부족한 것은 새 그룹에 포함되지 않습니다. --------원수 그룹은 변하지 않습니다.

var arr=[3,5,6,-1,-2,-3]
var a =arr.filter(function(val){
    return val>0
})
a
(3) [3, 5, 6]
arr
(6) [3, 5, 6, -1, -2, -3]      // 

var students=[{
    name:'a',
    age:10
},
{
    name:'b',
      age:20
},
{
    name:'ce',
      age:8
},
{
      name:'dd',
        age:5
}
]                         // 18 ？
var stu18 =students.filter(function(val){
      return val.age>18
})
stu18
[{name:'b',  age:20}]  (length=1)//length 。

 c ：
var namehasc =students.filter(function(val){
    return val.name.indexOf('c')>-1
})
namehasc
[{name:'ce',age:8}]  // indexOf ， 。

reduce(function(v1,v2),value)/reduceRight(function(v1,v2),value) 원소가 작용하면 새로운 원소를 얻고, 새로운 원소는 다음 원수조의 원소와 계속 작용한다.

var arr =[3,4,5]    // 
arr.reduce(function(v1,v2){
      return v1+v2                             
})
12

처음, 두루두루, v1=3, v2=4, 7 얻기;다시 훑어보면 v1=7, v2=5, 12.여기에 초기값 매개 변수value가 있습니다.

arr.reduce(function(v1,v2){
    return v1+v2
},100)
112    // v1=100,v2=3, ，，，

어떻게 손으로 써서 Reduce의 기능을 실현합니까?

var arr=[3,4,5,6]
function reduce(arr,fn,initval){
}
var result=reduce(arr,function(){
          v1+v2
},10)
 ：
function reduce(arr,fn){
      var arr2=arr
  while(arr2.length>1){
              console.log(arr2)
              arr2.splice(0,2,fn(arr2[0],arr2[1]))
}
return arr2[0]
}

var arr=[3,4,5,6]

var result=reduce(arr,function(v1,v2){
        return  v1+v2
})
 (4) [3, 4, 5, 6]
(3) [7, 5, 6]
 (2) [12, 6]

console.log(result)
 18       // ， 。 arr2=arr.concat([]), 。

 ？ arr2=[initvalue,3,4,5,6]——

function reduce(arr,fn，initValue){
      var arr2=arr.concat([])
if(initValue !== undefined){
    arr2.unshift(initValue)
}                                            // ： if(initValue), 0 null, false。
  while(arr2.length>1){
              console.log(arr2)
              arr2.splice(0,2,fn(arr2[0],arr2[1]))
}
return arr2[0]
}
var arr=[3,4,5,6]
var result=reduce(arr,function(v1,v2){
        return  v1+v2
},10)


console.log(result)

하나의 그룹을 평평하게 찍다

var arr=[3,['4,5',7,[1]],[2,10]]
function flat(){
}
var arr2 = flat(arr)
console.log(arr2)     //[3,'4,5',7,1,2,10] ， 。 ？
 ：
function flat(arr){
  var arr2=[]
 arr.forEach(function(val){
      if(Array.isArray(val)){
          arr2 = arr2.concat(flat(val))
}else{
        arr2.push(val)
}                
})
return  arr2
}
var arr2=flat(arr)
arr2
(6) [3, "4,5", 7, 1, 2, 10]

 ：flat value 。
function flatten(arr){
var newArr=[]
function flat(arr){
    arr.forEach(val>={
      if(Array.isArray(val)){
          flat(val)     
}else{
        newArr.push(val)
}
})
}
flat(arr)
return newArr
}

 ：
function flatten2(arr){
    return arr.reduce(function(initArr,curentArr){
      return initArr.concat(Array.isArray(currentArr)flatten2(currentArr):currentArr)
},[])
}
// ， 。

어쨌든 기본적인 사고방식은 틀림없이 귀속으로 끼워 넣은 것을 평평하게 찍은 다음에 평평하게 찍은 후에 어떻게 결합하는지는 각자 능력에 달려 있다.