六、字符串和数组

最新推荐文章于 2022-10-09 14:38:19 发布

默默229

最新推荐文章于 2022-10-09 14:38:19 发布

阅读量769

点赞数

分类专栏：前端文章标签： html 前端 javascript es6

本文链接：https://blog.csdn.net/qq_63011146/article/details/121521954

版权

前端专栏收录该内容

33 篇文章 3 订阅

订阅专栏

本文详细介绍了字符串的常用方法，如长度计算、字符访问、编码转换、拼接、搜索等，同时涵盖数组的基础概念、创建、操作方法，如合并、拷贝、填充、查找、数组处理等。通过实例演示，帮助读者理解和实践JavaScript中的字符串和数组操作。

摘要由CSDN通过智能技术生成

1.length属性，返回的是字符串的长度

2.charAt()方法，根据字符串中字符的索引(下标)获取对应的字符，注意：索引从0开始获取字符串的中指定索引的字符，也可以通过[索引]的方式获取

3.charCodeAt()方法，用于获取字符串中指定位置字符的Unicode编码值,Unicode编码是指不同国家的人，使用不同的字符描述数据。这些字符计算机不认识，计算机只认识二进制数字，也就是0和1，所以将全世界范围内使用的常用字符都定义一个对应的十进制数字编码，而这个十进制的数字编码就是Unicode编码，再将这些十进制的Unicode编码转为二进制编码传给计算机识别

比如：A -> 65 a -> 97 你 -> 20320

4.concat()方法，用于拼接字符串，通常情况下，我们可以直接使用加号去拼接，该方法，可以同时拼接多个字符串数据

5.fromCharCode()方法，用于将指定的Unicode编码转为指定字符，注意该方法是由String类型来调用的，该方法，可以传递多个Unicode编码

6.indexOf()方法，用于从字符串中返回指定字符串第一次出现的位置（注意：索引从0开始，找不到返回-1）

7.lastIndexOf()方法，是从后往前找，找到后，下标是从前往后数（注意，如果找不到返回-1）

8.slice()方法，用于截取指定区间范围内的字符串，该方法需要传两个参数，分别是起始位置和结束位置，能够取到起始位置，取不到结束位置，注意：slice()方法的参数，可以传负数，表示从后往前数索引

9.substring()方法，用于截取指定区间范围内的字符串，该方法需要传两个参数，分别是起始位置和结束位置，能够取到起始位置，取不到结束位置，注意：substring()方法参数，只能传正数，不能传负数

10.substr()方法，也是用于截取字符串，它的两参数分别是：起始位置和截取长度

注意：slice，substring，substr方法，如果只传1个参数，就表示从起始位置到最后全部截取

11.toLowerCase()方法，用于返回字符串转的小写版本，注意：不是改自身

12.toUpperCase()方法，用于返回字符串的大写版本，注意：不是改自身

13.trim()方法，用于去除字符串两端空格

14.repeat(num) 方法，用于重复指定的字符串多少次

15.split()把一个字符串分割成字符串数组，可以传两个参数分别为separator和limit 提示:如果把空字符串 ("") 用作 separator，那么 stringObject 中的每个字符之间都会被分割。注意： split() 方法不改变原始字符串。limit参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>字符的常用方法</title>
</head>
<body>
    <script>
        let s1 = "好好  学习"
        // length属性，返回的是字符串的长度，空格也是字符
        console.log(s1.length);
        let s2 = "HelloWorld"
        // charAt()方法，根据字符串中字符的索引(下标)获取对应的字符，注意：索引从0开始
        console.log(s2.charAt(0));
        console.log(s2.charAt(3));
        // 获取字符串的中指定索引的字符，也可以通过[索引]的方式获取
        console.log(s2[0]);
        console.log(s2[3]);
        console.log('-------------------------------');
        // charCodeAt()方法，用于获取字符串中指定位置字符的Unicode编码值
        // A -> 65 -> 01000001，a -> 97，你 -> 20320
        console.log(s2.charCodeAt(0));
        console.log(s1.charCodeAt(0));
        console.log('------------------------------');
        // concat()方法，用于拼接字符串，通常情况下，我们可以直接使用 加号 去拼接，该方法，可以同时拼接多个字符串数据
        let s3 = "张三"
        let s4 = "李四"
        let s5 = "王五"
        let s6 = s3.concat(s4)
        console.log(s6);
        console.log(s3);
        let s7 = s3.concat(s4,s5)
        console.log(s7);
        let s8 = s3+s4
        console.log(s8);
        let s9 = s3+s4+s5
        console.log(s9);
        console.log('-------------------------------');
        // fromCharCode()方法，用于将指定的Unicode编码转为指定字符，注意该方法是有String类型来调用的，该方法，可以传递多个Unicode编码
        console.log(String.fromCharCode(65));
        console.log(String.fromCharCode(65,66,67));
        console.log(String.fromCharCode(12345,33678,44778));
        console.log('--------------以下是字符串的核心方法-----------------');
        // indexOf()方法，用于从字符串中返回指定字符串第一次出现的位置（注意：索引从0开始，找不到返回-1）
        let str1 = "abc你好ccc你好ddd你好eee"
        console.log(str1.indexOf('你好'));
        console.log(str1.indexOf('你好呀'));
        console.log('------------');
        // lastIndexOf()方法，是从后往前找，找到后，下标是从前往后数（注意，如果找不到返回-1）
        console.log(str1.lastIndexOf('你好'));
        console.log(str1.lastIndexOf('你好呀'));
        console.log('------------');
        // slice()方法，用于截取指定区间范围内的字符串，该方法需要传两个参数，分别是起始位置和结束位置，能够取到起始位置，取不到结束位置，
        // 注意：slice()方法的参数，可以传负数，表示从后往前数索引
        console.log(str1.slice(3,6));
        // 如果只传一个参数，从起始位置往后全部截取
        console.log(str1.slice(3));
        console.log(str1.slice(-6,-3));
        console.log('------------');
        // substring()方法，用于截取指定区间范围内的字符串，该方法需要传两个参数，分别是起始位置和结束位置，能够取到起始位置，取不到结束位置，
        // 注意：substring()方法参数，只能传正数，不能传负数
        console.log(str1.substring(3,6));
        console.log(str1.substring(3));
        console.log(str1.substring(-6,-3));
        console.log('------------');
        // substr()方法，也是用于截取字符串，它的两参数分别是：起始位置和截取长度
        console.log(str1.substr(3,6));
        // 只传一个参数，也是从起始位置往后全部截取
        console.log(str1.substr(3));
        console.log('------------');
        // toLowerCase()方法，用于返回字符串转的小写版本，注意：不是改自身
        // toUpperCase()方法，用于返回字符串的大写版本，注意：不是改自身
        let str2 = 'AbCdEfG'
        console.log(str2.toLowerCase());
        console.log(str2.toUpperCase());
        console.log('------------');
        // trim()方法，用于去除字符串两端空格
        let str3 = '  abc  cba  '
        console.log(str3.length);
        // 注意：trim()方法，只能去掉字符串两端的空格，中间的空格无法去除。
        console.log(str3.trim().length);
        let str4 = "adadacosd"
        //不传任何参数则默认分割为长度为1的数组
        let arr = str4.split()
        console.log(arr);
        //只传引号分割每个字符，包括空格
        let arr1 = str4.split("")
        console.log(arr1);
        //传引号和第二个参数表示该数组长度为6，即取上个数组结果前6个
        let arr2 = str4.split("",6)
        console.log(arr2);
        let str5 = "name:张三&age:25&gender:男&enduction:本科"
        //当字符串中由某个字符连接时，如果不想要该字符，可以使用这个字符作为分隔符去除)
        let arr3 = str5.split("&")
        console.log(arr3);
    </script>
</body>
</html>

控制台显示为：

2.字符串练习题

1.输入邮箱地址，验证邮箱格式是否正确

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>字符串练习1</title>
</head>
<body>
    <script>
        // 输入邮箱地址，验证邮箱格式是否正确
        // 邮箱格式：必须包含@符号，必须包含.符号，.符号必须在@符号的后面，而且中间至少再隔一位
        // @符号不能是第一位，.符号不能是最后一位
        // 比如：zhangsan@123.com
        let email = prompt('请输入邮箱：')
        // 获取邮箱中@符号的位置
        let index1 = email.indexOf('@')
        // 获取邮箱中最后一个.符号的位置
        let index2 = email.lastIndexOf('.')
        // index1>0 表示必须包含@符号，并且还不能是第一位
        // index2<email.length-1 表示必须包含.符号，并且还不能是最后一位
        // index2-1>index1 表示.符号必须在@符号的后面，而且中间至少隔一位
        if(index1>0 && index2<email.length-1 && index2-1>index1){
            alert('邮箱格式正确')
        }else{
            alert('邮箱格式错误')
        }
    </script>
</body>
</html>

弹窗显示为：

2.输入登录名和密码，要求登录名长度为2-4位，密码长度是6-10位，用户名不能是全数字

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>字符串练习2</title>
</head>
<body>
    <script>
        // 输入登录名和密码，要求登录名长度为2-4位，密码长度是6-10位，用户名不能是全数字
        let loginId = prompt('请输入登录名(2-4位):')
        let loginPwd = prompt('请输入密码(6-10位):')
        let len1 = loginId.length   //登录名长度
        let len2 = loginPwd.length  //密码长度
        //先判断登录名
        if(len1>=2 && len1<=4 && isNaN(loginId)){
            //再判断密码
            if(len2>=6 && len2<=10){
                alert('登录成功')
            }else{
                alert('密码长度是6-10位')
            }
        }else{
            alert('登录名长度必须是2-4位，登录名不能是全数字')
        }

    </script>
</body>
</html>

弹窗显示为：

3.输入手机号码，要求长度必须是11位，第一位必须是1，后面的必须是数字

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>字符串练习3</title>
</head>
<body>
    <script>
        // 输入手机号码，要求长度必须是11位，第一位必须是1，后面的必须是数字
        let tel = prompt('请输入手机号：')
        let len = tel.length  //获取手机号的长度
        let first = tel[0]    //获取第一位数字
        let next = tel.slice(1)  //从第二位到最后全部截取
        //粗略的判断
        /* if(len==11 && first==1 && !isNaN(next)){
            alert('手机号码正确')
        }else{
            alert('手机号码错误')
        } */
        //详细的判断
        if(len!=11){
            alert('手机号码必须是11位')
        }else if(first!=1){
            alert('手机号码的第一位必须是1')
        }else if(isNaN(next)){
            alert('手机号码必须是全数字')
        }else{
            alert('手机号码正确')
        }
    </script>
</body>
</html>

弹窗显示为：

3.数组

变量：就是在内存中，开辟一个合适的空间，存储一份对应的数据

数组：就是在内层中，开辟一段连续的空间，存储一组数据

创建数组的第一种方式，使用数组的构造函数，new一个数组类型的对象

let arr1 = new Array(5)

创建数组的第二种方式：使用字面量方式直接定义

let arr2 = ["hello","world"]

length属性，返回的是数组的长度

根据数组的下标(索引)，向数组中存放数据，数组中可以存放任意类型的数据

注意：在创建数组对象时，可以给一个固定的长度，但是没有意义，因为在js中数组的长度是可以随意变化的

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>数组</title>
</head>
<body>
    <script>
        // 数组：就是在内存中，开辟一段连续的空间，存储一组数据
        // 如果需要维护多组数据，之前我们需要定义很多个变量，维护起来会相对比较麻烦
        let score1 = 55
        let score2 = 66
        let score3 = 77
        let score4 = 88
        let score5 = 99
        // 通过变量名获取变量中保存的数据
        let sum1 = score1+score2
        console.log(sum1);
        console.log('--------------------------');
        // 现在可以通过一个数组统一维护
        let scores = new Array(5)  //创建一个长度为5的数组空间（在内存中连续开辟了一个长度为5的存储空间）
        // 通过数组的下标，往数组中存储数据
        scores[0] = 55
        scores[3] = 66
        // 通过数组的下标，从数组的指定空间里面获取数据
        let sum2 = scores[0] + scores[3]
        console.log(sum2);
        console.log(scores);
        console.log('-------------------------');
        // 注意：在其他的编程语言中，定义数组时，必须要明确数组的长度，但是，js中不需要。
        // 在js中，数组的长度是弹性的，
        let scores2 = new Array()
        scores2[0] = 55
        scores2[8] = 66
        console.log(scores2);
        console.log('-------------------------');
        // 在js中，定义数组有两种方式：1.采用数组的构造函数new，2.使用字面量直接赋值
        let scores3 = new Array('苹果','香蕉')
        console.log(scores3);
        let scores4 = ['葡萄','榴莲']
        console.log(scores4);
        // length属性，返回数组的长度
        console.log(scores4.length);
    </script>
</body>
</html>

控制台显示为：

4.数组的常用方法

1.concat()方法，用于合并两个或多个数组，返回一个全新的数组

2.copyWithin()方法，从数组的指定位置拷贝元素到数组的另一个指定位置中

注意：第一个参数是目标位置，第二个参是拷贝元素的起始位，第三个参数是拷贝元素的结束位置

如果不设置第三个参数，拷贝元素结束位置就是目标位置的前一位

3.fill()方法，使用一个固定值来填充数组

4.includes()方法，从数组中检查指定的数据是否存在，存在返回true，不存在返回false

5.indexOf()方法，从数组中检查指定的数据的位置（从前往后找第一个），不存在返回-1

6.lastIndexOf()方法，从数组中检查指定的数据的位置（从后往前找第一个），不存在返回-1

7.isArray()方法，用于检查指定的对象是否是数组，注意：该方法属于Array类型，不属于Arrary的对象

8.join()方法，用于将一个数组根据某个字符串拼接成字符串，该方法不传参数，默认是根据逗号拼接

9.push()方法，向数组的末尾添加一个或更多元素，并返回新的长度

10.pop()方法，删除数组的最后一个元素并返回删除的元素

11.unshift()方法，向数组的开头添加一个或更多元素，并返回新的长度

12.shift()方法，删除并返回数组的第一个元素

13.reverse()方法，反转数组的元素顺序

14.slice()方法，选取数组的一部分，并返回一个新数组。注意：该方法的第一个参数是起始位置，第二个参数是结束位置(取不到结束位置)。 第二个参数可以省略，表示从起始位置到最后全部返回

15.splice()方法，从数组中添加或删除元素。如何删除，该方法需要传两个参数：第一个是起始位置，第二个是删除长度 。如果第二个参数不传，就表示从起始位置往后全部删除。删除方法，删除的是原始数组里面的数据，返回的是删除的数据。该方法也可以传三个参数，第三个参数就是删除部分插入的新内容

16.toString()方法，把数组转换为字符串，并返回结果

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>数组的常用方法</title>
</head>
<body>
    <script>
        // concat()方法，用于合并两个或多个数组，返回一个全新的数组
        let arr1 = [11,22,33]
        let arr2 = [44,55,66]
        let arr3 = arr1.concat(arr2)
        console.log(arr3);
        console.log('----------------------');
        /* 
            copyWithin()方法，从数组的指定位置拷贝元素到数组的另一个指定位置中
            注意：第一个参数是目标位置，第二个参是拷贝元素的起始位，第三个参数是拷贝元素的结束位置
            如果不设置第三个参数，拷贝元素结束位置就是目标位置的前一位
        */
        let arr4 = [11,22,33,44,55,66,77,88]
        arr4.copyWithin(2,4,6)
        console.log(arr4);
        console.log('----------------------');
        // fill()方法，使用一个固定值来填充数组
        let arr5 = new Array(5)
        arr5.fill(50)
        console.log(arr5);
        console.log('----------------------');
        // includes()方法，从数组中检查指定的数据是否存在，存在返回true，不存在返回false
        // indexOf()方法，从数组中检查指定的数据的位置（从前往后找第一个），不存在返回-1
        // lastIndexOf()方法，从数组中检查指定的数据的位置（从后往前找第一个），不存在返回-1
        let arr6 = [11,22,33,44,55,44,77,88]
        console.log(arr6.includes(44));
        console.log(arr6.includes(38));
        console.log(arr6.indexOf(44));
        console.log(arr6.indexOf(38));
        console.log(arr6.lastIndexOf(44));
        console.log(arr6.lastIndexOf(38));
        console.log('----------------------');
        // isArray()方法，用于检查指定的对象是否是数组，注意：该方法属于Array类型，不属于Arrary的对象
        let str1 = 'hello'
        console.log(Array.isArray(str1));
        console.log(Array.isArray(arr6));
        console.log('----------------------');
        // join()方法，用于将一个数组根据某个字符串拼接成字符串，该方法不传参数，默认是根据逗号拼接
        console.log(arr6.join('你好呀'));
        console.log(arr6.join(''));
        console.log(arr6.join());
        console.log('-----------以下是核心方法，必须无条件掌握-----------');
        let arr7 = [11,22,33]
        // push()方法，向数组的末尾添加一个或更多元素，并返回新的长度
        arr7.push(44)
        console.log(arr7);
        // pop()方法，删除数组的最后一个元素并返回删除的元素
        arr7.pop()
        console.log(arr7);
        // unshift()方法，向数组的开头添加一个或更多元素，并返回新的长度
        arr7.unshift(55)
        console.log(arr7);
        // shift()方法，删除并返回数组的第一个元素
        arr7.shift()
        console.log(arr7);
        // reverse()方法，反转数组的元素顺序
        arr7.reverse()
        console.log(arr7);
        console.log('----------------------');
        /* 
            slice()方法，选取数组的一部分，并返回一个新数组
            注意：该方法的第一个参数是起始位置，第二个参数是结束位置(取不到结束位置)
            第二个参数可以省略，表示从起始位置到最后全部返回
        */
        let arr8 = [11,22,33,44,55,66,77,88,99]
        console.log(arr8.slice(3,6));
        console.log(arr8.slice(3));
        // repeat()是字符串的方法，用于重复指定的字符串多少次
        console.log('-'.repeat(30));
        /* 
            splice()方法，从数组中添加或删除元素
            如何删除，该方法需要传两个参数：第一个是起始位置，第二个是删除长度
            如果第二个参数不传，就表示从起始位置往后全部删除
            删除方法，删除的是原始数组里面的数据，返回的是删除的数据
            该方法也可以传三个参数，第三个参数就是删除部分插入的新内容
        */
        // arr8.splice(4,3)  //删除指定区间的数据
        // arr8.splice(4)    //从起始位置往后全部删除
        // arr8.splice(4,3,'哈哈')  //删除部分的内容替换成新的内容（修改数组的内容）
        arr8.splice(4,0,'哈哈')     //在数组的指定位置插入内容
        console.log(arr8);
        // toString()方法，把数组转换为字符串，并返回结果
        // 效果跟join方法不传参数一样。
        console.log(arr8.toString());
    </script>
</body>
</html>

控制台显示为：

5.数组练习题

1.如何反转字符串 (先将字符串转为数组，再将数组反转，然后将反转后的数组，再转为字符串)

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>如何反转字符串</title>
</head>
<body>
    <script>
        // split()方法，用于将字符串根据某个字符串打散成数组
        let s1 = "我喜欢吃苹果，喜欢吃桃子，喜欢吃香蕉"
        // 将字符串根据“喜欢”打散成数组
        console.log(s1.split('喜欢'));
        // 将字符串中的所有字符打散成数组
        console.log(s1.split(''));
        console.log('---------------------------');

        let str = '好好学习，天天向上'
        // 01.将字符串打散成数组
        let arr = str.split('')
        // 02.数组反转一下
        arr.reverse()
        // 03.将数组拼接陈字符串
        let str2 = arr.join('')
        console.log(str2);
        //字符串和数组的所有方法，可以链式调用
        console.log(str.split('').reverse().join(''));
</script>
</body>
</html>

控制台显示为：

2.学生管理系统 (定义四个数组，分别存储学生的学号，姓名，年龄，性别)

<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>学生管理系统</title>
</head>

<body>
    <script>
        // 定义4个数组，管理学生的：学号，姓名，年龄，性别
        let nos = ['1001', '1002']
        let names = ['张三', '李四']
        let ages = [22, 23]
        let sexs = ['男', '女']

        let menu = 0  //定义一个菜单变量
        do {
            menu = prompt('******学生管理系统******\n1.查看学生信息 2.添加学生信息 3.修改学生信息 4.删除学生 0.退出系统')
            switch (menu) {
                case '1':
                    console.log('*******************查询学生信息*******************');
                    console.log('学号\t姓名\t年龄\t性别');
                    //循环数组，输出所有的学生信息
                    for (let i = 0; i < nos.length; i++) {
                        console.log(`${nos[i]}\t${names[i]}\t${ages[i]}\t\t${sexs[i]}`);
                    }
                    break;
                case '2':
                    //输入学生基本信息
                    //输入学号
                    let no = prompt('请输入学号')
                    //判断学号不能重复
                    if (nos.includes(no)) {
                        alert('学号不能重复')
                        continue  //跳过本次循环
                    }
                    //输入姓名
                    let name = prompt('请输入姓名')
                    //输入年龄
                    let age = prompt('请输入年龄')
                    if (isNaN(age)) {
                        alert('年龄必须是数字')
                        continue
                    }
                    //输入性别
                    let sex = prompt('请输入性别')
                    if (!(sex == '男' || sex == '女')) {
                        alert('性别只能是 男 或 女')
                        continue
                    }
                    //将学生的基本信息，添加到数组中
                    nos.push(no)
                    names.push(name)
                    ages.push(age)
                    sexs.push(sex)
                    alert('添加成功！')
                    break;
                case '3':
                    // 输入学号，根据学号，找到它在数组中的位置
                    let no1 = prompt('请输入需要修改学生的学号：')
                    //查找学号在数组中的位置
                    let index = nos.indexOf(no1)
                    //判断该学号是否存在
                    if (index == -1) {
                        alert('您输入的学号不存在！')
                        continue
                    }
                    //输入姓名
                    let name1 = prompt('请重新输入姓名')
                    //输入年龄
                    let age1 = prompt('请重新输入年龄')
                    if (isNaN(age1)) {
                        alert('年龄必须是数字')
                        continue
                    }
                    //输入性别
                    let sex1 = prompt('请重新输入性别')
                    if (!(sex1 == '男' || sex1 == '女')) {
                        alert('性别只能是 男 或 女')
                        continue
                    }
                    // 更新数组中的信息
                    names[index] = name1
                    ages[index] = age1
                    sexs[index] = sex1
                    alert('修改成功！')
                    break;
                case '4':
                    // 输入学号，根据学号，找到它在数组中的位置
                    let no2 = prompt('请输入需要修改学生的学号：')
                    //查找学号在数组中的位置
                    let index2 = nos.indexOf(no2)
                    //判断该学号是否存在
                    if (index2 == -1) {
                        alert('您输入的学号不存在！')
                        continue
                    }
                    // 删除数组中对应的数据
                    nos.splice(index2,1)
                    names.splice(index2,1)
                    ages.splice(index2,1)
                    sexs.splice(index2,1)
                    alert('删除成功！')
                    break;
                default:
                    alert('成功退出系统！欢迎下次使用！')
                    break;
            }
        } while (menu != 0);

    </script>
</body>

</html>

弹窗显示为：

3.随机生成一组双色球号码，存放到数组中

双色球号码的规则是：前六组号码是1-32之间不重复的随机数，第七组号码是1-16之间的随机数

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>作业1</title>
</head>
<body>
    <script>
        // 随机生成一组双色球号码，存放到数组中
        // 双色球号码的规则是：前六组号码是1-32之间不重复的随机数，第七组号码是1-16之间的随机数
        let nums = []
        //循环6次，生成前6组号码  
        for(let i=0;i<6;i++){
            let num = parseInt(Math.random()*32)+1
            // 判断每次生成的随机数，在数组中是否已经存在，
            if(!nums.includes(num)){
                // 如果不存在添加到数组中
                nums.push(num)
            }else{
                // 如果存在，重新再生成一次
                i--
            }
        }
        nums[6] = parseInt(Math.random()*16)+1
        console.log(nums);
    </script>
</body>
</html>