数组及其数组的方法

数组

数组的概念

一个变量只能存储一个数据，如果我们有一组数据，比如1到100一百个数字，定义100个变量来存储就太痛苦了，这时候我们就需要数组来存储这样的数据。数组:存储一组数据.

数组的定义

数组为引用类型，创建时可通过构造方法创建。

堆和栈及索引思维

构造方法

1.无参构造函数，创建一空数组

var a1=new Array();

2.一个数字参数构造函数，指定数组长度（由于数组长度可以动态调整，作用并不大），创建指定长度的数组

var a2=new Array(5);

3.带有初始化数据的构造函数，创建数组并初始化参数数据

var a3=new Array(4,'hello',2.34);

数组的定义
    1.构造方法
    new:在堆内开辟空间的关键词
    Array:数组数据类型
    
var arr=new Array(1,2,3,4,5,6);

字面量

4.使用方括号，创建空数组，等同于调用无参构造函数

var a4=[];

5.使用中括号，并传入初始化数据，等同于调用带有初始化数据的构造函数

var a5=[10];

var arr=[1,2,3,4,5,6,7,8,9]; 最常用的

数据类型分类

内置基本类型:
    Number
    String
    Boolean
    undefined
    null

    
引用类型:
    object
    
内置类型与引用类型的区别:
    内置类型:只有一块空间,在栈区,该空间直接保存着变量的数值
    
引用类型:
    有两块空间,一块栈空间,存储new出来堆空间的地址,
    另一块堆空间,存储真正的数值

数组元素的访问

数组名[下标];
    下标:索引,从零开始连续的自然数,基于0;
    下标也可以是变量
    数组下标的取值范围0~元素个数-1;
    数组的长度:length
    
​
注意事项:
    数组的下标不能越界访问
    超出范围出现undefined,不报错,
    
数组的长度
    length
    console.log(arr.length);
    
数组的遍历

    var arr=[7,8,9,6,5,0,1,2,3];
    for(var i=0;i<arr.length;i++){
        document.write(arr[i]+" ");
    }
        

数组的逆序:
    思想:相当于第一个和最后一个交换,第二个和倒数第二个交换,交换的次数为数组元素个数的一半
    交换需要中间变量
    程序=算法+语法
    算法:先用中文描述出来问题解决的步骤,然后再翻译为JS语言
  

  var t=0;//定义中间变量
    var arr=[7,8,9,6,5,1,2,3];
    for(var i=0;i<arr.length/2;i++){
        t=arr[i];
        arr[i]=arr[arr.length-1-i];
        arr[arr.length-1-i]=t;
    }
    document.write(arr+" ");
    

    分析:7和3交换
    规律:arr4[0]和arr4[arr4.length-1-0]交换
    以此类推

数组的相关函数

函数需要注意的几个点:功能 ,参数 ,返回值
​
eg:
封装闰年问题
 

   function getRn(x){
        if(x%4==0&&x%100!=0 ||x%400==0){
            return true;
        }else{
            return false;
        }
    }
    if(getRn(2008)==true){
        console.log('闰年');
    }else{
        console.log('平年');
    }

• push尾插 (尾插有参返新长)

     功能:末尾插入一个或多个元素
     参数:push(x1,[x2,x3])必须要有一个参数,方括号里面表示可选的参数,可有可没有.
      返回值:返回尾插后新数组的长度

   var arr=[1,2,3];
    var len=arr.push(4,5,6);
    console.log(len);//6
    console.log(arr);//[1,2,3,4,5,6]

• pop尾删

pop:尾删
    参数:无
    返回值:返回被删掉的元素
    

  var arr=[4,5,7,8,5,1,2,3];
    var x=arr.pop();
    console.log(x,arr);//3,[4,5,7,8,5,1,2]

• unshift头插 (头插有参返新长)

  unshift:头插
      功能:头部插入一个或若个元素
      参数:unshift(x1,[x2,x3])
      返回值:返回头插后新数组的长度
  

    var arr=[1,2,3];
      var x=arr.unshift(4,5,6);
      console.log(x,arr);//6,[4,5,6,1,2,3]
      

• shift 头删

  shift:头删
      功能:删除第一个元素
      参数:无参
      返回值:返回被删除的元素
      
  

      var arr=[1,2,3];
      var x=arr.shift();
      console.log(x,arr);//1,[2,3]
      

• reverse 逆序

  reverse 
      功能:逆序
      参数:无
      返回值:无
      直接改变原数组对象
      
  

     var arr=[1,2,3,4,5,6];
      arr.reverse();
      console.log(arr);//[6,5,4,3,2,1]

• splice 删除指定元素且用新的元素代替

  功能:删除指定元素且用新的元素代替
      参数:splice(起始位置,偏移量,[替换的元素]);
      返回值:被删除的元素(其实就是一个数组)
      注意:起始位置:看的下标,偏移量从下标开始算
  

      var arr=[1,2,3,4,5,6];
      var arr1=arr.splice(2,3,7,8,9);
      console.log(arr,arr1);//[1,2,7,8,9,6][3,4,5]

  • concat:拼接数组

    功能:拼接数组
        参数:concat(数组)
        返回值:被拼接的新数组
    

      var arr1=[7,8,9,5,4];
        var arr2=[1,2,3,6];
        var arr3=arr1.concat(arr2);
        console.log(arr3);//[7,8,9,5,4,1,2,3,6]

  • join 将数组转换为字符串

  功能:将数组转换为字符串
      参数:([字符串分隔符]),默认分隔符为逗号
      返回值:被分隔的字符串
     

   
      var arr=[1,2,3,4,5,6];
      var arr1=arr.join('*');
      console.log(arr1);// 1*2*3*4*5*6
  ​

• slice 数组元素的截取

  slice
      功能:数组元素的截取
      参数:slice(起始位置,结束位置);[左闭右开)
      返回值:返回被截取的数组
  

      var arr=[1,2,3,4,5,6];
      var arr1=arr.slice(2,5);
      console.log(arr1);// [3,4,5]返回被截取的数组

  • sort(了解)

    var arr=[7,8,9,5,1,2,3];
        arr.sort();
        console.log(arr);// [1, 2, 3, 5, 7, 8, 9]按照字符串的大小排序,内部Ascall码值比较 

        
    从小到大    
        

  • 多维数组

    多维数组
        js中多维数组是模拟一维数组的
         多维数组实际是一维数组的嵌套

    var arr=[ ​ [1,2,3],//arr[0]第一个元素 ​ [4,5],//arr[1]第二个元素 ​ [7,8,9]//arr[2]第三个元素 ​ ] ​ //二维数组的遍历 ​ ​ for(var i=0;i<arr.length;i++){ ​ for(var j=0;j<arr[i].length;j++){ ​ document.write(arri+" "); ​ } ​ document.write(" ") ​ }

     // 冒泡排序:两两比较,每趟找出最大或者最小的一个数值
            // 趟数:N-1
            // 次数:N-1-i
            
             var arr=[5,6,7,4,8,3,9,2,0,1];
             var t;
             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]){
                t=arr[j];
                        arr[j]=arr[j+1];
                    arr[j+1]=t;//实现交换
                    }
                }
             }
             console.log(arr);
    ​
    ​
            
            /*
                    5,6,7,4,8,3,9,2,0,1 初始数据 
                    
                    模拟第0趟比较  交换9次
                    5,6,7,4,8,3,9,2,0,1
                    5,6,7,4,8,3,9,2,0,1
                    5,6,4,7,8,3,9,2,0,1
                    5,6,4,7,8,3,9,2,0,1
                    5,6,4,7,3,8,9,2,0,1
                    5,6,4,7,3,8,9,2,0,1
                    5,6,4,7,3,8,2,9,0,1
                    5,6,4,7,3,8,2,0,9,1
                    5,6,4,7,3,8,2,0,1,              9   
                    
                    第1趟交换  交换8次
                    
            */

     选择排序
    ​
    
    

     var arr=[7,8,6,2,10,3];
        // 核心:外层循环N-1次
        // 内层:循环N-1-i次
    ​
        // 思路:i控制指定位置
        // k控制目标位置
        // k=i;用k来查找目标位置
        // 最后交换arr[k]和arr[i];
        // 每趟交换一次,找到最大(最小)的数,然后放到目标位置,进行下标交换;
    ​
         var t,k;
        for(var i=0;i<arr.length-1;i++){//趟数
            k=i;  //控制目标位置
            for(var j=i+1;j<arr.length;j++){//次数
        if(arr[k]>arr[j]){
        k=j;  //下标交换,相当于找到目标位置,与指定位置交换下标
            }
           }t=arr[i];
            arr[i]=arr[k];
            arr[k]=t;
         }console.log(arr);
    ​