【JS】Day06

GreatWillSSS

已于 2022-11-04 10:14:04 修改

阅读量60

点赞数

分类专栏：二阶段文章标签： html5

于 2022-11-01 19:32:50 首次发布

本文链接：https://blog.csdn.net/qq_62417130/article/details/127622106

版权

二阶段专栏收录该内容

34 篇文章 0 订阅

订阅专栏

学习内容

冒泡排序
选择排序
数组方法
lastIndexOf

冒泡排序

/*
    1. 从小到大排列
    2. 冒泡排序：相邻的两个数，进行比较，符合条件，交换位置 

    9    6     6    4    2
    6    9     4    2    4
    15   4     2    6
    4    2     9
    2    15
*/

//声明一个数组
var arr = [9,6,15,4,2];
function fnBubbleFromSmallToBig(arr){
//比较的轮数
for(var i = 1;i < arr.length;i ++){
    //遍历数组
    for(var j = 0;j < arr.length - i;j ++){
        if(arr[j] > arr[j + 1]){
            var t = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = t;
        }
    }
}
return arr;
}
console.log(fnBubbleFromSmallToBig(arr));

/*
    1. 当有多个数据需要排序时，才使用排序算法。
    2. 多个数据，放到数组
    3. 冒泡排序：相邻的两个数，进行比较，符合条件，交互位置。
    4. 操作数据，必须先从数组中取出数据，遍历-循环-三要素（i = 0;i <  i ++);
    5. 目标：从小到大排列。
    6. 比较的轮数：轮数比数组长度少一次
    9
    6
    15
    4
    2    

*/
//声明数组
var arr = [9,6,15,4,2];
//比较轮数
//                 5        1    2    3    4  
for(var j = 1;j < arr.length;j ++){
    //遍历数组，取出元素
    for(var i = arr.length - 1;i >= j; i --){
        //进行比较
        if(arr[i] < arr[i - 1]){
            var t = arr[i];
            arr[i] = arr[i - 1];
            arr[i - 1] = t;
        }
    }
}
console.log(arr);

选择排序

/*
    选择排序：取一个元素 与 剩下的所有元素 进行比较 符合条件 交换位置 
    2    4    6    9    15

*/
var arr = [9,6,15,4,2];
function fnSelectSortFromSmallToBig(arr){
//取元素 遍历
for(var i = 0;i < arr.length - 1;i ++){  //0  1  2   3
    //取元素 遍历
    for(var j = i + 1;j < arr.length;j ++){  //4 
        //比较
        if(arr[i] > arr[j]){
            //交换位置
            var t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
}
return arr;
}
console.log(fnSelectSortFromSmallToBig(arr));

function fnSelectSortFromBigToSmall(arr){
    for(var i = 0;i < arr.length - 1;i ++){
        for(var j = i + 1;j < arr.length;j ++){
            if(arr[i] < arr[j]){
                var t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
    }
    return arr;
}

数组方法

//前增
/*
unshift(元素,元素,……)
作用: 在数组前面添加元素。
返回值: 返回新增后数组的长度
是否影响原数组: 是
*/
var arr  =  [5,6,7,8,9];
console.log(arr.unshift(true,[1,2],false));
console.log(arr);

//后增
/*
push(元素,元素,……)
作用: 在数组后面添加元素。
返回值: 返回新增后数组的长度
是否影响原数组: 是
*/
var arr  =  [5,6,7,8,9];
console.log(arr.push(true,[1,2],false));
console.log(arr);

//前删 (一次只能删一次)
/*
shift()
作用: 删除数组中第1个元素
返回值: 被删除的元素
是否影响原数组: 是
*/
var arr  =  [5,6,7,8,9];
console.log(arr.shift());
console.log(arr);

//后删 (一次只能删一次)
/*
pop()
作用: 删除数组中最后一个元素
返回值: 被删除的元素
是否影响原数组: 是
*/
var arr  =  [5,6,7,8,9];
console.log(arr.pop());
console.log(arr);

//如何删除全部
var arr  =  [5,6,7,8,9];

//不确定循环次数
//while, do while
while(arr.length) arr.pop();
console.log(arr);

//改
/*
splice(start,delLength,newEle,newEle,……)
start: 从哪个下标位置开始
delLenght: 删除几个元素
newEle: 新元素
作用: 在数组的任意位置进行增、删、改的操作。
返回值: 被删除的元素数组
是否影响原数组: 是
*/

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

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

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

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

var arr  =  [5,6,7,8,9];
console.log(arr.splice(1,0,true,false)); //[]
console.log(arr); //[5,true,false,6,7,8,9]

//截
/*
slice(start,end)
start: 从哪里开始 (包含)
end: 到哪里结束 (不包含)
作用: 截取数组中指定范围的元素
返回值: 被截取到的元素数组
是否影响原数组: 否
*/
var arr = [5,6,7,8,9];
console.log(arr.slice(1)); //[6,7,8,9]
console.log(arr.slice(1,4)); //[6,7,8]
console.log(arr.slice(4,1)); //[]
console.log(arr.slice(-4,-1)); //[6,7,8]
console.log(arr.slice(0,-1)); //[5,6,7,8]
console.log(arr.slice(0,arr.length - 1)); //[5,6,7,8]
console.log(arr); //[5,6,7,8,9]

//拼
/*
concat(newEle,newEle,……)
作用: 将新元素拼接到指定数组的末尾。
(如果新元素是一个数组，则去掉最外层的[]，将里面的内容进行拼接)
返回值: 拼接后的新数组
是否影响原数组: 否
*/

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

//复 (面试题: 至少写两种复制数组的方法)
var arr = [5,6,7,8,9];

function fnCopyArr(arr){
    return arr.slice(0);
}
function fnCopyArray(arr){
    return arr.concat();
}
function fnCloneArr(arr){
    var list = [];
    for(var i = 0,len = arr.length;i < len;i ++){
        list[i] = arr[i];
    }
    return list;
}
console.log(fnCopyArr(arr));
console.log(fnCopyArray(arr));
console.log(fnCloneArr(arr));

//逆序排
/*
reverse()
作用: 将数组元素逆序存放
返回值: 逆序后的数组
是否影响原数组: 是
*/
var arr = [5,6,7,8,9];
console.log(arr.reverse()); //[9,8,7,6,5]
console.log(arr); //[9,8,7,6,5]

//按编码排
/*
sort()
作用: 将数组中的元素按字符编码从小到大排序
返回值: 排序后的数组
是否影响原数组: 是
sort(function(a,b){return a - b;}): 按数字从小到大排序
sort(function(a,b){return b - a;}): 按数字从大到小排序
*/
var arr = [3,2,10,20,11];
//console.log(arr.sort()); //[10, 11, 2, 20, 3]
//console.log(arr); //[10, 11, 2, 20, 3]
//数组元素按照数字从小到大排列
console.log(arr.sort(function(a,b){return a - b;}));
//数组元素按照数字从大到小排列
console.log(arr.sort(function(a,b){return b - a;}));

//转
//toString() (面试题：不是数组的方法，是Object对象的方法，数组继承到的方法)
/*
数字.toString(2-36): 将数字转为指定进制的字符串
数组.toString(): 将数组转为字符串
*/
var arr = [1,2,3,4,5];
console.log(arr.toString());
console.log(arr);

//join ('连接符')
/*
作用: 将数组转为以指定连接符连接成的字符串
返回值: 字符串
是否影响原数组: 否
*/
var arr = [1,2,3,4,5];
console.log(arr.join(''));
console.log(arr);

var obj = {};
console.log(obj);
console.log(obj.toString());
alert(obj);
alert(obj.toString());

var i = 10;
console.log(i.toString(2)); //'1010'
console.log(i.toString(8)); //12
console.log(i.toString(16)); //'a'

//ES5新增 (都不会影响原数组)
/*
indexOf(元素,start): 查找元素在数组中第一次出现的下标位置，如果没有，则返回 -1
lastIndexOf(元素,start) : 查找元素在数组中从右向左查找第一次出现的下标位置，如果没有找到，返回 -1
*/
        // 0 1 2 3 4 5 6  7 8
var arr = [1,2,1,2,3,2,12,2,4];
console.log(arr.indexOf(2)); // 1
console.log(arr.indexOf(22)); //-1
//第一个参数是查找的元素
//第二个参数是从哪个下标位置开始向右查找
console.log(arr.indexOf(2,2)); // 3
//第二个参数是从哪个下标位置开始向左查找
console.log(arr.lastIndexOf(2)); //7
console.log(arr.lastIndexOf(2,7)); //7
console.log(arr.lastIndexOf(2,6)); //5

//forEach(function(value,index,array){}): 遍历数组
var arr = [1,2,3,4,5,6];
var sum = 0;
arr.forEach(function(value,index){
    //value: 代表数组中的每一个元素
    //index: 代表数组中的每一个下标
    //sum += value;
    console.log('下标:' + index,'元素：' + value);
})
alert(sum);

//map(function(value,index,array){return ...}): 映射 (一一映射) 遍历数组，返回数组
var list = arr.map(function(value,index){
    return value + 1;
})
console.log(arr,list);

//every(function(value,index,array){return ...}): 检测数组中每一个元素，如果有一个元素的条件返回false时，则直接退出循环，返回false; 如果所有元素都返回true时，最终返回true
var arr = [100,99,89,95,98];
var bool = arr.every(function(item){
    console.log(item);
    return item >= 90;
})
console.log(bool);

//some(function(value,index,array){return ...}): 检测数组中每一个元素，如果有一个元素的条件返回true，则直接退出循环，返回true; 如果所有元素都返回false时，最终返回false
var boo = arr.some(function(value){
    console.log(value);
    return value < 90;
})
console.log(boo);

//filter(function(value,index,array){return ...}): 过滤-条件，返回数组
var list = arr.filter(function(item){
    return item >= 90;
})
console.log(list);

//reduce(function(prev,next,index,array){return ...}): 归并
var arr = [100,99,89,95,98];
var sum = arr.reduce(function(prev,cur){
    console.log(prev,cur);
    //prev = 100,cur = 99
    //prev = 199,cur = 89
    //prev = 288,cur = 95
    //prev = 383,cur = 98
    //prev = 481,cur = 没有值了
    return prev + cur;
}); 

var sum = arr.reduce(function(prev,cur){
    console.log(prev,cur);
    //prev = 0,cur = 100
    //prev = 100,cur = 99
    //prev = 199,cur = 89
    //prev = 288,cur = 95
    //prev = 383,cur = 98
    //prev = 481,cur = 没有值了
    return prev + cur;
},0); //第二个参数: 是给prev的初始化值
console.log(sum);

lastIndexOf

//         0 1 2 3 4 5 6 7
var arr = [1,2,3,2,4,2,5,2];
// 从右向左查找，第一次出现的下标位置
console.log(arr.lastIndexOf(2));  //7
console.log(arr.lastIndexOf(2,5)); //5
console.log(arr.lastIndexOf(2,4)); //3

//遍历
// arr.forEach(function(value,index,array){

// })
console.log(arr.some(function(value){
    return value > 3;
}))