JavaScript篇.day05-数组, 基本/引用数据类型函数调用区别_同个函数调用不同数组和不同函数调用相同数组的区别-CSDN博客

// 数组 存放一组数据的集合, 存放多个数据, 有序的数据集合, 长度可变的数组
      // 索引: 从 0 开始,  数组索引最大为 数组名.length - 1    空数组索引无效
      // 稀疏数组     定义数组时,其中有的元素没有内容 undefined
      // 定义数组 (自变量的方式)
      var arr1 = []
      var arr2 = ['mm', 'tt', 'zz']

      // 向数组中添加元素    通过索引
      arr1[0] = 10
      arr1[1] = 20
      arr1[10] = 100
      // 稀疏数组
      console.log(arr1) // [10, 20, empty × 8, 100]

      // 获取数组中指定位置的元素   通过索引
      console.log(arr1[1]) //20
      console.log(arr1[5]) //undefined

      // 获取数组长度     数组名.length
      console.log(arr2.length) //3

      // 修改某元素      数组名[索引] = 值
      arr1[0] = 1000
      console.log(arr1[0]) // 1000

      // 删除某元素      使用delete 删除的是内容, 位置没有删掉, 变为undefined
      delete arr1[1]
      console.log(arr1) //[1000, empty × 9, 100]

(3)数组的遍历

a. 普通数组的遍历

for-in遍历, 将数组看作对象遍历
for循环遍历每个元素

      // 遍历数组
      // 方式1: for-in   将数组看作对象,索引对应键key,元素为值   只会遍历打印有值的数据
      for (var key in arr1) {
        console.log(arr1[key])
      }
      // 方式2: for   遍历每个元素
      for (var i = 0; i < arr1.length; i++) {
        if (arr1[i] !== undefined) {
          //排除稀疏数组的空元素
          console.log(arr1[i])
        }
      }

b.对象数组的遍历

 // 对象数组
      var objArr = [{ name: '中' }, { name: '美' }, { name: '英' }]
      for (var i = 0; i < objArr.length; i++) {
        console.log(objArr[i].name)
      }

      console.log('================================')

      var objArr11 = [
        { fruits: ['apple', 'pear'] },
        { vegetable: ['tomato', 'potato'] },
      ]
      for (var i = 0; i < objArr11.length; i++) {
        // obj11 接收  objArr11数组中的对象
        var obj11 = objArr11[i]
        console.log('objArr11------', objArr11[i])
        // 遍历对象
        for (var key in obj11) {
          // 接收对象中的值(数组)
          var arr11 = obj11[key]
          console.log('obj11---------', obj11[key])
          // 遍历最里层的数组
          for (var j = 0; j < arr11.length; i++) {
            console.log('arr11------------', arr11[j])
            break
          }
        }
      }

(4)数组对象常用方法

Array	对数组的内部支持
Array.concat( )	连接数组
Array.join( )	将数组元素连接起来以构建一个字符串
Array.length	数组的大小
Array.pop( )	删除并返回数组的最后一个元素
Array.push( )	给数组添加元素
Array.reverse( )	颠倒数组中元素的顺序
Array.shift( )	将元素移出数组
Array.slice( )	返回数组的一部分
Array.sort( )	对数组元素进行排序
Array.splice( )	插入、删除或替换数组的元素
Array.toLocaleString( )	把数组转换成局部字符串
Array.toString( )	将数组转换成一个字符串
Array.unshift( )	在数组头部插入一个元素

var array1 = [1,2,3]
      var array2 = [4,5,6]
      var array3 = [7,[8,'a']]
      // length 属性     获取数组长度
      console.log(array1.length)   //  3

      // 数组常用方法    ()方法/函数     
      // 1. concat()   拼接数组 或 向数组中添加元素,并返回新数组
      var newArr1 = array1.concat('c','d')
      var newArr2 = array1.concat(array2).concat(array3).concat(9, 10)
      console.log(array1)  //  [1, 2, 3]
      console.log(array2)  //  [4, 5, 6]
      console.log(array3)  //  [7, Array(2)]
      console.log(newArr1) //  [1, 2, 3, 'c', 'd']
      console.log(newArr2) //  [1, 2, 3, 4, 5, 6, 7, Array(2), 9, 10]

      // 2. join()  将数组拼接为字符串, 元素间默认以,分隔
      console.log(array1.join())  //  1,2,3
      console.log(array1.join(""))  //  123

      // 3. push()  向原数组尾部添加元素
      array2.push('d','e','f')
      console.log(array2)   //  [4, 5, 6, 'd', 'e', 'f']

      // 4. pop()  删除原数组尾部的元素, 返回删除元素值
      console.log(array2.pop()) // f
      console.log(array2)   // [4, 5, 6, 'd', 'e']
      
      // 5. unshift()   原数组头部添加一个或多个元素(从右往左加,后加的在最前), 返回数组长度
      console.log(array2.unshift('111','222'))   // 7
      console.log(array2)     //['111', '222', 4, 5, 6, 'd', 'e']

      // 6. shift()     移出数组头部元素, 返回移出的元素
      console.log(array2.shift())    //  111
      console.log(array2)    //['222', 4, 5, 6, 'd', 'e']

      // 7. reverse()    反转数组,返回新数组
      console.log(array2.reverse())    //  ['e', 'd', 6, 5, 4, '222']
      console.log(array2)    //  ['e', 'd', 6, 5, 4, '222']
       
      //8. sort()    排序, 默认按字母序排列
      console.log(array2.sort())   // ['222', 4, 5, 6, 'd', 'e']
      console.log(array2)   //  ['222', 4, 5, 6, 'd', 'e']

      //9. slice(startIndex, endIndex)   分割范围数组,并返回, 不改变原数组    [startIndex, endIndex)
      console.log(array2.slice(0,2))  //['222', 4]
      console.log(array2.slice(1, -1))  //  [4, 5, 6, 'd']
      console.log(array2)  //  ['222', 4, 5, 6, 'd', 'e']

      var array4 = ['piano','erHu','suona']
      // 10. splice(start, delCount, value...)    插入,删除,替换数组元素   start开始位置, delCount删除几个, value值
      //  索引为 0 的位置添加元素
      console.log(array4.splice(0,0,'guitar','guzheng'))   //没有返回值 
      console.log(array4)  //['guitar', 'guzheng', 'piano', 'erHu', 'suona']
      //  删除某索引位置的值(可删除多个值)
      console.log(array4.splice(1,2))  //['guzheng', 'piano']  返回删除的片段
      console.log(array4) //  ['guitar', 'erHu', 'suona']
      //  替换某几个位置的几个元素
      console.log(array4.splice(1,2,'333','444'))   //['erHu', 'suona']  从索引为1的位置开始,替换2个
      console.log(array4)  //  ['guitar', '333', '444']

2.基本/引用数据类型函数调用区别

基本数据类型函数调用是传值调用
引用数据类型函数调用是传地址调用

// 传值调用
      // 将交换步骤封装为一个方法
      function swap1(num1, num2) {
        console.log(num1, num2) // 10 20
        var temp = num1
        num1 = num2
        num2 = temp
        // 交换的是 num1 和 num2, 与a,b无关
        console.log(num1, num2) //20 10
      }
      // 传值调用   基本数据类型数字交换
      // 基本数据类型中,每一个变量名指向内存空间中的具体值,函数调用传递的仅仅是值, 形参的改变不影响实参      a,b,num1,num2互不相关, num1与num2值交换与a,b无关
      var a = 10,
        b = 20
      swap1(a, b)
      console.log(a, b) // 10 20

      // 传地址调用
      // arr数组  i,j要交换的索引
      function swap(arr, i, j) {
        console.log(arr[i], arr[j]) // 1,3
        var temp = arr[i]
        arr[i] = arr[j]
        arr[j] = temp
        console.log(arr[i], arr[j]) // 3,1
      }
      // 传地址调用   引用数据类型
      // 引用数据类型中, 变量名指向内存中的地址, 函数调用是将地址传递,故不同的变量名指向同一个地址, 当其中一个变量指向的内容发生变化时, 另一个也会变    形参的改变影响实参
      var arrs = [1, 2, 3]
      swap(arrs, 0, 2)
      console.log(arrs[0], arrs[2]) //3,1