数组类型 array

数组类型 array

数组是一种特殊的对象，数组是按顺序排列的一组值 ( 元素 ), 每个位置都一个编号，编号是从 0 开始 , 编号也叫索引或者下标。数组可以存储任意数据类型。

• 创建数组用[ ]

  ["a","b",110,120] // 第一个位置a的索引是0，b值的索引是1 ，依次类推

• 读取数组的值用 [下标],由于数组的索引是数字，只能用[]方式读取

  console.log(arr[0])
  console.log(arr[4])

• 数组由length属性，可以返回数组元素的个数

  console.log(arr.length)

• 修改数组的值 通过[下标] 给对应位置元素重新赋值

  arr[0] = "a1"
  arr[2] = "001"

• 数组添加值 [下标] 添加值,如果对应位置有元素则是覆盖，没有对应的位置元素，则是添加。

  arr[5] = "cc"
  arr[10] = "dd" // 可以给任意位置赋值，中间跳过的位置则自动填充空位。存的值是undefined，一般是按顺序添加，不要留empty空位。

• in运算只能判断对象属性是否在对象，数组则是数组下标是否在数组里面，判断数组元素是否在数组里面不能用。

  console.log(2 in arr) // 只能判断下标2 是在数组arr存在

• for...in 可以遍历数组，由于数组是有序号的特殊对象，用for...in开销比较大，一般不用

  for(var x in arr){
  // x 是数组的下标
  console.log(arr[x])
  }

• for()循环遍历数组,较常用的遍历数组方法

  for(var i=0;i<arr.length-1;i++){
  console.log("--", arr[i])
  }

• 判断元素是否在数组里面,比较原始的方法，后面有更简洁的。

  var has = false
  for(var j=0;j<arr.length;j++){
  if("b2" === arr[j]){
  has = true;
  break
  }
  }
  if(has){
  console.log("该元素存在")
  } else {
  console.log("该元素不存在")
  }

• delete 可以删除数组元素，但是删除后对应位置变为空(值是undefifined),一般不用该方法

  delete arr[3] // 把下标为3的元素删除，对应位置还在，只是一个空的位置，值是(undefined)

• Array() 是js创建数组的一个对象，带有操作数组的一些方法和属性,也可当做一个函数去创建数组

  var arr1 = new Array(3) // 如果只有一个值，值是创建数组的长度
  var arr2 = new Array("a","b","c") // 如果值是一个非数组的或者大于1个值，则是作为数组元素创建数组

• Array.isArray() 判断是否是一个数组类型,是数组返回true，不是数组返回false

  console.log(Array.isArray("a"))

• toString()，数组转字符串

  console.log(["a","b",123,345].toString())

• push() 在数组末尾追加一个元素,可以追加多个

  var arr3 = ["a1","b1"]
  arr3.push("c1","d1","e1")

• pop() 删除末尾最后一个元素(整个位置都没有),并返回删除的元素

  console.log(arr3)
  var x = arr3.pop() // 把删除的元素赋值给x

• unshift 在数组的开头插入一个或者多个元素

  arr3.unshift("111") // 在头部插入一个元素
  arr3.unshift("123","456","789") // 在头部插入多个元素

• shift() 删除头部的元素，并返回该元素

  var y = arr3.shift()

• 二维数组，由于数组的元素是任意数据类型，当数组的元素是一个数组的时候，就构成了二维数组,如果二维数组的元素又是数组，可以称为多维数组

  var arr = [[1,2],["a","b"]]

• 类似数组对象,属性看起来和数组一样，但是本质还是一个狭义对象，并没有数组的特性，如果数组的操作方法和length的自动计算。

  var arr1 = ["a","b","c"]
  arr1[3]="d"
  var ob1 = {0:"a",1:"b",2:"c",length:3}
  console.log(arr1)
  console.log(Array.isArray(ob1))
  ob1[3]="d"
  console.log(ob1.length,arr1.length)

---

题

1.对象的深拷贝

var person1 = {
        name:"lisi",
        age:10,
        frend:["a1","a2","a3", {name:"lisi",age:10}], // frend属性数组是一个引用数据类型，对应的是一个内存地址
        family:{  // family属性是引用数据类型，也是一个内存地址。
          number:123,
          address:"四川成都",
          o1:{ // 思考，如果是多层次的引用数据类型嵌套，怎样拷贝?
            o2:{
              name: "a1"
            }
          }
        }
      }

 // 1.创建一个空对象
    var person2 = {}
    // 2. 拷贝对象的属性到空对象,只深拷贝了一层。需要判断对象的属性值是否是一个引用数据类型，如果是引用数据类型需要用深拷贝.
    // 该方法能实现两层数据的深拷贝
    for(var key in person1){
      // 直接拷贝只能拷贝非引用数据类型
      if(typeof(person1[key]) !== "object"){
        person2[key] = person1[key]
      } else if(Array.isArray(person1[key])){
        // 如果是数组，需要深拷贝数组的每个元素
        let arr = []
        for(var i=0;i<person1[key].length;i++){
          arr.push(person1[key][i])
        }
        person2[key] = arr;
      } else if(typeof(person1[key]) === "object"){
        // 如果属性值是对象，需要深拷贝对象的属性值
        var o = {}
        for(var item in person1[key]){
          o[item] = person1[key][item]
        }
        person2[key] = o;
      }
    }
    // person1 的内存地址和person2的内存地址不相同
    // person1.frend是引用数据类型，persong2拷贝person1的frend是拷贝的frend的内存地址，所以person2.frend 和 person1.frend 是同一个内存地址。
    console.log(person2.frend === person1.frend)

2：计算1-100所有数字相加的和

 var count = 0;
    for(var i=1;i<=100;i++){
      count += i
    }
    console.log(count)

3.var arr=[1,5,2,9,7,4]
把数组元素由小到大排序输出

// 算法: 为解决一类问题而写的js逻辑代码就叫算法。
    // 数组排序算法1: 冒泡排序法
    // 比较n-1轮
    var counta = 0;
    for(var i=0;i<arr.length-1;i++){
      // 每一轮都让相邻数相比较，前数大于后数则交换位置。每比一轮会找到一个大数放到后面，所以每一轮后数不需要在比较。
      for(var j=0;j<arr.length - 1 - i;j++){
        // 如果前数大于后数则交换位置。(如果是由大到小的排序，则是前数小于后数则交换位置)
        if(arr[j] > arr[j+1]){
          let tem = arr[j]
          arr[j] = arr[j+1]
          arr[j+1] = tem
        }
        counta++
      }
    }
    console.log(arr,counta)

 数组排序方法2:  1. 从第一个元素开始，认为第一个元素已经被排序  2. 取下一个元素，在已排序的元素中从后向前比较，前数大于后数则交换位置  3. 重复2步骤就可以实现排序

    arr=[1,5,2,9,7,4,6]
    var countb = 0
    // 从第二个元素开始比较
   for(var i=1;i<arr.length;i++){
    // 和前面排好序的数字做比较
    for(var j=0;j<i;j++){
      if(arr[j] > arr[i]){
        let tem = arr[j]
        arr[j] = arr[i]
        arr[i] = tem
      }
      countb++
    }
   }
   console.log(arr, countb)