JavaScript基础—

JavaScript基础——数组

一、数组的介绍

　　1.概念：数据的集合，任何数据都可以放在数组中

　　2.作用：可以同时操作多个数据

　　3.数组的创建：

　　　　字面量：var arr = [ ];

　　　　构造函数：var arr = new Array( );　　　　　　　

var arr = [234,"hello"];
var arr2 = new Array(234,"hello");
console.log(arr);　　　　　　　　　　　　　　　　
console.log(arr2);　　　　　　　　　　　
console.log(arr == arr2); 　　　　　　　　　　//false 

// 任何两个数组都不相等

var arr = [6]; 
var arr2 = new Array(6); 
console.log(arr); 　　　　　　　　　　　　　　 //表示有一个数组成员的值是6
console.log(arr2); 　　　　　　　　　　　　　 //表示6个数组成员，每个成员的值是undefined
console.log(arr.length)；　　　　　　　　　　//1 
console.log(arr2.length)；　　　　　　　　　 //6 
//当只有一个数据且是数值时，字面量会在数组中保存这个数值;构造函数会将这个数值作为长度，多个数值时表示数组成员

二、数组的操作方法
　　1.push：在数组的最后新增一个或多个成员； arr.push(3,4,5,6,7,8,9) ；返回值：数组的长度

　　2.unshift：在数组的开头新增一个或多个成员；arr.unshift(3,4,5,6,7,8,9) ；返回值：数组的长度

　　3. pop：删除数组的最后一个数组成员；arr.pop( )；返回值：被删除的数组成员

　　4.shift：删除数组的第一个数组成员； arr.shift( )；返回值：被删除的数组成员

　　5.splice：用于修改数组，向数组中添加新成员，删除数组成员； splice(start,num,replaceData1,replaceData2,.....)

　　　　（注：start：起始位置新增或替换；num：删除几个成员；后面的参数是新增的成员或替换的成员）

　　　　　返回值：被删除成员的数组，若没有就是空数组

　　　　arr.splice(2,1)；删除指定位置

　　　　arr.splice(2,1,7)；删除并替换一个

　　　　arr.splice(2,1,7,8,9)；删除并替换多个

　　　　arr.splice(2,0,7)；在指定位置新增一个

　　arr.splice(2,0,7,8,9)；在指定位置新增多个

　　6.slice：截取数组成员；slice(n,m)：从索引n，截取到索引m的前一个；返回值：截取成员的数组

　　　　arr.slice(2)；从下标2开始截取到最后

　　7.sort：将数组按要求排序；返回值：排序后的数组

　　　　arr.sort(function(a,b){

　　　　　　return a-b　　　　//按升序排序

　　　　　　return b-a　　　　//按降序排序

　　　　})

　　8.concat：将两个数组合并拼接；返回值：合并的新数组

　　　　arr.concat([5,6,7,8])

　　9.join：以指定内容作为连接符将数组转为字符串；返回值：字符串

　　　　arr.join( )：默认连接符为”，“；

注：Es5新增的数组方法（ indexOf，forEach，map，filter，some，every，reduce，reduceRight）

　　特点：不改变原数组

1.indexOf：根据数组成员查索引

　　　　arr.indexOf( )：一个参数时，参数是数组成员；两个参数时，第一个参数为查询开始位置，第二个为数组成员

　　　　返回值：查询数组成员的索引，若没有该数组成员则返回 -1

2.forEach：遍历数组；返回值：没有返回值，可以通过声明变量并赋值得到数组的val,index,self

　　arr.forEach(function(val,idx,self){

　　console.log(val,idx,self)

　　});

3.map：遍历数组，同时操作数据，并返回到新数组中；返回值：操作后的新数组

　　 var arr1 = arr.map(function(val,idx,self){

　　　　return val *= 1.3;

　　})

4.filter：遍历数组，同时筛选数据，当返回值为true时，将当前这次回调函数的执行时拿到的值，返回到新数组中（过滤）

　　　返回值：筛选后的新数组

　　var arr1 = arr.filter(function(val,idx,self){

　　　　return val > 30;

　　})

　　5.some：判断数组中是否有符合条件的成员；返回值：有就返回true,没有就返回false　　　　

　　　　var res = arr.some(function(val,idx,self){

　　　　return typeof value === string";

　　})

　　5.every：判断数组中是否有符合条件的成员；返回值：都符合就返回true,否则就返回false　　　　

　　　　var res = arr.every(function(val,idx,self){

　　　　return typeof value === string";

　　})

总结：不改变原数组的方法：slice( ) indexOf( ) concat( )

三、数组的排序

 var arr = [5,2,6,1,4,9]
        //冒泡排序
            //1.确定循环比较几轮 ——————arr.length - 1
                for(var i = 0;i < arr.length-1;i++){
            //2.开始轮流比较 ——————每轮都比较出最大值，下一轮少比较一个，arr.length-1-i 
                    for(var j = 0;j < arr.length -1 -i;j++){
            //3.进行位置交换——————————将较大值放在较小值后面
                        if(arr[j] > arr[j+1]){
                            var ls = arr[j];
                            arr[j] = arr[j+1];
                            arr[j+1] = ls;
                        }
                    }
                }
                console.log(arr)

        //选择排序
            //1.确定循环比较几轮 ——————arr.length -1
                    for(var i = 0;i < arr.length -1;i++){
            //2.假设第一个数为最小值，记录数值和索引
                        var min = arr[i];
                        var minIndex = i;
            //3.拿第一个数依次与后面每个数比较 ——————每轮都比较出最小值，将最小值放在第一个位置
                        //下一轮最小值不用比较，每轮比较次数也相应减小——————arr.length
                        //每轮的第二个数是下一轮的第一个数，这个数不用和自身比较————i+1
                        for(var j = i+1;j < arr.length;j++){
                            if(min > arr[j]){
                                //记录较小值和索引
                                min = arr[j];
                                minIndex = j;
                            }
                        }
            //4.交换位置 
                        //先将较大值放在较小值位置上
                        arr[minIndex] = arr[i];
                            //再将最小值放在每轮第一个位置上
                            arr[i] = min;
                    } 
                    console.log(arr)

四、数组的应用

// 1.定义一个30项的数组，数组的每一项要求是1－10的随机数，每间隔5个数字，求出前五个数的平均值
    // 定义一个30项的数组
    var arr = [];
    for(var i=0;i<30;i++){
        arr.push(random(1,10))
    }
    console.log(arr)
    // 每间隔5个数字，
    // 0~5
    // 5~10
    // 10~15
    for(var i=0;i<arr.length;i+=5){
        var a = arr.slice(i,i+5);
        var num = avg(a);
        console.log(num);
    }

    function avg(myarr){
        var sum = 0;
        for(var i=0;i<myarr.length;i++){
            sum += myarr[i];
        }
        return sum 
    }
//2.二维数组随机数
    function Make(a,b){
        var arr1 = new Array();
        for(var i = 0;i < 5;i++){
            var arr = new Array();
            for(var j = 0;j < 5;j++){
                arr[j] = Math.round(Math.random(a,b) * (b-a) + a)
            }
            arr1.push(arr)
        }
        return arr1 
    }
    console.log(Make(3,8))

//3.编写函数map（arr）
    function map(arr) {
        var arr1 = [];
        for(var i = 0;i < arr.length;i++){
            arr1.push(parseFloat(arr[i] * 1.3).toFixed(1));
        }
        return arr1
    }
    var arr = [1,2,3,4,5];
    console.log(map(arr))

//4.编写函数has（arr，60）
     function has(arr,num){
         for(var i = 0;i < arr.length;i++){
             if(arr[i] === num){
                 return true
              }
         }
         return false
      } 
      var arr = [1,2,3,4,60] 
      console.log(has(arr,60))  

//5.编写函数norepeat（arr）
    function norepeat(arr) {
        var arr1 = [];
        for(var i = 0;i < arr.length;i++){
            if(!has(arr1,arr[i])){
                 arr1.push(arr[i])
            }
        }
        return arr1
     }
     var arr = [1,2,3,4,5,6,5,4,3,2,1]
     console.log(norepeat(arr))      

//6.编写add函数，要求插入一个数，按原来从小到大排序插入
     function add(arr,num){
         arr.push(num);
         arr.sort(function(a,b){
                return a-b
         }) 
         return arr
     }
     var arr = [1,2,3,4,6,7];
     console.log(add(arr,5))