let var
//1、let 的块级作用域
//var 没有块级作用域
function fn1(){
for(var i = 0; i < 5; i++){
// do something
}
console.log(i);//5
}
fn1();
function fn2(){
for(let i = 0; i < 5; i++){
// do something
}
// console.log(i);//i is not defined
}
fn2();
//2、var 变量覆盖,原则上变量不能重名
var demo = "小明";
var demo = "小红";
console.log(demo); //小红
let demo1 = 1;
let demo1 = 2; //Identifier 'demo1' has already been declared
console.log(demo1)
//声明提升 let 不存在声明提前
console.log(name); //空
var name = 123;
// console.log(name1); //Cannot access 'name1' before initialization
let name1 = 123;
//const声明一个只读的常量,一旦声明,常量的值就不能改变
//一般用于定义全局变量
//通常变量名全部大写
//定义后必须赋值
//const 如果定义的是对象、数组、函数、引用数据类型。可以改变其中的存储的数据.
const PI='3.14';
const NUM = {
name:'Tom',
age:18,
sex:"男" ,
};
NUM.name = "Jary";//修改内部变量
console.log(NUM); //{name: "Jary", age: 18, sex: "男"}
解构赋值
//解构赋值 从对象和数组中获取特定数据并赋值给变量
//1、对象赋值
//对象字面量的语法形式
let obj ={
val:1,
type:2,
two:8
}
// 一定要用一对小括号包裹解构赋值语句
let {val,type}=obj;
console.log(val,type);//1,2
let {type,val}=obj;
console.log(val,type);//1,2
// 使用解构赋值表达式时,如果指定的局部变量名称在对象中不存在,那么这个局部变量会被赋值为undefined
let {one,two}=obj;
console.log(one,two);//undefined undefined
//当指定的属性不存在是,可以随意定义一个默认值,在属性名称后面添加一个等号和相应的默认值即可
//当指定的属性存在时,定义的默认值无效
let {one=true,two=1}=obj;
console.log(one,two);//true 8
let {val} = obj;
console.log(val);//1
// 嵌套对象解构
let obj1={
tit:{
val1:{
one:123,
two:456
}
}
};
let {tit:{val1}}=obj1;
console.log(val1.one);//123
console.log(val1.two);//456
// ... 剩余运算符
let obj3 ={
a:1,
b:2,
c:3,
d:4
}
let {a,b,...c}=obj3;
console.log(a);//1
console.log(b);//2
console.log(c);//{c:3,d:4}
//数组解构
//1
let arr = [1,2,3,4];
let [v1,v2,v3]=arr;
console.log(v1,v2,v3);//1,2,3
//2、想拿后面的值前面可以不用定义,用空格代替
let [,,v4]=arr;
console.log(v4);//3
//3、整个赋值
let arrall=[...arr];
console.log(arrall);//[1,2,3,4]]
//4、部分赋值
let [a1,b1,...c1]=arr;
console.log(a1);//1
console.log(b1);//2
console.log(c1);//[3,4]
// eg: q=1,w=2,让q w交换值
// 如果右侧数组解构赋值表达式的值为null或undefined,则会导致程序错误
let q=1,w=2;
[q,w]=[w,q];
console.log(q,w);//2,1
//字符串解构
const [p, o, i, u, y] = 'hello';
console.log(p);//"h"
console.log(o);//"e"
console.log(i);//"l"
console.log(u);//"l"
console.log(y);//"o"
const {length} = 'hello';
console.log(length);//5
模板字符串
//模板字符串
${},对ie的兼容性不好 可以替换为''++''
let str1= '好好学习,';
let str2='天天向上';
let str3=`${str1}${str2}`;
console.log(str3); //好好学习,天天向上
console.log(`你好${str2}`); //你好天天向上
箭头函数
箭头函数本身没有作用域(无this)
//箭头函数的this指向上一层,上下文决定其this
//不让this的指向发生改变
let fn = a=>a;
console.log(fn(1));//1
let fa=(a,b)=>{
let num = a+b;
return num;
}
console.log(fa(1,2));//3
//适用场景
// 当代码里面需要存this时, let _this=this,
let obja={
'za':1,
'zb':function(){
console.log(this);//指向obja
console.log(this.za);//1
setTimeout(()=>{
console.log(this);//指向obja
console.log(this.za);//1
console.log(za);//2
})
setTimeout(
function fb(){
console.log(this);//指向Window
console.log(this.za);//undefined
console.log(za);//2
}
)
}
}
let za=2;
obja.zb()
- //特点: 箭头函数this为父作用域的this,不是调用时的this
- // 箭头函数的this永远指向其父作用域,任何方法都改变不了
- // 普通函数的this指向调用它的那个对象
- // 箭头函数不能作为构造函数,不能使用new
- // 箭头函数没有原型属性
// 函数参数的扩展
// 1、默认参数 f为默认参数,如果不传就为5,传值就会覆盖默认值
function fc(f=5){
console.log(f);
return f;
}
fc()//5
fc(6)//6
// 只有在函数没有传参数或者传的参数为undefined时才会使用默认参数,null值是被认为有效的值传递
// // 2、不定参数
function fd(...val){
console.log(val);//[1,2,3,4,[1,2,3]]
}
fd(1,2,3,4,[1,2,3]);
Class类
生成实例对象
1、创建构造函数
function Peoson(name,age){
this.name=name,
this.age=age
}
2、 创建实例对象
var p1 = new Peoson('123',2);
3、创建实例方法
Peoson.prototype.prt=function(){
return this.name+this.age;
}
console.log(p1.prt());
Class创建构造函数
1、在类中声明方法不能给方法添加function关键字
2、方法之间不要用逗号分隔
3、类定义不会被提升,必须在访问前对类进行定义
class Persona{
constructor(name,age){//构造方法
this.name=name;//this代表实例对象
this.age=age
}
prta(){
console.log(this.name,this.age)
return this.name+this.age;
}
}
var p2= new Persona('456',7);
console.log(p2.prta());
Map Set
// map,映射,即原数组映射成一个新数组
//通过map可以操作数组中的恶数据
// var arre=[1,2,3,4]
var arre=[
{
zhi:[
{
a:1,
b:2,
c:3
},
{
a:4,
b:5,
c:6
}
],
d:0
}
]
function maps(arre){
console.log(arre)
var arrf=[];
for(let j=0;j<arre.length;j++){
for(let i=0;i<arre[j].zhi.length;i++){
// arrf.map(function(arre[j].zhi[i]){
arrf.push(arre[j].zhi[i].a)
arrf.push(arre[j].zhi[i].b)
if(i==arre[j].zhi.length-1){
arrf.unshift('一');
arrf.unshift('二');
}
// })
}
}
console.log(arrf);//[2,3,4,5]
}
maps(arre);
// Map
//初始化Map需要一个二维数组,
const map = new Map([
['name', '张三'],
['title', 'Author']
]);
//或者初始化一个空map
let myMap=new Map();
// 创建key值
myMap.set('onee',123);
myMap.set('twoe',456);
myMap.set('threee',789);
myMap.has('onee');
//判断onee是否存在
console.log(myMap.has('onee'))//true
//获取key值
console.log(myMap.get('onee')); //123
// 因为一个key只能对应一个值,所以重复赋值会被覆盖
myMap.set('onee','321');
console.log(myMap.get('onee'))//321
// 删除key值
myMap.delete('onee');
console.log(myMap.get('onee')); //undefined
// set和map类似,也是一组key的集合,但他不存储value,在Set中不会存在重复的key.
let dfg=[1,2,3,4,5,5,6,6];
var mySet=new Set(dfg);
mySet.add(1);
console.log(mySet);//{1,2,3,4,5,6}
mySet.delete(6);
console.log(mySet);//{1,2,3,4,5}