js第五天-CSDN博客

本文链接：https://blog.csdn.net/beibei_ya/article/details/128977426

数组

        //1.什么是数组?
        // 顾名思义:就是一组数据,可以是任意类型.


        //2.为什么要使用数组?
        //  让一个容器装更多任意类型的值


        //3.js数组的特点?
        // 1).可以存放任意类型
        var arr = [123, true, '你好'];
        // 2).数组可以动态的扩容,如果缩小空间,丢失数据
        var arr = [11, 22, 33];
        arr.length = 2;//这时候相当于删除了33
        arr.length = 10;
        console.log(arr);


        // 3).数组要通过下标获取元素,下标可以是数值,可以是其他的类
        //      如果不是下标,将不会被统计到length


        //       0  1  2
        var arr = [11, 22, 33];
        console.log(arr);
        console.log(arr[1]);  //通过下标取值
        arr[1] = "吴彦祖";  //通过下标覆盖元素,(通过下标设置值)



        arr[10] = "吴某凡"; //下标为10的数值,值为字符串,数组的长度发生了变化
        console.log(arr);


        // 数组也属于特殊的对象,不一定要通过下标设置值,也可以自定义key
        //  如果key不是数值类型,不会影响长度
        arr['height'] = 180;
        arr['weight'] = 200;
        console.log(arr);
        //4.遍历的方式
        var arr = [11, 22, 33];
        arr['a'] = "你好1";
        arr['b'] = "你好2";
        arr['c'] = "你好3";
        console.log(arr);
        //  1).数组可以通过for获取成员
        for (var i = 0; i < arr.length; i++) {
            console.log(arr[i]);
        }//这时候不会打印  你好1  你好2  你好3
        console.log('-----------');
        //  2).数组可以通过for ..in 获取成员
        for (var key in arr) {
            console.log(key, arr[key]);
        }
        //5.数组的创建方式
        //  1). '构造函数实例化',通过new 关键字
        var arr = new Array();


        //  2).数组的字面量表达式 (简写)
        // 看到中括号 '新数组'
        var arr = []; // new Array()


        //  3). 调用内置Array函数,返回结果
        var arr = Array();

数组中常见的函数

push()

push(): 接收任意数量的参数，把它们逐个添加到数组的末尾，并返回修改后数组的长度;

pop()

pop(): 从数组末尾移除最后一个元素，减少数组的 length 值，然后返回移除的元素;

shift()

shift(): 方法从数组前端移除一个元素,并返回移除的元素

unshift()

unshift(): 方法从数组前端添加一个或多个元素。

reverse()

reverse() : 逆向排序, 原数组也被逆向排序了,逆向排序方法，返回排序后的数组

sort()

sort() : 从小到大排序 , 原数组也被升序排序了,返回排序后的数组

//只能排序10以内的数，因为是按ASCII码计算的
//得加个函数

        // sort 排序
        //升序: 从小到大, 降序: 从大到小
        //sort 排序,默认是根据ASCII码,只能排0-9的值
        //sort 提供了一个回调函数(callback),对sort功能的扩展
        //a-b 升序,b-a 降序
        // 0-9 48-58
        // a-z 97-122
        // A-Z 65-90
        var arr = [11, 4, 3, 1, 6, 2, 8,];
      	// 用以下的方法可以排序10以外的数
        arr.sort(function (a, b) {
            // return a-b //升序
            return b - a //降序
        });
        console.log(arr);

concat()

concat() : 在数组末尾追加数据, 创建一个新数组, 不改变原数组

var arr = [2, 3, 4, ‘绿箭侠’, ‘黑寡妇’];
var arr2 = arr.concat(‘美队’, ‘雷神’);
console.log(arr);
console.log(arr2); //arr2是追加数据后的数组

       //concat  合并,数组的拷贝
        var arr1 = [11, 22, 33];
        var arr2 = ['A', 'B', 'C'];

      方法一
        // for(var i=0;i<arr1.length;i++){
        //      arr3.push(arr1[i]);
        // }
        // for(var i=0;i<arr2.length;i++){
        //     arr3.push(arr2[i])
        // }

      方法二
        // var  arr3=[].concat(arr1,arr2)


        // console.log(arr3);
        var arr1 = [11, 22, 33];
        var arr2 = ['A', 'B', 'C'];
        var arr3 = [];
        //concat 会返回一个新的数组(这里有合并之后的内容)
        var arr4 = arr3.concat(arr1, arr2);
        console.log(arr3 == arr4); //false
        console.log(arr3); // []
        console.log(arr4); // [11,22,33,'A','B','C']



        //拷贝
        var arr1 = ['A', 'B', 'C']; //
        var arr2 = [].concat(arr1);
        console.log(arr1);
        console.log(arr2);
        console.log(arr1 == arr2);//false

slice()

slice() : 不修改原数组, 将原数组中的指定区域数据提取出来

var arr = [2, 3, 4, "绿巨人"];
var arr2 = arr.slice(1, 3);  //并没有修改原数组,将原数组中的元素提取出来,生成新数组,
                            //  取的是下标在区域: [1,3)
	                          // 只有一个数  表示从这个数下标地方到数组的最后一个
console.log(arr);
console.log(arr2);//[3,4]

splice()

splice() : 截取原数组中指定的数据, 会改变原数组

splice() : 截取原数组中指定的数据, 会改变原数组
var arr = [2, 3, 4, '绿箭侠', '黑寡妇'];
var arr2 = arr.splice(2, 1);   //第一个参数代表我要开始截取的下标位置
			         //第二个参数截取的长度, 如果只有两个参数, 则表示删除操作
console.log(arr);     //[2, 3, '绿箭侠', '黑寡妇'];
console.log(arr2);   //4

splice() 详解:
插入: 如果有3个或以上参数,且第二个参数(长度)为0,则表示插入
arr.splice(1, 0, “绿巨人”, “冬兵”); //在下标为1的位置插入: "绿巨人","冬兵"

替换: 如果有3个或以上的参数, 且第二个参数(长度)不为0, 则表示替换
arr.splice(1, 1, “绿巨人”, “冬兵”); //在下标为1的位置替换成: "绿巨人","冬兵"

删除: 如果只有两个参数, 则表示删除指定区域的数据
arr.splice(0, 2); //删除原数组的部分数据, 并返回截取的数据

join()

//join  指定格式,返回一个新字符串,不会改变原来数组  默认以逗号连接
        var arr = [2022, 11, 19]; // '2022-11-19'
        console.log(arr.join('-'));
        console.log(arr.join('/'));
        console.log(arr);

join() : 连接数组中的元素, 并返回连接后的字符串, 不传参则以逗号连接
arr.join(“+”);

排序算法

常用的排序算法 (On2)

冒泡排序 (逐层冒泡)

选择排序（选择一个数跟其他的进行比较）

插入排序（在插入数据的时候的排序法）

希尔排序（快速插入排序）

快速排序（快速冒泡排序（数据量不大的情况下最快））

归并排序（大数据处理中最快的排序）

堆排序

桶排序

...

冒泡排序(On^2)

前一个跟后一个比较俩俩相比比较完就交换位置直到所有的内容比较完

function bubleSort(arr){
    //轮数
    for(var i=0;i<arr.length-1;i++){
        //比较的次数
        for(var j=1;j<arr.length-i;j++){
            //俩俩比较
            if(arr[j]<arr[j-1]){
                var temp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = temp
            }
        }
    }
    return arr
}

选择排序(On^2)

选择一个下标和所有的数进行比较如果比较完发现这个下标不是之前的下标就换位置

function selectorSort(arr){
    for(var i=0;i<arr.length-1;i++){
        //指定max为当前遍历的下标
        var max = i
        //max要跟其他的所有未排序比较
        for(var j=i+1;j<arr.length;j++){
            if(arr[max]<arr[j]){
                max=j
            }
        }
        //如果最大值不是原本的下标位置就需要交换位置了
        if(max!=i){
            var temp = arr[max]
            arr[max] = arr[i]
            arr[i] = temp
        }
    }
    return arr
}

快速排序（二分排序）Onlogn

function quikSort(arr) {
    //如果你的数组长度只有一个 或者没有就直接返回这个数组
    if (arr.length <= 1) {
        return arr
    }
    //中间值取第一个
    var mid = arr[0]
    //左右的容器
    var left = [],
        right = []
    //循环比较
    for (var i = 1; i < arr.length; i++) {
        arr[i] > mid ? right.push(arr[i]) : left.push(arr[i])
    }
    //递归调用无限取中间值
    return quikSort(left).concat(mid).concat(quikSort(right)) 
}