js - 数组对象

数组对象Array

数组对象的作用是：使用单独的变量名来存储一系列的值。

元素取值

数组名【元素索引号】

数组遍历

let arr = ['red', 'green', 'blue', 'pink', 'purple']
let newArr = []
// 返回反转的数组内容
for (let i = arr.length - 1; i <= 0; i--) {
  // arr[i] 遍历每一项元素，arr.length
  newarr[newarr.length] = arr[i]
}

// 求数组[2,6,1,77,52,25,7]中的最大值。
let arr2 = [2, 6, 1, 77, 52, 25, 7]
let max = arr[0]
for (let i = 0; i < arr2.length; i++) {
  if (max < arr2[i]) { max = arr2[i] }
}
console.log(max)

// 要求：将数组转换为字符串并且用|或其他符号分割
let arr3 = ['red', 'green', 'blue', 'pink']
let arrStr = ''
function arrayTstr (fu) {
  for (let i = 0; i < arr3.length; i++) {
    if (i == arr3.length - 1) {
      arrStr += arr3[i]
      console.log(arrStr)
      return
    }
    arrStr += arr3[i] + fu
    console.log(arrStr)
  }
}
arrayTstr('=')

属性 length  设置或返回数组中元素的数目

数组方法

数组转换数据类型

join( ):把数组每一项加入到字符串,第一个参数为分割符
        不传则每项以','分割
        let strArr2 = arr2.join()
        // console.log(strArr2()）//13, 22, 11
        // 采用''分割内容全部连接一起
        let strArr2 = arr2.join('')
        console.log(strArr2）//132211
    
      1.2 split():字符串加入至数组，第一个参数为以什么分割加入的分隔符//

 数组元素操作

 2. 增 //       
        2.1 push()向数组末尾添加一个或更多元素，并返回此数组新的长度,影响源数组 //
        let students = ['小张', '小王', '小李']
        //students =['小张', '小王', '小李','小顺']
        let newLength = students.push("小顺")
        console.log(newLength) //4
        
        2.2 concat()合并两个数组，返回合成数组；不会影响原数组；浅拷贝
        let arr11 = [1, 2, 3]
        let arr22 = [4, 5, 6]
        let arr33 = [7, 8, 9]
        console.log(arr11.concat(arr22).concat(arr33)) // [1, 2, 3, 4, 5, 6, 7, 8, 9]

        2.3 splice（） 可以对数组进行增删改，返回被删除元素数组，被删除元素的数组;
            // 参数1：起始下标，参数2：删除元素个数，参数3：替换内容
            let people = ['张三', '李四', '王五']
            
            // 删除李四 
             //let newP = people.splice(1, 1)
             //console.log(newP) // ['李四']
             //console.log(people) // ['张三', '王五']

            // 把王五修改成丽丽 
             //people.splice(2, 1, '丽丽')
             //console.log(people) //) ['张三', '王五', '丽丽']

            // 在任意位置添加
                //在任意数组末尾的位置进行添加顺顺               
                 //people.splice(people.length, 0, '顺顺')

   3.删//
        // 1/slice() 方法返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝        
        //（包括 start，不包括 end），其中 start 和 end 代表了数组元素的索引。原始数组不会被改变。    
        let a = [1, 2, 3, 4]
        // 第二个第三索引的元素
        console.log(a.slice(1, 3)) // 
        // 第2个到最后一个元素
        // end不传默认截取到最后
         console.log(a.slice(1));
*/

// 删除数组中为0的元素
let arr3 = [2, 0, 0, 1, 1, 77, 0, 52, 0, 25, 7]
let arr3Q0 = []


/* 
//错误做法:
let arr9 = [2, 0, 0, 1, 1, 77, 0, 52, 0, 25, 7]
for (let i in arr9) {
  if (arr9[i] == 0) {
    arr9.splice(i, 1)
  }
} 
console.log(arr9) //[2, 0, 1, 1, 77, 52, 25, 7]

// 数组漏删0元素，原因splice 每次的操作基于上回合操作后的数组
// 第一次 i = 0 ，arr[0] 为2故此回合没有元素被删除 
// 第二次 i = 1 ，arr[1]为0 ，删除后 数组为[2, 0, 1, 1, 77, 0, 52, 0, 25, 7]
// 第三次 i = 2 ，arr[2]为1 则漏掉了0



*/

/* arr3.forEach(item => {
  // 遍历当前元素不等于0放到新数组中
  if (item !== 0)
    arr3Q0.push(item)
}) */

/* 
  splice 每次的操作基于上回合操作后的数组
    1次循环： arr4 = [1, 1, 2, 3]
    2次循环： arr4 = [1, 1, 1, 2, 3]
    3次循环： arr4 = [1, 1, 1, 1, 2, 3]
 */
let arr4 = [1, 2, 3]
for (let i in arr4) {
  arr4.splice(i, 0, 1)
}
console.log(arr4)

数组排序

 

/* 
    1.sort排序并返回对相同数组的引用。compareFn没有默认是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序。
    compareFn(a,b)定义排序顺序的函数。返回值应该是一个数字，其正负性表示两个元素的相对顺序。
    
    compareFn(a, b) 返回值影响的排序规则
      > 0	a 在 b 后，如 [b, a]
      < 0	a 在 b 前，如 [a, b]
      === 0	保持 a 和 b 原来的顺序
  */
  const 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((a, b) => a.value - b.value)
   console.log(items) */


  // 根据 name 排序
  /*  items.sort((a, b) => {
     let nameA = a.name
     let nameB = b.name
     if (nameA > nameB) {
       return 1
     }
     if (nameA < nameB) {
       return -1
     }
     if (anameA = nameB) {
       return 0
     }
   })
   console.log(items) */

// 4.冒泡排序
/* 
  趟数：数组中需要进行排序的元素个数；
        值为数组.length - 1 : 因为最后一个不需要排序
  次数：需要排序元素交换的次数
          以arrx为数据
            1 2
            2 3 
            3 4 第一个元素需要交换 3次

            2 3 第一个元素需要交换 2次
            2 4 

            3 4 第一个元素需要交换 1次

*/
let arrx = [7, 4, 47, 2, 1, 44]
let newArrx = []

for (let i = 0; i < arrx.length - 1; i++) {
  for (let j = 0; j < arrx.length - i - 1; j++) {
    if (arrx[j] > arrx[j + 1]) {
      var front = arrx[j + 1]
      arrx[j + 1] = arrx[j]
      arrx[j] = front
    }
  }
}

console.log(arrx);