JavaScript_Day_08 排序

最新推荐文章于 2024-08-12 09:24:46 发布
最新推荐文章于 2024-08-12 09:24:46 发布
阅读量1k 收藏
点赞数 1
文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64954239/article/details/121959793
版权

函数知识点小结：

函数：

1. 封装性，复用性，调用性；

2. 函数名  小驼峰 (首字母不要大写)；

形参：

1. 函数声明时的参数；

2. 用于接受实参的；

3. 本质上是局部变量；

 实参：

1.  函数调用时的参数；

2.  返回值  return；

3.  返回一个结果；

3.  结束整个函数；

              预编译  函数可以先调用后声明

              arguments 用于接受实参列表（伪数组）

              递归函数  自己调用自己

              构造函数  创建对象

              回调函数  ？

数组

创建方式2种：    [ ]    new Array(1,2,3,3)；

*  数组的长度 ，数组的下标

*  数组的长度和值可以随时被更改

数组的遍历

               for
               for in    遍历下标   主要是用于遍历对象（不适合数组）
               for of   遍历值

封装

              includes()   判断数组中是否存在某个值

              质数判断的假设法和是否存在的假设法做对比（到底flag为true还是false）

              join()    把数组变成字符串  (三目)    i < arr.length - 1 ? arr[i] + ',' : arr[i]

              push()  向数组尾部追加无数个  遍历arguments ，把数组的长度边长  arr[arr.length] = arguments[i]

              pop()  删除数组中最后一个值  创建一个新的数组  遍历原数组时丢掉最后一个  i < arr.length - 1

排序

冒泡排序： 

思路：相邻的做比较，大的就向后交换   arr[i] > arr[i+1]；

        function bubbleSort(arr) {  
            // 控制比较的轮数
            for(var i = 0 ; i < arr.length - 1 ; i++) {
                // 从头开始做比较（大数下沉）
                for(var j = 0 ; j < arr.length - 1 - i ; j++) {
                    if(arr[j] > arr[j + 1]) {
                        var t = arr[j] ;
                        arr[j] = arr[j + 1] ;
                        arr[j + 1] = t ;
                    }
                }
            }
            // console.log(arr);
            return arr
        }


        var arr2 = bubbleSort([8,6,4,3,2,10]);
        console.log(arr2);

选择排序：

思路：找到最小的数，放在前面；

        function selectSort(arr) {  
            // 控制比较的轮数
            for(var i = 0 ; i < arr.length - 1 ; i++) {
                // 假设第一个位置最小，与后面所有的数比较
                var min = i ;
                for(var j = i + 1 ; j < arr.length ; j++) {
                    // 拿第一个位置上的 数与后面所有的数做比较
                    if(arr[min] > arr[j]) {
                        // min 记录最小的角标
                        min = j ;
                    }
                }
                // 判断与假设是否相同
                if(min !== i) {
                    var t = arr[min] ;
                    arr[min] = arr[i] ;
                    arr[i] = t ;
                }
            }
            // console.log(arr);
            return arr
        }

        var arr2 = selectSort([8,6,4,3,2,10]);
        console.log(arr2);

验证码：

* 随机验证码，必须同时包含小写，大写和数字；

    <script>


        function rand(min , max) {  
            return parseInt(Math.random() * (max - min) + min)
        }

        function join(arr , f) {  
            var res = '' ;
            for(var i = 0 ; i < arr.length ; i++) {
                res += i < arr.length - 1 ? arr[i] + f : arr[i]
            }
            return res
        }

        // function randCode(n) {  
        //     // 默认4位
        //     n = n || 4 ;
        //     var res = '' ;

        //     var arr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ;


        //     for(var i = 0 ; i < 4 ; i++) {
        //         res += arr[rand(0,arr.length)]
        //     }
        //     console.log(res);
        //     return res ;
        // }


        function randCode(n) {  
            // 默认4位
            n = n || 4 ;
            var arr2 = [] ;

            var numArr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
            var bigArr = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] ;
            var smallArr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ;
            var allArr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ;

            // 从数字中去一个
            arr2.push(numArr[rand(0,numArr.length)]) ;
            // 从大写中去一个
            arr2.push(bigArr[rand(0,bigArr.length)]) ;
            // 从小写中去一个
            arr2.push(smallArr[rand(0,smallArr.length)]) ;
            for(var i = 0 ; i < n - 3 ; i++) {
                arr2.push(allArr[rand(0,allArr.length)])
            }

            // 以上顺序总是一样的
            console.log(arr2);

            // 打乱顺序,随机交换每个位置上的值
            for(var i = 0 ; i < arr2.length ; i++) {
                var j = rand(0 , arr2.length) ;
                var t = arr2[i] ;
                arr2[i] = arr2[j] ;
                arr2[j] = t ;
            }
            
            
            // document.write(join(arr2 , ''))
            return join(arr2 , '') ;
        }

        var res = randCode();
        document.write(res)

    </script>

数组的方法

数组的方法  push( ) 、  pop( ) 、  unshift( ) 、shift( )；

数组的常用方法：

          join()  把数组变成字符

          includes()  判断数组中是否存在某个

          indexOf()  判断数组中是否存在某个值，返回第一次出现的下标,找不到就返回-

          lastIndexOf()  判断数组中是否存在某个值，返回最后一次出现的下

          concat()   拼接数组，返回一个新的数

          slice(i,i)  截取数组中的部分值,返回一个新的数

          splice(i , 删除的个数 ， 新增的值...)  新增，删除，替换 --- 直接改变原数组   !!!!!!!

    <script>

        function includes(arr , n) {  
            for(var i in arr) {
                if(arr[i] === n) {
                    return true
                }
            }
            return false
        }

        function indexOf(arr , n) {  
            for(var i in arr) {
                if(arr[i] === n) {
                    return i
                }
            }
            return -1
        }

        function lastIndexOf(arr , n) {  
            // 假设找不到
            // var flag = -1 ;
            // for(var i in arr) {
            //     if(arr[i] === n) {
            //         flag = i
            //     }
            // }
            // return flag 

            for(var i = arr.length - 1 ; i >= 0 ; i--) {
                if(arr[i] === n) {
                    return i
                }
            }
            return -1
        }


        var arr = [1,2,3,4,2,5] ;
        var str = arr.join('&') ;
        console.log(str);

        console.log(arr.includes(20));

        console.log(arr.indexOf(2));

        console.log(arr.lastIndexOf(2));

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

        // slice(i , i)  截取数组中的值   (包前不包后)

        var arr4 = [1,2,3,4,5,6,7] ;
        var arr5 = arr4.slice(2,5);
        console.log(arr5);


        // splice(i , 删除的个数, 插入的值) 删除，替换，新增
        //   用法1：在任意位置插入数据
        //       arr.splice(i , 0 , v1 ,v2 , v3 ....)
        //   用法2：删除
        //      arr.splice(i , 删除的个数)
        //   用法3：替换
        //    

        var arr = [1,2,3,4,5] ;
        arr.splice(arr.length,0,'a','b','c') ;
        console.log(arr);

        // splice(i , 删除的个数)
        arr.splice(2 , 2);
        console.log(arr);

        // splice( i , 删除的个数 ， 替换的值...)
        arr.splice(3 , 3 , 'A' ,'B' , 'C');
        console.log(arr);
        arr.splice(2,0,'a')

    </script>

判断数组：

基本数据类型：number   string  boolean   null   undefined

基本数据类型可以通过 typeof 来判断；

引用数据类型：unction  数组   对象

       Array.isArray()  判断是不是数组

数组去重：

方法1：得到新的数组；

        var arr = [1,2,3,42,1,3,2,2,1,3,5] ;

        var newArr = [] ;
        // 遍历原数组
        for(var i in arr) {
            // 判断原数组中每一个值是否在新数组中存在
            // if(newArr.indexOf(arr[i]) === -1)
            // if(!newArr.includes(arr[i])) {
            //     newArr.push(arr[i])
            // }

            // 自己把includes方法写了一遍
            var flag = false ;  
            for(var j in newArr) {
                if(newArr[j] === arr[i]) {
                    flag = true ;
                    break ;
                }
            }
            if(!flag) {
                newArr.push(arr[i])
            }

        }

        console.log(newArr);

方法2：直接改变原数组

 //     对比，出现重复的就删掉

        //   拿第一个值出来跟后面所有的值作比较
        var arr = [1,2,3,42,1,3,2,2,1,3,5] ;
        
        // 比较的轮数
        for(var i = 0 ; i < arr.length - 1 ; i++) {
            // 拿第i个数与后面所有的数进行比较
            for(var j = i + 1 ; j < arr.length ; j++) {
                // 只要相同就删除
                if(arr[i] === arr[j]) {
                    // 没删除一个的时候，数组塌陷!!!!!!!!!!
                    arr.splice(j , 1);
                    j--;
                }
            }
        }

        console.log(arr);

数组统计：

        <script>

            // 统计每一个值出现的次数
            var arr = [1,2,3,42,1,3,2,2,1,3,5] ;

            // // 比较的轮数
            // for(var i = 0 ; i < arr.length ; i++) {
            //     var count = 0 ;
            //     // 拿每一个值与所有的值进行比较
            //     for(var j = 0 ; j < arr.length ; j++) {
            //         if(arr[i] === arr[j]) {
            //             count++ ;
            //         }
            //     }
            //     console.log(arr[i] + '出现了' + count + '次');
            // }


            // 方法1：先去重再统计
            // var arr2 = [] ;
            // for(var i = 0 ; i < arr.length ; i++) {
            //     if(!arr2.includes(arr[i])) {
            //         arr2.push(arr[i])
            //     }
            // } 
            // console.log(arr2);


            // // 拿新数组中的每一个值与原数组进行比较
            // for(var i = 0 ; i < arr2.length ; i++) {
            //     var count = 0 ; 
            //     for(var j = 0 ; j < arr.length ; j++) {
            //         if(arr2[i] === arr[j]) {
            //             count++
            //         }
            //     }
            //     console.log(arr2[i] + '出现了' + count + '次');
            // }


            // var arr = [1,2,1,3,2,3]

            // 方法2：一边删除一边统计
            for(var i = 0 ; i < arr.length ; i++) {
                // 拿第一个值与后面的值进行比较
                var count = 1 ;
                for(var j = i + 1 ; j < arr.length ; j++) {
                    if(arr[i] === arr[j]) {
                        count++ ;
                        arr.splice(j , 1) ;
                        j-- ;
                    }
                }
                console.log(arr[i] + '出现了' + count + '次');
            }
            console.log(arr);



            // 方法3：先排序，再统计
            var arr = [1,1,1,1,2,2,2,3,4,4];

            for(var i = 0 ; i < arr.length ;  ) {
                var count = 1 ;
                for(var j = i + 1 ; j < arr.length ; j++) {
                    if(arr[i] === arr[j]) {
                        count++ ;
                    }
                    else {
                        // 只要不相等说明后面没有相同 的了
                        break ;
                    }
                }
                console.log(arr[i] + '出现了' + count + '次');
                i += count
            }

        </script>

封装concat

   <script>

        // var arr1 = [1,2,3] ;
        // var arr2 = [6,7,8] ;

        // // [1,2,3,6,7,8]


        // var arr3 = [] ;

        // // 遍历第一个数组
        // for(var i in arr1) {
        //     arr3.push(arr1[i])
        // }

        // // 遍历第二个数组
        // for(var i in  arr2) {
        //     arr3.push(arr2[i])
        // }

        // console.log(arr3);



        // function concat(arr1 , arr2) { 
        //     var arr3 = [] ; 
        //     // 遍历第一个数组
        //     for(var i in arr1) {
        //         arr3.push(arr1[i])
        //     }

        //     // 遍历第二个数组
        //     for(var i in  arr2) {
        //         arr3.push(arr2[i])
        //     }

        //     console.log(arr3);
        // }

        function concat() { 
            var arr3 = [] ; 
           
            for(var i in arguments) {
                var arr = arguments[i] ;
                for(var j in arr) {
                    arr3.push(arr[j])
                }
            }

            console.log(arr3);
        }


        concat([1,2,3] , ['a' , 'b' ,'c'] , [4,5,7])


    </script>

回调函数

callback: 回调函数，把一个函数当做另一个函数的参数；

        function xunHuan(n , fn) {  
            for(var i = 0 ; i < n ; i++) {
                fn()
            }
        }

        xunHuan(5 , function(){
            document.write(1 + '<br>')
        })


        xunHuan(6 , function () {  
            console.log(666);
        })


        function ff() {  
            console.log(999);
        }


        xunHuan(10 , ff)

数组的迭代方法 

   <script>

        // forEach(function(v , i , arr){})   遍历数组

        var arr = [1,2,3,5,6,7] ;
        var sum = 0 ; 
        arr.forEach(function (v , i , arr) {  
            sum += v ;
        })
        console.log(sum);



        function forEach(arr , cb) {  
            for(var i = 0 ; i < arr.length ; i++) {
                cb(arr[i] , i)
            }
        }

        forEach([1,2,3] ,function (v , i) {  
            // console.log(666);
            console.log(v);
            console.log(i);
        })

        // 把数组中的每一个值加1

    </script>

         sort()   ASCII升序

         sort(function(a,b){return a - b})  升序

         sort(function(a,b){return b - a})  降

         forEach(function(v,i,arr){})  遍历数

         map(function(v,i,arr){})  改变数组中的值，返回一个新的数组  必须retur

         filter(function(v,i,arr){})  过滤器，找到满足条件的值，返回一个新的数

         every(function(v,i){})  判断数组中是不是每一个值都满足条

         some(function(v,i){})  判断数组中有没有满足条件的 


        var arr = [5,3,22,1,7] ;
        var res = arr.sort(function (a , b) {  
            return b - a
        })
        console.log(res);



        var arr = [5,3,22,1,7] ;
        arr.forEach(function (v, i) { 
            console.log(v); 
            if(i == 2) {
                // break ;   // 报错
                // return   没有任何意义
            }
        })

回调

    <script>

        // sort(函数)
        // var res = arr.sort(function(a,b){return a - b})

        // arr.forEach(function (v,i) {  })

        // 函数也可以是一个参数



        function fn(n) {  
            // console.log(n); // 函数
            n()
        }

        // fn(console.log(777))   // n is not a function


        // var a = console.log(777);
        // console.log(a);


        fn(function(){
            console.log();
        })


        function aa(arr , fn) {  
            for(var i = 0 ; i < arr.length ; i++) {
                fn(arr[i])
            }
        }


        aa([1,2,3] , function (v) {  
            console.log(v);
        })

    </script>

把数组中每个值+1

    <script>

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

        // for(var i = 0 ; i < arr.length ; i++) {
        //     arr[i] = arr[i] * 2 ;
        // }
        // console.log(arr);

        function aa(arr , cb) {  
            for(var i = 0 ; i < arr.length ; i++) {
                arr[i] = cb(arr[i]) ;
            }
            console.log(arr);
        }


        aa([2,3,4] , function (v) {  
            return v * 3
        })

    </script>

我喜欢大太阳
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaScript_day08-------＞js主要内容是数组的方法；回调函数等。
莫名的博客
12-15 1133
1.冒泡排序和选择排序的回顾 冒泡排序：相邻之间做比较，大的就向后交换 arr[ i ] > arr[ i + 1] //冒泡排序 //函数封装它 function bubbleSort(arr) { //控制比较的轮数 for(var i = 0 ; i < arr.length - 1 ; i++) { //从头开始做比较(大数下沉) for(var j = 0 ; j < arr.length...
javascript国际化_JavaScript国际化
cuk0051的博客
08-27 855
javascript国际化Intl is a powerful object that exposes the JavaScript Internationalization API. Intl是一个功能强大的对象，它公开了JavaScript国际化API 。 It exposes the following properties: 它公开了以下属性： Intl.Collator: g...
JavaScript_Day_09 (对象、商品搜索)
m0_64954239的博客
12-20 740
数组的基本方法： shift() pop() push() unshift() 直接改变原数组； 数组的常用方法： splice(i , howmany , v1 , v3 ...) 删除，替换，新增； includes() indexOf() join() 转换字符串 concat() 拼接数组，得到新的数组 数组的迭代方法： sort() forEach() 遍历数组 不能写返回值 m...
头条--黑马头条_day08
xiaorui的博客
04-19 1482
day08_爬虫系统搭建 目标 了解爬虫是什么 了解webmagic及其四大组件 了解爬虫系统中的ip代理 能够导入爬虫系统 知道文档下载和文档解析的思路 1爬虫是什么 网络爬虫（Web crawler)，是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本，它们被广泛用于互联网搜索引擎或其他类似网站，可以自动采集所有其能够访问到的页面内容，以获取或更新这些网站的内容和检索方式。从功能上来...
JavaWeb 05_JavaScript基础
weixin_64646820的博客
12-20 1061
JavaScript课程体系 —、JavaScript概述 1、什么是JavaScript 2、为什么要使用Javascript3、JavaScript运行环境 4、编写Javascript的语法结构5、变量定义与赋值 6、JavaScript数据类型 7、JavaScript中的基本类型转换8、JavaScript运算符有哪些9、函数定义与应用 10、JavaScript的注释二、Js循环语句 1、Javascript中的对象2、内置核心分类对象 三、掌握JavaScript中的数组对象 1、构造方法 2
JavaScript-day04
2201_75449897的博客
07-20 259
【代码】JavaScript-day04。
JS-JavaScript_简介及基本使用
qq_31455841的博客
09-27 1074
JS-JavaScript JQuery
javaScript Day01
cailianming的博客
11-11 724
1.概述 1.1什么是JavaScript JavaScript是一门世界上最流行的脚本语言 一个合格的后端人员，必须精通JavaScript 1.2历史 https://blog.csdn.net/kese7952/article/detalls/79357868 ECMAScript它可以理解为是JavaScript的一个标准 最新版本已经更新到es6版本 但是大部分浏览器还只停留在5版本 开发环境----线上环境版本不一致 2.入门 2.1引入JavaScript 1.内部标签
python的学习day_05
m0_74304371的博客
12-10 1667
python的学习day_05
JavaScript基础练习_day9
10-24
### JavaScript基础练习_day9知识点详解 #### 一、JavaScript基础概念与练习背景 - **标题**: “JavaScript基础练习_day9”表明本练习旨在帮助初学者巩固JavaScript基础知识，并通过实际编程练习来加深理解。 - *...
JavaScript基础练习_day12
10-27
### JavaScript基础练习_day12 #### 知识点概述 本篇练习主要涵盖了以下几个方面的JavaScript基础知识： 1. **数组操作**：使用数组进行循环、条件判断等基础操作。 2. **数学运算**：通过数学计算解决实际问题。...
work_day_scheduler
04-02
工作日程调度器（work_day_scheduler）是一款基于JavaScript编写的软件工具，主要用于帮助用户管理和规划他们的日常工作。在JavaScript这个强大的编程语言支持下，这个应用能够实现动态的时间块分配、事件提醒以及...
JavaScript_Projects:回购JavaScript项目
05-23
JavaScript_Projects到现在为止实施的项目如下：JavaScript30项目Day10：按住Shift复选框第11天：自定义视频播放器第12天：Konami代码第13天：在滚动条中滑入第14天：JavaScript参考与复制第15天：本地存储第16天：...
Arco Design for Vue 3 - 快速上手指南与实战技巧
qq_42072014的博客
08-11 419
如果你在使用 TypeScript 时遇到了类型定义问题，确保你安装了正确的类型包，并且版本与 Arco Design 的版本相匹配。Arco Design for Vue 3 是一个非常强大的 UI 框架，它不仅提供了丰富的组件和功能，还有完善的文档和支持。通过本文，你已经掌握了如何快速上手 Arco Design，并学会了一些实用的技巧来提升你的开发效率。希望这些经验能帮助你在 Vue 3 的开发过程中更进一步！
05_ Electron 自定义菜单、主进程与渲染进程通信
所学所思
08-09 584
单独写在一个 js 文件中，然后再在主进程中引入labe: "文件",submenu: [label: "新建文件",},label: "编辑",submenu: [label: "复制",},submenu: [// main.js// 1、引入初始化remote 模块width:800,})// __dirname 表示获取我们当前目录， path.join 会将两个参数合并成 d://electrondemo/index.html// 打开调试模式。
Electron学习与总结
最新发布
song854601134的博客
08-12 117
组成，‌其中Chromium负责渲染和显示Web页面，‌而Node.js则提供了主进程的功能，‌包括管理应用程序的生命周期、‌创建和控制浏览器窗口以及与操作系统交互。，‌Electron使得开发者能够保持JavaScript代码库的一致性，‌从而轻松地创建跨平台的应用程序，‌而无需具备本地开发经验。Electron的核心是由。
牛客JS题（三十四）监听对象
不起眼小菜菜的博客
08-10 414
注释很详细，直接上代码……
Vue项目通过宝塔部署之后，页面刷新后浏览器404页面
水w的博客
08-07 310
Vue项目通过宝塔部署之后，页面刷新后浏览器404页面
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值