变量声明let与const
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
/*
1.学习目标 ： 掌握ES6新增两个关键字 let 与 const
* let 与 const的作用是声明变量，类似于ES5的let关键字
2.学习路线（对比法学习）
(1) 复习ES5的let关键字两个特点
(2) 介绍ES6的let与const关键字的两个特点
(3) 介绍let与const的区别 与 注意点
*/
/* 1.ES5语法变量特点 */
// 1.1 变量会提升
console.log(num) //undefined
var num = 10
// 1.2 没有块级作用域
for (var i = 1; i < 5; i++) {
console.log('循环内' + i)
}
console.log('循环外' + i) //5
/* 2.ES6新增两种变量声明方式（let与const），类似于let
(1).不会提升
(2).有块级作用域
*/
// （1）如果打印undefined，说明提升了 （2）如果报错，说明没有提升
// console.log(a);//报错
// let a = 10;
// (2)如果打印5，说明没有块级作用域 （2）如果报错，说明有块级作用域
for (let j = 1; j < 5; j++) {
console.log(j)
}
// console.log(j);
/* 3.let与const区别
* 注意点：ES6中变量不能重复声明，否则会报错
*/
//let声明：变量，允许修改
let a = 10
a = 20
// let a = 30;//程序报错，不允许重复声明
console.log(a)
//const声明:常量，只可以声明的时候赋值一次，之后无法修改
const b = 100
// b = 200;//程序报错
console.log(b)
</script>
</body>
</html>
解构赋值语法
对象解构赋值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
/*
1.学习目标：掌握对象的解构赋值语法
* 解构赋值本质 就是 变量赋值语法的简写形式
2.学习路径 ： 对比法学习（ES5与ES6对比）
（1）取出 对象的属性值 赋值给 变量
（2）取出 变量的值 赋值给 对象的属性
（3）设置 解构赋值语法 的默认值
*/
//解构赋值语法 ： 其实就是变量赋值语法的简写形式
//1：取出 对象的属性 赋值 给变量
let obj = {
name: '张三',
age: 18,
sex: '男'
}
/* ES5 */
// let name = obj.name;
// let age = obj.age;
// let sex = obj.sex;
// console.log(name,age,sex);
/* ES6 */
/* a.这行代码本质:声明三个变量 name，age，sex。取出右边obj对象对应的属性名赋值给左边的变量*/
// let {name,age,sex} = obj;
// console.log(name,age,sex);
/* b.由于obj对象没有score属性，所以变量score的值为undefined。 */
// let {name,score} = obj;
// console.log(name,score);
/* c. sex:gender 的含义 ： let gender = obj.sex */
// let {name,sex:gender} = obj;
// console.log(name,gender);
//2：取出变量的值 赋值给对象的属性
// let name = '李四';
// let age = 20;
// let sex = '男';
// let sayHi = function(){
// console.log('你好');
// };
/* ES5 */
// let person = {
// name : name,
// age : age,
// gender : sex,
// sayHi :sayHi
// };
// console.log(person);
/* ES6 */
// let person = {
// name,//等价于 name:name
// age,
// gender:sex,//如果属性名和变量名不一致，还是按照以前ES5的写法来赋值
// sayHi,
// play(){//等价于：play:function(){}
// console.log('学习使我快乐');
// }
// };
// console.log(person);
//3. 设置 解构赋值语法 的默认值
let student = {
name: '班长',
age: 38,
sex: '女'
}
/*
（1） name = '坤哥'
a. 声明变量name : let name;
b. 取出student对象的name属性值赋值给name : student.name
c. 如果student对象没有name属性则赋值坤哥 : if(student.name){ name = student.name }else{ name = '坤哥' }
(2) sex:gender = '男'
a. 声明变量gender : let gender;
b. 取出student对象的sex属性值赋值给gender : student.sex
c. 如果student对象没有sex属性则赋值男 : if(student.sex){ gender = student.sex }else{ gender = '男' }
*/
let { name = '坤哥', score = 88, sex: gender = '男' } = student
console.log(name, score, gender) //班长 88 女
</script>
</body>
</html>
数组解构赋值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
//数组解构赋值
let arr = [10, 20, 30]
/* ES5 */
// let n1 = arr[0];
// let n2 = arr[1];
// let n3 = arr[2];
// console.log(n1,n2,n3);
/* ES6 */
let [n1, n2, n3 = 50, n4 = 100] = arr
console.log(n1, n2, n3, n4) // 10 20 30 100
</script>
</body>
</html>
函数参数解构赋值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
/*
1.学习目标 ： 掌握函数参数的解构赋值
2.学习路线
（1）复习 函数 传参的本质是 实参给形参赋值的过程
（2）使用解构赋值语法 给函数传参
（3）使用解构赋值语法 设置 函数的默认参数
*/
/* (1) ES5 :函数传参 */
/**
* @description:
* @param {Object} obj:对象类型 {name:名字 age:年龄 sex:性别}
* @return:
*/
// function fn(obj){
// console.log(obj);
// //声明三个变量接收对象的参数值
// let name = obj.name;
// let age = obj.age;
// let sex = obj.sex;
// console.log(name,age,sex);
// };
// fn({
// name:'黑马李宗盛',
// age:32,
// sex:'男'
// });
/* (2) ES6 :函数传参 */
// function fn1({name,age,sex}){
// //声明三个变量接收对象的参数值
// console.log(name,age,sex);
// };
// fn1({
// name:'黑马李宗盛',
// age:32,
// sex:'男'
// });
//添加解构语法默认值
// function fn2({name = '班长',age = 38,sex:gender='女'}){
// //声明三个变量接收对象的参数值
// console.log(name,age,gender);
// };
// fn2({
// name:'黑马李宗盛',
// });
/* (3)函数默认参数 */
/* ES5:使用逻辑或短路运算实现 */
// function fn(n1,n2,n3){
// n1 = n1 || 10;
// n2 = n2 || 20;
// n3 = n3 || 30;
// console.log(n1,n2,n3);
// };
// fn(5,8);
// fn();
/* ES6:使用解构赋值语法默认值实现 */
function fn (n1 = 10, n2 = 20, n3 = 30) {
console.log(n1, n2, n3)
}
fn(5, 8)
fn()
</script>
</body>
</html>
箭头函数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
/*
1.学习目标：学会使用ES6的箭头函数
* 箭头函数 => 其实是 function 关键字的简写形式
* 写法： 将function关键字使用 => 符号代替
2.学习路线
(1)介绍箭头函数的常见用法 ： 重点
(2)介绍箭头函数的其他用法 ： 了解
*/
//1.箭头函数常见用法
//1.1 无参无返回函数
/* ES5 */
let fn = function () {
console.log('111')
}
fn()
/* ES6
箭头函数规则： （1）function变成 箭头符号 => (2)形参小括号写到箭头 => 左边
*/
let fn1 = () => {
console.log('222')
}
fn1()
//1.2 有参有返回函数
/* ES5 */
let add = function (a, b) {
return a + b
}
console.log(add(10, 20))
/* ES6 */
let add1 = (a, b) => {
return a + b
}
console.log(add1(100, 200))
//2.箭头函数其他用法
//2.1 如果函数只有一个形参，则可以省略形参小括号
let fn2 = a => {
return a * 2
}
console.log(fn2(20)) //40
//2.2 如果函数体只有一行代码，则可以省略函数体大括号
//注意点： 如果省略函数体大括号，则返回值也要省略return
//下面代码等价于： let fn3 = function(a){ return a*2 }
let fn3 = a => a * 2
console.log(fn3(30)) //60
</script>
</body>
</html>
箭头函数中this
1.箭头函数 中 没有this：这意味着capp() apply() bind() 无法修改箭头函数中的this指向
2.箭头函数中的this指向：访问上一个作用域的this指向
说人话：函数再哪个作用域声明，this就是谁（本质是通过作用域链访问上一个作用域中的this）
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*ES6箭头函数中的this
(1)箭头函数中没有this : 这意味着 call() apply() bind() 无法修改箭头函数中的this
(2)箭头函数中的this指向 ：访问上一个作用域的this
说人话：函数在哪个作用域声明，this就是谁 (本质是通过作用域链访问上一个作用域中的this)
*/
//1.全局函数 ： window
let fn = () => {
console.log(this);
};
fn();//window
fn.call({ a: 11 });//window 箭头函数中的this无法修改，因为箭头函数没有this
//2.对象方法： window (因为对象无法开辟作用域，obj所在作用域还是window)
let obj = {
sayHi: () => {
console.log('学习使我快乐');
console.log(this);
}
};
obj.sayHi();//window
//3.局部函数
let person = {
play: function () {
console.log('play中的this');
console.log(this);//person
//在局部作用域声明一个箭头函数
let fn2 = () => {
console.log('fn2在一级链中被声明，我的this就是一级链中的this');
console.log(this);//person
};
fn2();
}
};
person.play();
</script>
</body>
</html>展开运算符
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1.展开运算符 ： ...
2.作用： 相当于遍历对象简写
3.应用场景：
3.1 连接数组（上拉加载下一页） ： arr1.push(...arr2)
3.2 求数组最大值 : Math.max(...arr)
*/
//1.用于连接数组 : 页面上拉加载下一页的时候，就需要连接数组
let arr1 = [10,20,30,40]
let arr2 = [50,60,70,80]
//ES5 : arr1.push.apply(arr1,arr2)
// arr1.push(arr2[0],arr2[1],arr2[2],arr2[3])
// arr1.push.apply(arr1,arr2)
//ES6 : arr1.push(...arr2)
arr1.push(...arr2)
console.log(arr1)
//2.用于求数组最大值
let arr = [20,0,60,88,100,50]
//ES5 : Math.max.apply(Math,arr)
let max1 = Math.max.apply(Math,arr)
console.log( max1 )
//ES6 : Math.max(...arr)
let max2 = Math.max(...arr)
console.log( max2 )
</script>
</body>
</html>数据类型Set
1.数据类型Set (集合) : 类似于数组，与数组唯一的区别是 ： 不能存储重复元素
2.应用 ： 数组去重
一行代码去重： let newArr = Array.from( new Set(数组) )
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1.数据类型Set (集合) : 类似于数组，与数组唯一的区别是 ： 不能存储重复元素
2.应用 ： 数组去重
一行代码去重： let newArr = Array.from( new Set(数组) )
*/
let arr = [10,20,60,80,20,60,99,10,100]//[10,20,60,80,99,100]
//1.声明Set
// let set = new Set(arr)
// console.log( set )
//2.把set转成真数组
// let newArr = Array.from(set)
// console.log(newArr)
/* 一行代码实现数组去重 */
let newArr = Array.from(new Set(arr))
console.log(newArr)
</script>
</body>
</html>数组迭代方法
| 数组几种遍历介绍(共同点：回调函数一样) | 应用场景 | 回调执行次数 | 函数返回值 | 回调是否需要return |
|---|---|---|---|---|
| map遍历 | 映射数组 | == 原数组长度 | 新数组(==) | 一定要return（当前元素） |
filter遍历 | 过滤数组 | == 原数组长度 | 新数组(!=) | return true(元素添加到新数组) |
| forEach遍历 | 遍历数组 | == 原数组长度 | 无 | 无 |
| some遍历 | 找出符合条件的数 | != 原数组长度 | 布尔类型 | return true；循环结束 |
| every遍历 | 判断所有元素是否符合条件 | != 原数组长度 | 布尔类型 | return true; 循环继续 |
| findIndex遍历 | 获取符合条件的第一个元素位置(下标) | != 原数组长度 | 数字 | return true; 循环结束 |
| includes方法(底层是遍历) | 判断数组/字符串是否包含某一个值 | 无回调 | 布尔类型 | 无回调 |
数组map遍历
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1. map场景 ： 映射数组。 对数组每一个元素进行映射处理，得到一个全新数组
映射关系： 每一个元素 * 0.8
映射关系： 每一个元素 * 2
2. map方法特点
(1)回调执行次数 === 数组长度
(2)本身返回值 : 隐射之后的新数组
(3)回调函数内部return
return 新数组元素值
如果不写return， 新数组每一个元素都变成undefined
*/
let arr = [88,100,90,66,50]
//全场8折
let newArr = arr.map( (value,index)=>{
console.log(index,value)//下标 元素
return value*2
} )
console.log( newArr )
</script>
</body>
</html>数组filter遍历
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1. filter场景 ： 筛选数组
举例：找出数组中符合条件的元素
找出数组中所有的偶数
找出对象数组中符合条件的元素
2. filter方法特点
(1)回调执行次数 === 数组长度
(2)本身返回值 : 筛选之后的新数组
(3)回调函数内部return
return true : 满足筛选条件，当前元素放入新数组中
return false : 不满足筛选条件，当前元素不放入新数组
*/
let arr = [10, 55, 60, 88, 99, 70]
//找出数组中所有的偶数
let res = arr.filter((value, index) => {
if (value % 2 == 0) {
return true
} else {
return false
}
})
// let res = arr.filter(v=>v % 2 == 0)
console.log( res )
//需求：筛选4000-5000之间
let arr1 = [
{
name:'苹果电脑',
price:8888
},
{
name:'macbook',
price:5888
},{
name:'xiaomi',
price:3888
},{
name:'华为',
price:4888
},
]
let res1 = arr1.filter( (value,index)=>{
if( value.price > 4000 && value.price < 5000 ){
return true
}else{
return false
}
} )
// let res1 = arr1.filter( v=>v.price > 4000 && v.price < 5000 )
console.log( res1 )
</script>
</body>
</html>数组some遍历
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1. forEach场景 ： 遍历数组
2. forEach方法特点
(1)遍历次数 === 数组长度
(2)本身返回值
无
(3)回调函数内部return
无
*/
let arr = [10, 55, 60, 88, 99, 70]
arr.forEach((value,index)=>{
console.log(index,value)
})
</script>
</body>
</html>数组every遍历
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1. every场景 ： 判断数组中是否所有元素都满足条件
经典场景：开关法
2. every方法特点
(1)遍历次数 != 数组长度
(2)本身返回值
true : 全部满足条件
false: 有元素不满足条件
(3)回调函数内部return
true:循环继续。如果全部遍历结束还是true，则every方法默认返回就是true
false:循环结束。并且every方法本身返回值是false
*/
let arr = [10, 55, 60, 88, 99, 70]
//判断数组中是否所有元素都是正数
let res = arr.every((value,index)=>{
if( value >= 0){
return true
}else{
return false
}
})
console.log( res )
</script>
</body>
</html>数组findindex方法
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1. findIndex场景 ： 获取某个元素下标
* 应用场景： 与 indexOf() 类似 . 但是findIndex一般用于对象数组
2. findIndex方法特点
(1)遍历次数 != 数组长度
(2)本身返回值
有元素： 元素下标
没有元素： 固定值-1
(3)回调函数内部return
return true: 找到了，循环立即结束。并且findIndex方法本身返回当前index
return false: 没找到，循环继续。如果全部遍历完还是没找到，则得到默认返回值-1
*/
let arr = [
{
name:'张三',
age:20
},
{
name:'李四',
age:50
},
{
name:'王五',
age:20
}
]
let res = arr.findIndex((value,index)=>{
if( value.name == '李四'){
return true
}else{
return false
}
})
console.log( res )
</script>
</body>
</html>数组reduce方法
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<script>
/*
1.数组reduce方法 ： 给每一个元素执行一次回调
2.应用场景： 数组求和、求数组最大值
3.语法：
let res = arr.reduce((sum,value,index)=>{ return sum+value },0)
* res返回值是最后一次sum的结果
4.注意点： 一定要给初始值，否则reduce遇到空数组就会报错
*/
let arr = [10, 55, 60, 88, 99, 70]
let sum = 0
for(let i = 0;i<arr.length;i++){
if(arr[i]>sum){
sum = arr[i]
}
}
console.log( sum )
/**
* @description:
* @param {callbackFn}回调函数
* (sum,value,index)=>{ sum:上一次的返回值 value:当前元素值 index:当前下标 }
* sum初始值 ： 一般给0,否则空数组reduce报错
* @return: 最后一次回调的结果
*/
let res = arr.reduce((sum,value,index)=>{
console.log( sum,value,index )
return sum+value
},0)
console.log( res )
//求最大值
let res1 = arr.reduce((sum,value)=>{
if(sum>value){
return sum
}else{
return value
}
},0)
console.log( res1 )
</script>
</body>
</html>
