2020-09-20

表示XXX重复声明（let）

XXX has already been declared

表示XXX没有声明

XXX is not defined

undefined 表示变量声明未赋值（不是报错）

创建变量

ES5书写格式：关键字， 标识符（变量名） 分号

​ var F70 ；

ES6书写格式：关键字， 标识符（变量名） 分号

例子： let F71 ；

声明常量

const F72 = 200；

变量的赋值

书写格式 关键词 标识符 赋值符号 表达式 分号

​ let F70 = 0 ；

变量初始化： let F70=0；

数据类型

数据类型分为：基本数据类型 和复杂数据类型

基本数据类型有：Symbol 、 undefined 、Boolean 、Number 、String 、 null

undefined是null（空）衍生出来的

Number 数值 ：判断是不是一个非数字{isNaN(标识符)}；-0；

复杂数据类型：Object

typeof 标识符 用于判断数据类型

字符串模板：

let str=` 欢迎光临${标识符}  `

数据类型的转换

Boolean类型转换 true转换成 1 false转换成 0

强制类型转换布尔 !!F70（前面加2个！！）

以下内容在转换布尔时为false，

1、 false

2、 0

3、 null

4、 undefined

5、 ``,””,’’

6、 NaN

NaN不等于任何数，包括他自己

比较运算符

注：返回值是布尔值

大于 >

小于 <

等于 ==

大于等于 >=

小于等于 <=

不等于 !=

全等 ===

不全等 !==

逻辑运算符

与运算：&& 一假全假

或运算：|| 一真全真

非 ： ！ 取反

判断语句

if（条件）{代码块} else{代码块}

循环语句

while（条件）{代码块}

do{代码块}while（条件） 注：至少执行一次代码块，条件为真执行第二次

for循环；

continue //终止本次循环

break //终止整个循环

数组

字面量声明

关键字 标识符 赋值符号 中括号 分号

let F70 = [] ;

构造函数声明

let F70=new Array()

解构

注：解构左右的数据类型，需要一致

功能：把引用数据类型，分解成基本数据类型

 [i,j]=[j,i]

数组的遍历

for…of会遍历出数组中的每个值

for…in 遍历出数组中每个值的下标

数据结构-集合

集合可以储存多个数据，数据不能重复

构造函数声明

let F70 = new Set();

对象

声明对象

字面量声明

let F70 = {} ;

对象的初始化

{

​ 属性名1:属性值1,

​ 属性名n:属性值n,}

方法名1:function(){代码块};

方法名n:function(){代码块};

属性和方法的添加

let qtt = {};

属性：

qtt.gf = “qyy”;

qtt.bf = “qqq”;

方法：

qtt.cry = function () {

this.money++;

}；

声明Symbol变量

let money=Symbol();

/使用方式:属性名[Symbol变量];

映射

let F70= new Map();

添加格式： 映射名.set(键名，键值)

F70.set(123,456);

使用格式 映射名.get(键名)

console.log(F70.get(123));//456

构造函数创建对象

let F70=new Object();

函数

声明函数

字面量声明

function F70 () {函数体}

构造函数声明

let F70 = new Function();

函数表达式(匿名函数表达式) 声明函数

let F70 =function(){函数体}

.arguments 返回所有实参

.length 返回所有行参

return具有终止当前函数的功能

不定参数 ： …行参 功能： 接收多的实参(以数组形式)，只能写在最后一个形参上

箭头函数

1、省略function关键字

2、如果只有一个形参，可以省略小括号

3、如果函数体只有一条语句，可以省略大括号

4、如果函数体只有一条语，并且需要返回这条语句的结果，可以省略return

5、不可以使用arguments

6、不会吧自己的this绑定在函数上

7、不可以用作构造函数

let F70 = (a, b) => {代码块}；

回调函数

当一个函数A，提供给函数B当参数，则A就是回调函数

//数组的排序
let F70=[1,30,440,5550,222,1];
//数组排序的升序
let arr=F70.sort((a,b)=>a-b)
console.log(arr);
//降序
let arr1=F70.sort((a,b)=>b-a)
console.log(arr1);


//数组的方法.every
// 判断数组中的每个值，是不是都满足需求
//注：所有都满足返回true，有1个不满足，则返回false
let F70=[2,2,3,4,5,7,7,8,9,4,3,2,2];
let state=F70.every(a=>a>1);//true
console.log(state);

// 数组的方法 some
//判断数组中的每个值，是不是都满足需求
//注 只要有1个满足，就返回true，都不满足就返回false
F70=[1,2,3,4,5,6,7,8,9,0]
state=F70.some(a=>a%2==0);
console.log(state);//true

//filter 过滤
//过滤满足条件的值
let F70=[1,30,50,11,5,,87];
let state=F70.filter(a=>a%2==0);
console.log(state);//30 80

//[交集、并集、差集]
let arr1=[1,2,3];
let arr2=[2,3,4];
//交集 [2,3]
let intersect=arr1.filter(a=>arr2.includes(a));
console.log(intersect);
//并集[1,2,3,4]
let intersect1=new Set([...arr1,...arr2]);
console.log([...intersect1]);
//差集[4]
let intersect2=arr2.filter(a=>!arr1.includes(a));
console.log(intersect2);


/**
 * 数组的方法 map：遍历出数组的中的每个值
 * 执行箭头函数的需求，把最终的结果，以新数组的方式返回
 */
let f70=[1,30,5,11,8,50];
// let state=f70.map(a=>a%2==0);
// console.log(state);//[ false, true, false, false, true, true ]

// let state=f70.map(a=>a-1);
// console.log(state);//[ 0, 29, 4, 10, 7, 49 ]
//.forEach 遍历出数组的每一个值,并且满足需求,无返回值
state = f70.forEach(
    a => {
        console.log(a - 1);
    }
);
console.log(state);

//[立即执行函数]（）（）；
//创建即调用，调用即销毁
//适用场景：关于一次性变量（时间）
(function F70() {
    console.log('F70');
})();

正则表达式

字面量声明

let re=/a/ig;//加g是全局查找 i是开启大小写不敏感
//大括号的功能：是不是以XXX开始的
let re=/^[1][3-9][0-9]{9}$/ig;
^[1]第一个数只能是1；
[^1]第一个数不能是1；
[3-9]范围3-9
[3-9]{9}相当于使用9次[3-9];

//贪婪匹配
 * 书写格式1{n};
 * 取满足n的个数的内容
 * 书写格式2{n,m}
 * 先取满足m的内容,当不满足时取m-n的
re=/[1-8]{2,5}/ig;