JavaScript数组笔记

数组创建的方式

• 通过构造函数的方式创建数组
  语法：var 数组名 =new Array();
  （1）var array=new Array()表示空数组
  （2）var array=new Array(数字)数字代表长度，如var array=new Array(5)数组有五个元素，长度为5，每个数据都为undefined
  （3）var array=new Array(多个值)表示这个数组有了数据，数组的长度为这些数据的个数
• 通过字面量的方式创建数组
  语法：var 数组名=[]
  （1）var array=[]表示空数组
  （2）var array=[数据1,数据2,数据3,....]

数组的属性

• 获取数组的长度
  （1）数组名称['length']
  （2）数组名称.length
• 规律
  （1）最后一份数据的长度-1，长度减一就是最大的索引值
  （2）没有数据是undefined
  （3）在数组最后添加数组arr.length='新数据'

数组的方法

• push() 后添加，可添加一个或多个值
• pop() 后删除一个，有返回值，可用变量接收
• shift() 前删除一个，有返回值，可用变量接收
• unshift() 前添加，可添加一个或多个值
• join() 转换为字符串，可以传入字符串进行分割
• concat() 用于连接（合并）两个或者多个数组，合并后的数据通过变量接收返回值，返回新的数组

（1）在原有的数据合并数组

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

（2）合并到新的数组

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

• reverse() 颠倒数组顺序

• slice()
  （1）slice(开始位置) 数据截取，传入一个参数，裁切到最后，不影响原数组
  （2）slice(开始位置,结束位置)不包含结束位置

• splice()
  （1）splice(开始位置) 数据劈取，传入一个参数，劈取到最后，影响原数
  （2）splice(开始位置,个数)从哪个开始劈取，劈取几个数据
  （3）ssplice(开始位置，个数，添加数据)从哪里开始劈取，劈取几个数据，并在开始劈取的位置添加数据

• sort() 数组排序

//从小到大排序
arr.sort(function(a,b){
	return a-b;
})

• indexOf()
  获取数据在数组的索引值（正顺取数据）
  （1）查找不到数据返回-1
  （2）arr.indexOf('数据',开始的位置)

• lastIndexOf()
  （1）倒序查找第一个数据的所在的索引值
  （2）arr.lastIndexOf('数据',开始的位置)

• from() 将伪数组变成数组，就是只要有length的就可以转成数组。

• forEach(callback) 遍历数组，无return
  callback的参数：
  value 当前索引的值
  index 当前索引
  array 原数组

let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
        console.log(`value:${value}    index:${index}     array:${array}`)
    })   
    //  value:1    index:0     array:1,2,3,4,5
    //  value:2    index:1     array:1,2,3,4,5
    //  value:3    index:2     array:1,2,3,4,5
    //  value:4    index:3     array:1,2,3,4,5
    //  value:5    index:4     array:1,2,3,4,5

• map(callback) 映射数组，有return
  callback的参数：
  value 当前索引的值
  index 当前索引
  array 原数组

   var arr = new Array(10, 20, 30, 50, 60);
    let arr1 = arr.map((v) => {
        return v + 1;
    })
    console.log(arr1);  //[11,21,31,51,61]

• filter(callback)过滤数组，返回一个满足要求的数组

 //箭头函数不带{}，自带return作用，有返回值
    var arr = new Array(10, 20, 30, 50, 60);
    let arr1 = arr.filter((i, v) =>
        i < 50
    )
    console.log(arr1);

• findIndex()返回第一个符合条件的数组成员的位置，如果所有成功都不符合条件，则返回-1

[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) // 2

• reduce(callback,initalValue)
  参数： callback: previousValue 必选 --上一次调用回调返回的值，或者是提供的初始值（initialValue）
  　　　　　　　　　　currentValue 必选 --数组中当前被处理的数组项
  　　　　　　　　　　index 可选 --当前数组项在数组中的索引值
  　　　　　　　　　　array 可选 --原数组
  　　　　　initialValue: 可选 --初始值

let arr = [0,1,2,3,4]
let arr1 = arr.reduce((preValue, curValue) => 
    preValue + curValue
)
console.log(arr1)    // 10

let arr2 = arr.reduce((preValue,curValue)=>preValue + curValue,5)
console.log(arr2)    // 15

清空数组的方法

• arr.length=0;将数组的长度设置为0
• arr.splice(0);将数组从开始位置劈取
• arr=[];将数组重新赋值，赋予空值

倒序数组

第一种方法

    var arr = new Array(10, 20, 30, 40, 50);
    var newArr = [];
    for (var i = arr.length - 1; i >= 0; i--) {
        newArr.push(arr[i])
    }
    console.log(newArr);

第二种方法

    var arr = new Array(10, 20, 30, 40, 50);
    console.log(arr.reverse());

翻转数组

第一种方法

    var arr = new Array(10, 20, 30, 40, 50);
    for (var i = 0; i < arr.length / 2; i++) {
        var temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
    console.log(arr);

第二种方法

    var arr = new Array(10, 20, 30, 40, 50);
    var newArr = [];
    for (var i = arr.length - 1; i >= 0; i--) {
        newArr[newArr.length] = arr[i]
    }
    console.log(newArr);

第三种方法

    var arr = [1, 2, 3, 4];
    var cloneArr = arr.slice();;
    var newArr = [];
    var i = 0;
    while (i < cloneArr.length) {
        newArr.push(arr.pop());
        i++;
    }
    console.log(newArr);

冒泡排序

    var arr = new Array(100, 10, 5, 20, 1, 30, 100, 40, 50);
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);

sort排序

    var arr = new Array(10, 5, 100, 500, 68, 37856, 1, 2, 20);
    console.log(arr.sort(function (x, y) {
        return x - y;
    }));

快速排序

function quick(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    var mid = Math.floor(arr.length / 2);
    var midNum = arr.splice(mid,1);
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if(arr[i]<midNum){
            left.push(arr[i])
        }else{
            right.push(arr[i])
        }
    }
    return quick(left).concat(midNum,quick(right));
}
console.log(quick([10,20,1,3,5]));

数组去重

• 第一种方法

    var arr = new Array(10, 20, 30, 20, 20, 60, 50, 50, 50, 10);
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (newArr.indexOf(arr[i]) == -1) {
            newArr.push(arr[i]);
        }
    }
    console.log(newArr);

• 第二种方法

    var arr = new Array(10, 20, 30, 20, 20, 60, 50, 50, 50, 10);
    var newArr = [arr[0]];
    for (var i = 0; i < arr.length; i++) {
        var isTrue = false;
        for (var j = 0; j < newArr.length; j++) {
            if (arr[i] === newArr[j]) {
                isTrue = true;
                break;
            }
        }
        if(!isTrue){
            newArr.push(arr[i])
        }
    }
    console.log(newArr);

第三种方法

    var arr = new Array(10, 20, 30, 20, 20, 60, 50, 50, 50, 10);
    var sortArr = arr.sort();
    var newArr = [];
    for (var i = 0; i < sortArr.length; i++) {
        if (sortArr[i] !== sortArr[i + 1]) {
            newArr.push(sortArr[i])
        }
    };
    console.log(newArr);

第四种方法

    var arr = new Array(10, 20, 30, 20, 20, 60, 50, 50, 50, 10);
    console.log(Array.from(new Set(arr)));

第五种方法

    var arr = new Array(10, 20, 30, 20, 20, 60, 50, 50, 50, 10);
    var obj = {};
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if(!obj[arr[i]]){
            obj[arr[i]]=1;
            newArr.push(arr[i])
        }
    }
    console.log(newArr);

数组克隆（深拷贝数组）

第一种方法

    var arr = new Array(10, 20, 30);
    var newArr = arr.slice();
    console.log(newArr);

第二种方法

   var arr = new Array(10, 20, 30);
    var newArr = [];
    newArr = newArr.concat(arr);
    console.log(newArr);

第三方方法

    var arr = new Array(10, 20, 30);
    var newArr = [];
    arr.forEach(function (v) {
        newArr.push(v)
    })
    console.log(newArr);

第四种方法

    var arr = new Array(10, 20, 30, 40);
    var [...newArr] = arr;
    console.log(newArr);

数组解构

• 解构赋值概念
  解构赋值允许你使用类似数组或对象字面量的语法将数组和对象的属性赋给各种变量。这种赋值语法极度简洁，同时还比传统的属性访问方法更为清晰。

    var [first, second, third] = [1, 2, 3]
    console.log(first);       //1
    console.log(second);  //2
    console.log(third);	 //3
    
//对应位留空来跳过被解构数组中的某些元素：
    var [, , third] = [1, 2, 3];
    console.log(third);
    
//“不定参数”模式捕获数组中的所有尾随元素
    var [... arr] = [1, 2, 3];
    console.log(arr);  //[1,2,3]
    
    var [first, ...arr] = [1, 2, 3];
    console.log(arr); //[2,3]
    
//交换变量
    let a = 1;
    let b = 2;
    console.log(a,b);	//1,2
    [a,b]=[b,a];
    console.log(a,b);	//2,1
    
//解构嵌套函数
      let arr = [ 10, [ 20, 30 ], 40 ];
        console.log( arr[1][1] ); //30
         let [ one, two, three, four ] = arr;	
         console.log( one, two, three, four ); //10 [20, 30] 40 undefined
         [ one, [ two, three ], four ] = arr; //前面不要let,否则会报重定义错误
         console.log( one, two, three, four ); //10 20 30 40
         
//数组的合并
    var arr1 = [1, 2];
    var arr2 = [3, 4];
    var arr = [...arr1, ...arr2];
    console.log(arr);

数组随机排序

第一种方法

    var arr = new Array(10, 20, 20, 30, 30, 40, 40);
    for (var i = 0; i < arr.length; i++) {
        var num = parseInt(Math.random() * arr.length);
        var temp = arr[i];
        arr[i] = arr[num];
        arr[num] = temp;
    }
    console.log(arr);

第二种方法

    var arr = new Array(10, 20, 20, 30, 30, 40, 40);
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        var num = parseInt(Math.random() * arr.length);
        newArr.push(arr[num]);
    }
    console.log(newArr);

第三种方法

    var arr = new Array(10, 20, 20, 30, 30, 40, 40);
    arr.sort(function(){
        return Math.random()-0.5;
    })
    console.log(arr);

字符串的方法

• .concat() 连接字符串
• .indexOf()查找字符串出现的位置
  （1）查得到：返回数据出现的索引值
  （2）查不到：返回-1
• .charAt()根据索引值获取单个字符
• .toUpperCase()转换成大写
• .toLowerCase()转换成小写
• .split('分割字符串')字符串转数组
• .replace(要替换的字符串，新字符串)

	/规则/  字符串规则
	g 全局替换（global）
    var str = 'aa-bb-cc-dd';
    var newStr=str.replace(/-/g,'_');
    console.log(newStr);

• .slice(开始位置，结束位置) 不包含结束位置，字符串裁切
• .substring(开始位置，结束位置) 不包含结束位置 字符串裁切
• .substr(开始位置，个数) 字符串裁切
• .trim()去除字符串首尾空格
• .repeat(n) 将原字符串重复n次

找出以上字符串中出现次数最多的字符和出现的次数

第一种方法
（1）将字符转换成数组
（2）创建空对象
（3）遍历数组，判断这个对象是否包含数组里面的数据，包含则索引加一，不包含则赋予一
（4）创建两个变量，一个存储字符串，一个存储出现的次数
（5）遍历对象，判断若键大于存储出现的次数，则将值赋予它

    var str = 'abaasdffggghhjjkkgfddsssss3444343';
    var arr = str.split('');
    var obj = {};
    for (var i = 0; i < arr.length; i++) {
        if (obj[arr[i]]) {
            obj[arr[i]]++
        } else {
            obj[arr[i]] = 1
        }
    }
    console.log(obj);
    var maxStr = '';
    var maxNum = 0;
    for (var key in obj) {
        if (obj[key] > maxNum) {
            maxStr = key;
            maxNum = obj[key];
        }
    }
    console.log('出现最多的字符为' + maxStr + ',' + '次数为' + maxNum);

第二种方法
（1）将字符串转换成数组
（2）定义一个变量存储去重后的字符串，定义一个变量存储出现的次数
（3）遍历数组
（4）克隆存储变量出现次数的数组
（5）将存储次数的数组从大到小排序
（6）取出第一个数据，则为出现次数最多的数据
（7）根据取出来的数据在原数组得到索引，然后再存储去重后的变量取出字符

    var arr = str.split('');
    var numArr = [];
    var strArr = [];
    for (var i = 0; i < arr.length; i++) {
        var index = strArr.indexOf(arr[i]);
        if (index == -1) {
            strArr.push(arr[i]);
            numArr.push(1)
        } else {
            numArr[index]++;
        }
    }
    console.log(numArr, strArr);
    var [...cloneArr] = numArr;
    var rankArr = numArr.sort(function (a, b) {
        return b - a;
    });
    var maxNum = rankArr[0];
    var maxIndex = cloneArr.indexOf(maxNum);
    var maxStr = strArr[maxIndex];
    console.log('出现最多的字符为' + maxStr + ',' + '次数为' + maxNum);