数组以及常见api

day06

一：数组的概念：

数组用来存储一组数据。类似于数学概念中的集合。

是一个引用类型的数据,存储时，有两块空间，一块存地址，一块存数据

二：数组的定义

2·1：构造方法

new 在内存中开辟空间

2.1.1:无参的构造函数

var a1=new Array();
//返回的是一个空的数组

2.1.2:一个参数的构造函数

var a2=new Array(5);
//创建指定长度的数组（由于数组长度可以动态调整，作用并不大）

2.1.3:带有初始化数据的构造函数

//返回的是new出来空间的地址
var arr = new Array(1,2,3);
//创建数组并初始化参数数据

2·2：字面量

2·2·1：创建空数组（等同于调用无参构造函数）

var a4=[];

2·2·3：初始化数据（等同于调用带有初始化数据的构造函数）

var a5=[10];
//只有一个元素为10

【注意:】引用类型的存储方式，以及索引的思维

三：数组的元素访问

语法：数组名[下标];

数组的下标又叫数组的索引值,一般通过索引来访问数组中任意元素。

• 下标是基于零开始的 ,千万不要越界访问
• 下标是一个连续的整数，下标最大取值是“长度-1”
• 下标可以是一个变量或者是一个表达式

var arr = [6,5,7,4,8];
	 var n = 2;
	 console.log(arr[n]);

四：数组的遍历

4·1.遍历：

操作数组时，每个元素都要操作一遍，这个时候我们会用循环来访问每一个元素，循环访问数组的每一个元素的过程就叫做数组的遍历。

【注意】:数组的长度：arr1.length

4·2.循环遍历的方式：

方式一：for循环遍历

//
var arr=[1,2,1,3,4,5];
for(var i=0; i<arr.length; i++){
		console.log(arr[i]);
	}

方式二：for…in…遍历 【遍历数组的下标】

该遍历方法主要用于JSON对象

var arr=[1,2,1,3,5,4];
for(var index in arr){
		console.log(arr[index]);//打印0,1,2,3,4,5
	 }

[注意]：如果对没有的下标,进行赋值，则等价于添加新元素

var arr=[1,2,1,3,5,4];
//如果对没有的下标,进行赋值，则等价于添加新元素
 arr["heihei"] = 999;
 for(var index in arr){
	console.log(arr[index]);//打印1,2,1,3,4,5,999
     console.log(index)//打印0,1,2,3,4,5，下标
 }

方式三：for…of…遍历【遍历数组的内容】

var arr=[1,2,1,3,4,5];
for(var item of arr){
	 	console.log(item);//打印1,2,1,3,4,5
	 }

五：数组的API

5·1：API的学习方法

• 函数的功能
• 函数的参数
• 函数的返回值
• 参考文档

5·2数组常见API

• 尾插（一个或多个）—> push(参数1 ，[参数2…参数N]) —>返回数组的新长度

  var arr = [1,2,3];
  var len = arr.push(999,888,777);//1,2,3 ,999 ,888, 777,
  

• 尾删 —> pop（）—>删除最后一个元素并返回被删除的元素

  var arr = [1,2,3];
  var x = arr.pop();//1,2
  

• 头插（一个或多个）—> unshift(参数1 , [参数2…参数N] ) —>返回数组的新长度

  var arr = [1,2,3];
  arr.unshift(111);//111,1,2,3
  

• 头删 —> shift（）—>删除第一个元素并返回被删除的元素

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

• 删除或添加若干个元素—> splice(参数1，参数2，[参数3]) —>返回一个由删除元素组成的新数组

  参数1:开始索引

  参数2:删除元素的位移

  参数3:插入的新元素，当然也可以写多个(可省略)

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

• 数组转字符串 —>join([分隔符号])—>返回值为转换后的字符串

  	 var arr = [6,5,7,4,8];
  	 var str = arr.join("*");
  	
  	 console.log(typeof str);//string
  	 console.log(str);//6*5*7*4*8
  

• 截取子数组—> slice(起始位置下标，结束为止) —>返回截取的子数组 左闭右开

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

• 拼接数组—> concat(数组) —> 返回一个新数组（不修改原数组的内容）

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

• 将数组逆序 —> reverse( ) —> 无返回值,直接改变原数组

  	 var arr = [6,5,7,8,4,9];
  	 arr.reverse();
  	 console.log(arr);//9,4,8,7,6,5
  

• 排序 —> sort( ) —> 返回排序(小-大)后的数组,且原数组发生改变

  var arr = [11,6,5,7,8,4,9];
  	arr.sort();
  	console.log(arr);//打印11,4,5,6,7,8,9
  

六：二维数组

二维数组的本质就相当于一维数组的嵌套循环

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

七：数组的排序

7·1：冒泡排序

趟:N-1
次:N-1-i
冒泡：
    var a = [6,5,4,7,3,8,2,9,1,0];
    var t;
    for(var i=0; i<a.length-1; i++){
        for(var j=0; j<a.length-i-1; j++){
            if(a[j]>a[j+1]){
                t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    }

   for(var i=0;i<a.length; i++){
       console.log(a[i]);
   }

7·2：选择排序

 var a = [6,5,4,7,3,8,2,9,1,0];
    var t;
    //记录目标位置
    var k;
    for(var i=0; i<a.length-1; i++){
        k = i;
        for(var j=i+1; j<a.length; j++){
            if(a[k]>a[j]){
                k = j;
            }
        }
        t = a[i];
        a[i] = a[k];
        a[k] = t;
    }

ar t;
//记录目标位置
var k;
for(var i=0; i<a.length-1; i++){
k = i;
for(var j=i+1; j<a.length; j++){
if(a[k]>a[j]){
k = j;
}
}
t = a[i];
a[i] = a[k];
a[k] = t;
}