循环练习
- 跳转语句
- break语句
- continue语句
- 数组
- 创建数组
- 数组字面量法
- 扩展操作符
- 读写数组元素
- 稀疏数组
- 数组长度
- 添加和删除数组元素
- 删除数组元素
- 遍历数组
- 多维数组
- 数组方法
- 类数组对象
- 作为数组的字符串
- 作业
- 录制视频讲解splice()方法的使用方法
- 录制视频讲解数组去重:[8,3,2,6,4,4,6,2,8]
- 录制视频讲解数组冒泡排序: [5,4,3,2,1]
- 编程：翻转数组 [-6,-4,-2,0,2,4,6] => [6,4,2,0,-2,-4,-6]
- 编程：已知数组[22,0,33,0,44,0,55] 。创建一个新数组,把已知数组中的非0元素存储到新数组中。
循环练习
示例：假设银行的存款利率为2.75%,请问1000块钱需要存多少年才能变为5000块？
let money = 1000
let count = 0
while (money < 5000 ){
money *= 1.025
count++
}
console.log(count)
示例：请打印100以内所有的质数。
console.time("zhishu");
for (let i = 2; i < 100; i++) {
let zhishu = true;
for (let j = 2; j <= i ** 0.5; j++) {
if (i % j === 0) {
zhishu = false;
break; //优化
}
}
if (zhishu) {
console.log(i);
}
}
console.timeEnd("zhishu"); //优化
跳转语句
跳转语句会导致js解析器跳转到源代码中的新为止。
- break语句：让解析器跳出循环或switch
- continue语句：让解析器跳过当次循环并跳转到循环表达式，开始新一轮迭代
- return语句：让解析器从函数调用跳转会调用位置，通知提供调用返回值
- yield语句：生成器函数中返回的语句
- throw语句会抛出异常，与try/catch/finally语句共同使用
break语句
语法：
//语法1
break;
//语法2
break labelname;
用法1：立刻退出循环
for(let i=0;i<10;i++){
if(i === 3) break //012
document.write(i)
}
用法2：立刻退出switch语句
let str = '苹果'
switch (str) {
case '苹果':
document.write('苹果3.5元/斤')
break
case '猕猴桃':
document.write('猕猴桃4.5元/斤')
break
case '西瓜':
document.write('西瓜5.5元/斤')
break
default:
document.write('找不到您查找的水果')
}
用法3：只影响当前for循环
for(let i=0;i<10;i++){
console.log('====外循环====' + i)
for(let j=0;j<5;j++){
if(j===2) break
console.log('内循环' + j)
}
}
continue语句
语法：
//语法1
continue;
//语法2
continue labelname;
用法1：
for(let i=0;i<10;i++){
if(i === 3) continue //012456789
document.write(i)
}
示例：找出1000以内所有的质数。
for (let i = 2; i < 100; i++) {
let zhishu = true
for (let j = 2; j < i; j++) {
if ( i % j === 0) {
zhishu = false
}
}
if(zhishu) {
console.log(i)
}
}
数组
定义
数组是值的有序集合。
- 数组是编程语言的一种基础数据类型。
- 数组元素：数组的值被称为数组元素。
- 索引：每个数组元素有一个数值表示位置，叫做索引。
- js的数组元素可以是任意类型的值。
创建数组
创建数组有几种方式：
- 数组字面量法
- Array()构造函数
- ...
- 工厂方法
数组字面量法
数组字面量就是使用方括号包裹的数组元素，元素之间使用逗号分隔。
let empty = [] //空数组
let arr1 = [2,3,4,5,7,11] //有5个数值元素的数组
let arr2 = [1.1, true, 'a',]//3种不同类型的元素
数组元素可以是常量，也可以是变量
let num = 1
let table = [num,num+1,num+2,num+3]
扩展操作符
扩展操作符： ...（实际并不属于操作符)
用法1：扩展操作符允许在一个数组字面量种包含另一个数组元素。
let a = [1,2,3]
let b = [0,...a,4] // b == [0,1,2,3,4]
- 这里的三个点会扩展数组a。
-
...a代表数组a的所有元素。
用法2：用于快速赋值数组
let a = [1,2,3]
let b = [...a] //[1,2,3]
b[0] = 0 //不会影响数组a
a[0]//1
用法3：用于把字符串转数组
let str = 'hello'
let arr = [...str]
console.log(arr)
读写数组元素
使用[]读写数组元素
let arr = ['苹果','桔子','西瓜','榴莲','火龙果','牛油果']
arr[0] //'苹果'
arr[1] = '荔枝'
arr[1] //'荔枝'
稀疏数组
密集数组中的元素都是从索引 0 开始顺序排列的。数组的长度属性准确地指定了数组中元素的数量。
稀疏数组就是元素不连续的数组，它们并不总是从 0 开始。它们本质上是带有“孔”的。数组的长度属性会准确返回数组中元素的数量，但在稀疏数组中则不会。
let arr = []
arr[2] = 'hello'
console.log(arr.length) //3 实际只有一个数组元素
产生稀疏数组的情况
- new Array()
- delete删除符
数组长度
Array.length 返回数组的长度，也就是数组元素的数量。
用法1：查询数组长度
let arr = [1,2,3,4,5]
arr.length
用法2：查询最后一个数组元素
arr[arr.length - 1]
用法3：删除数组元素
arr.length = 3
用法4: 创建稀疏数组
arr.length = 10
arr // [1,2,3,4,5,,,,,]
添加和删除数组元素
方法1：使用索引赋值
let arr = [1,2,3]
arr[arr.length] = 4
方法2：使用push方法
方法3：使用unshift()方法
删除数组元素
方法1：pop方法
方法2：shift方法
方法3：delete方法
let arr = [3, 1, 4, 1, 5];
console.log("1" in arr);
delete arr[1]; //delete删除的是数组元素，删除后索引位置还在
console.log("1" in arr);
arr.length // => 3 不影响数组长度
let obj = { x: 1, y: 2 };
console.log("x" in obj);
delete obj.x; //delete删除的是属性，删除后就属性就不存在了。
console.log("x" in obj);
方法4： length属性
let arr = [1,2,3]
arr.length = 2 // [1,2]
方法5： splice()方法
定义
Array.slpice()方法用于修改数组。修改包括：
- 增加数组元素
- 删除数组元素
- 替换数组元素
语法
splice(start)
splice(start, deleteCount)
splice(start, deleteCount, item1)
splice(start, deleteCount, item1, item2, itemN)
splice(参数1,参数2,参数3)//1:删除数组的起始位置
splice(1,2)//2:删除数组元素的数量
splice(1,2,'a','b','c')//'a':要添加的元素
splcie(1,0,'b','c')//0:要做添加的操作，而不删除任何元素
- 参数1：删除的元素位置
- 参数2：删除的元素数量
- 参数3：添加的元素
- 参数2是0：表示删除0个
说明
- start：修改操作的起始位置
- start === -1 => 从数组末尾倒序计算
- start > -array.length || 不写start => start = 0
- start >= array.length，则不会删除任何元素
- deleteCount: 删除的数组元素的数量
- 如果省略deleteCount，或者其值大于或等于start指定位置之后的元素个数，则删除从start到数组末尾的所有元素。
- 如果 deleteCount 为 0 或负数，则不会删除任何元素
- item: 添加的新数组元素。
- 如果不指定任何元素，splice() 将只从数组中删除元素。
返回值
- 包含已删除元素的数组。
- 如果没有删除任何元素，则返回一个空数组。
示例：splice()
const fruits = ["苹果", "香蕉", "西瓜", "橘子"];
let removed = fruits.splice(2, 0, "榴莲"); //返回[]
removed = fruits.splice(2, 1, "菠萝");
console.log(removed);
console.log(fruits);
示例：数组去重[3, 7, 9, 1, 3, 2, 1, 1, 7]
let arr = [3, 7, 9, 1, 3, 2, 1, 1, 7];
//推理过程
// let i = 0
// for(let j = i + 1;j<arr.length;j++){
// if(arr[i] === arr[j]) {
// arr.splice(j,1)
// }
// }
// let i = 1
// for(let j = i + 1;j<arr.length;j++){
// if(arr[i] === arr[j]) {
// arr.splice(j,1)
// }
// }
for (let i = 0; i < arr.length; i++) {
//循环元素
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] == arr[j]) {
//比较值：第一个等同于第二个，splice方法删除第二个
arr.splice(j, 1);
j--;
}
}
}
console.log(arr);
示例：冒泡排序
// 冒泡，相邻元素之间比较
let arr = [57, 68, 59, 52, 72, 28, 96, 33, 24, 19];
// for (let i = 0; i < arr.length - 1; i++) {
// for (let j = 0; j < arr.length - 1 - i; j++) {
// if (arr[j] > arr[j + 1]) {
// let temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// }
//推理1：需要第三个瓶子存储大值
// let j = 0
// if(arr[j] > arr[j + 1]){
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j+1] = temp
// }
// j++
// if(arr[j] > arr[j + 1]){
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j+1] = temp
// }
// j++
// if(arr[j] > arr[j + 1]){
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j+1] = temp
// }
// j++
// if(arr[j] > arr[j + 1]){
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j+1] = temp
// }
//推理2：需要一个for循环做
// for (let j = 0; j < arr.length - 1; j++) {
// if (arr[j] > arr[j + 1]) {
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j + 1] = temp
// }
// }
//推理3：需要一个for循环控制轮次
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
console.log(arr);
遍历数组
方法1：使用for循环遍历数组
遍历数组：从前向后
let arr = [1,2,3,4,5]
for(let i=0;i<arr.length;i++)
{
console.log(arr[i])
}
遍历数组：从后向前
let arr = [1,2,3,4,5]
for(let i=arr.length-1;i>=0;i--)
{
console.log(arr[i])
}
遍历数组：隔一个遍历
let arr = [1,2,3,4,5]
for(let i=0;i<arr.length;i+=2)
{
console.log(arr[i])
}
练习：以数组形式返回所有大于等于18的数组元素。
let arr = [30, 18, 20, 10, 40, 17, 19, 50, 60];
let arr2 = [];
for (let i = 0; i < arr.length; i++) {
if (arr[i] >= 18) {
arr2.push(arr[i]);
}
}
console.log(arr2);
方法2： 使用for/in遍历数组
let arr2 = [1,2,3,4,5]
for(let attr in arr2){
console.log(attr)//{'0':1,'1':2,}输出的是字符串属性名
console.log(arr2[attr]) //输出的是数组元素
}
示例：拼接字符串
let arr = [...'Hello world']
let str = ''
for(let element of arr){
str += element
}
str // => 'Hello world'
方法3： 使用for/of遍历数组
let arr = [...'Hello world']
let str = ''
for(let element of arr){
str += element
}
str // => 'Hello world'
稀疏数组：
for(let i = 0; i< arr.length; i++){
if (a[i] === undefined) continue //跳过未定义及不存在的元素
//循环体
}
方法3：forEach()
方法4：map()
方法5：filter()
