打卡 day 8 数组

最新推荐文章于 2024-10-02 05:39:15 发布

怎么能不笑呢

最新推荐文章于 2024-10-02 05:39:15 发布

阅读量89

点赞数

文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/a1939249353/article/details/126512508

版权

数组

数组就是数据的集合

复杂数据类型 object

创建一个数组

字面量创建一个数组

直接使用 [] 的方式创建一个数组

// 创建一个空数组
var arr1 = []

// 创建一个有内容的数组
var arr2 = [1, 2, 3]

内置构造函数创建数组

使用 js 的内置构造函数 Array 创建一个数组

// 创建一个空数组
var arr1 = new Array()

// 创建一个长度为 10 的数组
var arr2 = new Array(10)

// 创建一个有内容的数组
var arr3 = new Array(1, 2, 3)

数组的索引

数组的下标从0开始

var arr2 = [1, 2, 3]
// 1 2 3 
// 0 1 2  下面代表索引   1 的索引是0

数据类型之间存储的区别（重点）

既然我们区分了基本数据类型和复杂数据类型
那么他们之间就一定会存在一些区别
他们最大的区别就是在存储上的区别
我们的存储空间分成两种栈和堆
栈：主要存储基本数据类型的内容
堆：主要存储复杂数据类型的内容

数组的常用方法

以下方法会改变数组

1.push 2.pop 3. unshift 4 .shift 5. reverse 6. sort 7.splice

以下不会改面数组

push() 添加数据返回值是添加数据之后新数组的长度
pop() 删除数据返回值是删除的数组的最后的那一个数据

    //对结尾 
        // push() 添加数据  返回值 是添加数据之后 新数组的长度
        // pop() 删除数据 返回值 是删除的数组的最后的那一个数据
    
//   var num1=[1,2,3,4,5,6,7]
//    num1.push('季沧海');//1,2,3,4,5,6,7.季沧海
//    document.write(num1+'<br>') 
//    document.write(num1.push('季沧海'+'<br>'));//9
//    var num2=[1,2,3,4,5,6,7]
//    document.write('<br>');
//    document.write(num2.pop())//7
//    document.write('<br>');
//    document.write(num2)//1,2,3,4,5,6

unshift() 添加数据返回值是添加数据之后新数组的长度
shift()删除数据返回值是删除的数组的第一个数据

//对开头
        // unshift() 添加数据 返回值 是添加数据之后 新数组的长度
        // shift()删除数据 返回值 是删除的数组的第一个数据

var num3=[1,2,3,4,5,6,7];

num3.shift()
document.write(num3) //2,3,4,5,6,7
document.write('<br>');
   document.write(num3.shift())//2    删除第一位 因为上面已经删除了1 所以删2
   document.write('<br>');

   var num4=[1,2,3,4,5,6,7];
   num3.unshift(1)
document.write(num3) //2,3,4,5,6,7
document.write('<br>');
   document.write(num3.unshift(1))//7     是添加数据之后 新数组的长度
   document.write('<br>');

sort() 按照每个数据一位一位的对比排序

 // sort() 按照每个数据 一位一位的对比 排序    不太重要

        //sort(function(a,b){return a-b})
        // var test = ['李白','安琪拉','猪八戒','韩信','李信','小乔','武则天']
        // var test = [119,20,5,67,27,48]
        // function haha(num1,num2){
        //     if(num1>num2){
        //         return -5; // 如果小于0 不交换位置
        //     }
        //     return 5; // 大于0 交换位置 
        // }
        // test.sort(haha) //因为 sort即可以排序数字 又可以排序字母
        // // 导致 直接排序数字 或者直接排序字母 有可能不正确的情况 
        // // 需要手动干预  
        // // 需要传一个方法 函数进去  传函数名进去 不要() 

        // alert(test)

        // 默认是排序纯字母 

        // var test = ['g','a','r','p','x','o']
        // test.sort()
        // alert(test)
        // sort 不要排序数字  非要排序数字  那么需要干预一下 写个

reverse() 翻转

   // reverse()  翻转
        var num5=[1,2,3,4,5,6,7];
        num5.reverse()
        document.write(num5);

splice() 专门用来截取数组

 // splice() // 专门用来截取数组 

     //一个方法完成了数组的增删改 
        //数组.splice(开始的索引位置,0,新元素1,...新元素n) 增
        //数组.splice(开始的索引位置,删除的个数) 删 
        //数组.splice(开始的索引位置,删除的个数,替换的元素1,...元素n) 改 
        document.write('<br>');
        var num6=[1,2,3,4,5,6,7];
     num6.splice(1,0,'w');// 从第二个位置前面 增加 w
     document.write(num6)

concat()
+ 语法: 原始数组.concat(数1, 数2, 数据, …)
+ 作用: 进行数组拼接, 把参数的所有数组或者数据, 拼接在原始数组身上
+ 返回值: 拼接好的数组
+ 和 push 的区别
=> 改变原始数组
-> push 直接改变原始数组
-> concat 不会改变原始数组
=> 插入数据
-> push 直接把数据插入
-> concat 如果遇到数组, 会把数组拆开, 把每一个数据依次插入



 var arr1 =  ['李白','安琪拉','猪八戒','韩信','李信','小乔','武则天']

    var res = arr1.concat([500,'周瑜'],'诸葛亮',['铁拐李','黄忠'])//在原有数组后面拼接。。。。
    document.write('原始数组',arr1,'<br>')
    document.write('拼接好的数组',res,'<br>')
    document.write('原始数组',arr1)

join() 数组=>字符串
+ 语法: 数组.join(‘连接符’)
+ 作用: 使用连接符, 把数组内的每一个数据连接成一个字符串(不写默认使用逗号)
+ 返回值: 连接好的字符串

    

     var arr2 =  ['李白','安琪拉','猪八戒','韩信','李信','小乔','武则天']
    var res2 = arr2.join('$') //就是在数组里面插入新的
    document.write('原始数组',arr2,'<br>')
    document.write('拼接好的字符串',res2,typeof(res2),'<br>')
    document.write('原始数组',arr2)

slice()



    //     + 语法: 数组.slice(开始索引, 结束索引)  [开始的索引,结束的索引)
    //     + 参数特点:
    //       => 包前不包后, 包含开始索引位置数据, 不包含结束索引位置数据

    //       => 开始所以不填, 默认是 0, 结束索引不填, 默认是 length

    //       => 可以填写负整数, 表示倒数第几个, 其实就是 length + 负整数
    //     + 作用: 截取数据的部分内容
    //     + 返回值: 必然是一个新数组
    //       => 内部就是截取出来的部分内容
    //     + 和 splcie 的区别
    //       => 改变原始数组
    //         -> splice 改变原始数组
    //         -> slice 不改变原始数组
    //       => 参数
    //         -> splice(开始索引, 多少个)
    //         -> slice(开始索引, 结束索引)

  document.write('<br>');
    var arr3 =  ['李白','安琪拉','猪八戒','韩信','李信','小乔','武则天']
    var res = arr3.slice(2,3);
    var res = arr3.slice(-6,-4); //截取的时候一定是从左往右截取 -6,-4  安其拉 猪八戒
    var res = arr3.slice(-1); // 截取数组的最后一个元素
    // var res = arr1.slice(-1,0); //默认是从左往右 -1 到0 是从右往左所以结果是空 

    // var res = arr1.slice(0,arr1.length);
    // var res1 = arr1.slice(0);// 有头无尾 不写尾代表你全要

    document.write('原始数组:',arr3,'<br>')
    document.write('截取的内容:',res,typeof(res),'<br>')
    // document.write('截取的内容',res1,typeof(res),'<br>')

    // document.write('原始数组',arr1)

    // 复制一个新的数组
    // push 到一个新空数组中

indexOf()/ lastIndexOf() 一个从前向后一个从后向前

     //     + 语法:
    //       => 数组.indexOf(数据)
    //       => 数组.indexOf(数据, 开始索引)
    //     + 作用: 从前到后检索该数据第一次在该数组内出现的位置
    //     + 返回值:
    //       => 如果在数组内找到了该数据, 那么就是该数据第一次出现的索引位置
    //       => 如果在数据内没有找到该数据, 那么就是 -1
     var arr4 =  ['李白','安琪拉','猪八戒','李白','杜甫','韩信','李信','小乔','武则天']
    //元素的下标永不变 不管从哪里找 找到他 就是他不变的下标
    var res = arr4.indexOf('杜甫',5) // 从左往右找       第一次出现的位置  1 如果找不到 返回-1
    // 如果指定了第二个参数 表示从下标五开始往右查找 找不到 -1 
    var res1 = arr4.lastIndexOf('杜甫',5) // 从右往左找     第一次出现的位置 3 如果找不到 返回-1
    // 如果指定了第二个参数 表示从下标五开始往左查找 返回 找到返回元素所在数组的下标 找不到 -1     
    alert(res) ;
    alert(res1);

数组的排序

冒泡排序

先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置
数组遍历一遍以后，那么最后一个数字就是最大的那个了
然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
以此类推，最后就会按照顺序把数组排好了

for (var j = 0; j < arr.length - 1; j++) {
  for (var i = 0; i < arr.length - 1 - j; i++) {
    // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
    if (arr[i] > arr[i + 1]) {
      var tmp = arr[i]
      arr[i] = arr[i + 1]
      arr[i + 1] = tmp
      document.write(arr+'<br>')
    }
  }
}

数据类型复制的区别

 // var a = 100; //在栈内存开辟一个独立的空间
        // var b = a; //  先给b在栈内存开辟一个空间 然后a中的100 给到 b 
        // 两个空间各自独立  基本数据类型储存在栈内存  复杂数据类型在堆内存

        //'hello' 100 原数据用不改变 


        // alert(a);  // 100
        // alert(b); // 100

        // b = 200;
        // alert(a); //100 修改b 不影响a 
        // alert(b); //200 

        var a = {name:'**'} // 栈内存中开辟空间 起名a  堆内存开辟空间

        var b = a;  // 栈内存开辟空间b 堆内存的地址赋值给a  ab共用一个堆内存地址
        console.log(a.name)
        console.log(b['name'])

        b.name = '***'  // 所以修改b 就会影响a
        console.log(a.name)
        console.log(b['name'])

t(a); //100 修改b 不影响a
// alert(b); //200

    var a = {name:'**'} // 栈内存中开辟空间 起名a  堆内存开辟空间

    var b = a;  // 栈内存开辟空间b 堆内存的地址赋值给a  ab共用一个堆内存地址
    console.log(a.name)
    console.log(b['name'])

    b.name = '***'  // 所以修改b 就会影响a
    console.log(a.name)
    console.log(b['name'])