JavaScript笔记

JS

基础知识

JS-2 基础前提

使用Script标签包裹起来js

type指定为text/javascript

src可引入其他js

<script type="text/javascript" src="/path/to/script.js">
</script>

代码块：

使用；分隔开代码，否则有的语句会因为合并而出错

使用//来进行注释/**/多行注释

严格模式

使用‘use strict’开启严格模式，一旦开启就关不上

严格模式必须在js头部或者函数代码块顶部声明

变量命名

使用字母，数字，下划线，$符号命名，开头不可以是数字

可以使用非英文字母，但是不推荐，不通用

常用全大写的数字命名变量

基本数据类型

Number

特殊NaN和Infinity未知和无限大
String

单引号，双引号，反引号

反引号，扩展字面量，内部的代码可以先运算，也可以使用占位符需要使用${}符号包裹，

${}符号内的可以进行计算
null typeof null是object，但其自成一数据类型
undefined typeof undefined为undefined
Boolean
BigInt 无限长的大数，整数
Symbol 用于创建对象object的唯一标识符
typeof：识别基本数据类型，object，function

和instanceof使用原型链相区别，instanceof识别对象

且要用 a instanceof Objectb来用

基本交互

alert，confirm 确认并返回，prompt 输入并返回

alert("Hello")
let test = prompt("Test",default);//test用于接收,标题为第一个参数，第二个为默认值
let isBoss = confirm("Are you the boss?");//返回用户的确认和取消，为true和false

类型转换，转换成数字

Number可强制类型转换

undefined NaN

null 0

true false 0 1

String 去掉空格，会识别数字，含有其他符号会转换成NaN

转换成Boolean

直观上为空的都为false，包括NaN，其他为true字符串‘0’为true

基本运算符

数学，除了已基本的运算另外有 a**b a^b,求幂

其余会将字符串转换成数字

+号会连接字符串，表现在可连接多个，+可以为加号，也可以为字符串，

自有字符串开始，加号就开始连接字符

先有数字，数字开头的话会先进行数字运算

+作为一元运算符存在强制转换成数字
赋值，可链式赋值，逗号赋值，嵌套赋值
位运算符
- 按位与 ( & )
- 按位或 ( | )
- 按位异或 ( ^ )
- 按位非 ( ~ )
- 左移 ( << )
- 右移 ( >> )
- 无符号右移 ( >>> )

值相互比较

null undefined NaN可能比较的时候会进行隐示类型转换

==会进行隐示类型转换 ===严格相等，不会

字符串之间相互比较，会按照字典顺序比较，大小写的字典序可能会不一样，比较的时候最好先统一大小写

顺序，选择，循环

if，else，if else

？：和？：？：？：多个？层层剥开

？？空值，检测第一个定义好的值，并返回

和||区别，检测第一个定义好的空值，并返回

？？和|| &&禁止一同使用除非用括号隔开了
循环

while do while

switch case

case不break，会继续执行，case比较是严格相等的

函数

函数声明function fun（a,b,...c）{}
函数与变量，函数内可以用，修改函数外的变量

函数内部会遮蔽函数外的同名变量
函数的参数

扩展参数function fun（a,...b)接受为数组b

使用arguments获取参数

参数默认值 function fun（a,b=c）

或者使用a===undefined检查参数是否传入

或者使用function fun（a,b）{a=a||c} 传入默认值或者可用？？代替||
函数的返回

没有返回，或者返回为空，返回值为undefined

return后与返回值之间不可以空行否则会导致
函数立即调用

声明函数后可立即传入参数并调用，箭头函数也是一样

函数（参）

函数表达式

使用let a=function（）{}和function a（）{}一样
函数是一个值，可也给其他变量赋值

a=b则是赋值操作 a=b（）则将函数调用的结果给a

let a=b;多用分号，如果不清楚哪些会自动加分号
回调函数，将函数作为参数传入另一个函数
函数提升和变量提升，如果使用函数声明，则函数会提升，可以先使用再定义，因为函数提升了已经声明过
箭头函数let a=（参数）=>

JS-3调试

使用Debugger可暂停，或者手动点了暂停以跟踪变量
某种功能尽量抽离开来，模块化

JS-4 对象

对象的声明

let a={}
let a=new Object()

对象的属性

可以用a.访问属性

可以用delete a.删除属性

可以用“ll ii ”包裹声明多字词属性

必须用方括号访问多字词属性 a.["ll ii"] delete a.["lli i"]

计算属性[]，则会将括号先替代，计算再进行访问，当不确定对象的名称是什么

对象属性

在对象进行声明，创建的时候，默认参数名和对象属性名同名，则可以简写

对象的属性中可以使用保留字，如for return等

使用 a in obj判断对象中是否有该属性

使用for key in obj 遍历obj中的所有属性

属性遍历的时候整数属性名会自动排序，字符串属性名按照声明的顺序

克隆与合并

使用Object.assign(a,b,c)进行合并将a，b，c中的同名属性进行合并

可以用Object.assign浅拷贝，但如果其中有引用类型的数据，则指向同一个引用

深浅拷贝

const对象可以修改内部的值

对象的删除和回收机制

可达性对象和指针，有类············似于链式的结构

根据可达性进行删除删除每个链条的根，则剩余的元素不可达，则会被回收

对象方法简写和箭头函数

可以使用简单的方法声明对象中的函数使用类似属性的格式

let obj={

f：function（）{}

}

this指针，会实时进行计算，尽量用到它，在对象中的函数里会指向当前对象

箭头函数没有自己的this

构造器

可以写个构造函数，并返回一个对象，返回this

可以使用new Target,在函数内部，查看当前函数是否由new实例化

函数的return，可以return对象，可以return this，可以return空，默认为this

可选链？.

当不确定对象存在某种方法或者属性的时候?.可以先判断存在性，方式有

obj？.name

obj?.[name]

obj.name？.()

不存在则返回undefined

Symbol的使用

为什么要用？作为对象的属性，有唯一性，括号内的仅仅为描述字符

let a=Symbol（‘id’）

let b=Symbol('id')

a,b不相等，因为创建的是唯一性的

Symbol对象不可以自动转换成字符串，得有tostring方法才可以转换成字符
Symbol作为对象的属性

要用obj.[]来访问
Symbol的隐藏

不会被其他第三方代码库看到

不会被for in循环检索到
全局Symbol

使用Symbol.for('name')可以注册同名Symbol，会先检查是否有这个Symbol，如果没有再创建，如果有这两个Symbol指向同一个Symbol

使用Symbol.keyfor()可以找到Symbol对象的描述符

JS-5 常见数据类型和对象细讲

Number

在js中是IEEE754表示方法 64 位的有长度限制
10亿，bn

使用10_000_000下划线不会改变数字

使用aeb的方式表示科学计数法
使用0x十六进制 0b二进制 0o表示八进制
字符串进制转换，使用 a.tostring(2~36)默认为10进制转换

使用123..toString()和（123）.toString()一样
舍入

Math.floor()向下

Math.ceil()向上

Math.round()化整数Math.trunc()IE不适用

num.toFixed(n)小数点后舍入多少位

不精确计算，因为二进制的原因，不能整除，所以表示0.3的时候会有无限不循环小数，需要用Fixed等来去尾
特殊值Infinity，和NaN，无限，和错误数据，相关的有IsInfinity和IsNaN方法
使用+和Number（num,base)进行显示类型转换，一旦有非数字字符则会错误

使用ParseInt（num,base）和parseFloat（），开头必须为数字，可以读取到非数字的值截止

第一个参数为数字，第二个参数可以设置进制
Mathjs内置对象中还有许多数字方法

字符串

反引号，可以嵌入占位符，可以进行计算，使用${}包裹，可以直接键入特殊字符
使用num.length获取字符串长度，这个是属性，不是方法
使用str[n]和str.charAt(n)访问单个字符，注意单个字符不可以修改
大小写转换：str.toUpperCase() str.toLowerCase()
子串方法：
- str.includes(a,pos)子串，某位置开始 str.startsWith str.endsWith
- str.slice(start,end), 适用性强通常记住这个就行了
  
  str.substring(start,end),可以前大后小会自动逆转
  
  str.substr(start,length)仅仅适用于浏览器
字符串可以根据Unicode编码顺序比较大小

数组

声明

let a=[],let a=new Array()

let a=new Array（n）创建有长度的数组时候，没有传入值，则里面的将会是undefined
pop,push尾巴

shift,unshift头其中shift是取出，unshift是插入，由于需要重新计算和编号，pop，push尾部操作通常比较快
遍历

可用for of和for in遍历数组，但是保险起见for in会额外遍历其他数组，for of会隐藏属性，如果仅操作数组尽量只用for of
不要使用==比较数组，因为有隐示类型转换等问题，会出错
数组.toString方法，会用逗号隔开并输出

集合，Map，Array

同样拥有keys，values，entities其中entities包含keys和value键值对非map的keys和values的可以省略
对象和集合类的转换，

使用Object.entities(obj)从由对象转换成键值对数组

使用Object.fromEntities（Array）由数组转换成对象

解构赋值

尽量使用[]数组解构，减少{}对象解构，解构主义解构的嵌套
解构可以有默认值
结构末尾使用[a,b,...rest]使用扩展解构

数组使用...扩展解构收入数组

对象使用...扩展解构收入对象

日期Date对象

日期元年

let da=new Date（） 1970 1 1

let date=new Date（ms）1970 1 1+毫秒数

let date=new Date（year,month,date,hour,minute,second,ms）

json和对象的转换

互换

JSON.Parse() json转换成对象

JSON.stringify()对象转换成json字符串

JS-6 函数进阶

Rest参数和Spread

认识一下展开运算符有两种用法，作为未知数量的参数，可以用rest接受function f（a,b,...rest){}
用于展开数组，将数组的内容剥离出来spread，展开运算符，部分函数比如Math.max需要将元素展开来
使用...展开可以做到类似Object.assign()对象复制的事

变量作用域和闭包

块作用域和闭包，同名变量，块内会覆盖掉块外，块内没有变量则会找块外的变量
闭包内部可以访问到外部环境的变量，如果内部没有的话

var const let

var会变量声明提升，没有块作用域，只有全局作用域
var只有声明提升，赋值并没有提升，在未赋值的时候默认是undefined
函数也有声明提升如果使用function fun（）{}
函数可以立即作用，使用方式，在函数的末尾用括号传参，则自动调用

全局作用域

尽量不适用全局作用域

使用let const，不可以window访问，如果需要，可以注入到window的属性中，比如

window.newobj={

name:'hello'

}
window.Promise使用之来判断浏览器是否支持现代js语言

函数的属性和命名函数表达式

name属性，函数的名称
length属性检查函数参数的个数，rest参数，不计入
命名函数表达式let fun=function fu（）{}函数的名称为fun非fu

fu为局部参数，在函数内部可以内部调用

new Function

使用：let fun=new Function（‘a,b’，‘return’）

特点，不能使用外部的变量，严格使用传递的变量，有利于代码规范，尽量使用参数传递

SetTimeOut和SetIntervel

SetTimeOut 时延，一次性
SetInterVel 重复时间间隔来使用

可以嵌套使用SetTimeOut来模拟SetIntervel，前者的间隔更加精准

let timerId = setTimeout(function tick() {
  alert('tick');
  timerId = setTimeout(tick, 2000); // (*)
}, 2000);

参数，（function，delay，arg1，arg2，……)仅ie9以上才可以使用第三个参数，一般为前两个

使用ClearTimeout来清空计时器

装饰器，函数绑定

箭头函数的特点

没有arguments，

不可new调用

没有this指针

没有super

JS-7对象属性

属性标志和属性描述符

除了一般的属性，属性还有一些描述符，比如

writable可写可修改

enumerable可以枚举，会被累死for of扫描出

configurable 可修改可删除
查看属性的完整信息

let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);

返回一个对象
来修改属性

Object.defineProperty(obj, propertyName, descriptor)

参数为对象，属性名称，属性改变使用对象的方式来描述

属性的getter和setter

可以以get 和set为前缀，读取和修改对象的属性

可以“创建”一个对象中没有的属性

可以使用Object.defineProperty创建一个关于某属性的访问器

Object.defineProperty(user, 'fullName', {
  get() {
    return `${this.name} ${this.surname}`;
  },

  set(value) {
    [this.name, this.surname] = value.split(" ");
  }
});

可以使用get set，计算，描述，初始化原来没有的属性

JS-8 原型和继承

隐示，显示原型

当对象是使用new创建出来的，则有隐示，显示原型之区别

隐示原型 _proto_ 实例化后的
显示原型 Prototype 对象本身

可以从原生原型中修改和获取原型中的属性

原型的修改

Object.create(proto, [descriptors])创建一个以某为原型的对象

Object.getPrototypeOf(obj)获取当前对象的原型

Object.setPrototypeOf(obj, proto)]设定当前对象的原型

对象原型的设定必须是一个对象的prototype，或者null，字符串不能识别为原型

JS-9 class类

什么是类class

浅薄的理解，类是一种语法糖，方便对象的创建，类本身是一个函数，

类的构建时期做了几件事

创建一个构造函数constructor，设定好原型

类表达式

和函数同可以使用let User=class{} let User=class User1{}后面的User1是内部可访问名，User才是外部可以访问的类名

类中可以有get，set，可计算属性，使用[]括号包裹

类中的属性直接使用= ；赋值即可，使用函数中的写法，不需要和对象一样使用：，

类的继承

使用extends关键词可以继承别的类，可以重载重写方法，可重写一般方法和constructor方法

内建类，比如Array，Set，Map都是可以继承并扩展的

静态属性和静态方法

仅使用class原名调用不可使用实例化后的对象来调用

内部的受保护的属性，

使用_开头，则只能类的内部方法可以访问,口头君子约定，

使用#则进入法定，只能内部访问，会报错

instanceof判断对象的原型 obj instanceof Object，返回Boolean类型的值

使用obj.prototype.Tostring（）可以看对象的类型，原型

可以嵌套原型，形成一个对象继承多个对象的效果

JS-10 try catch

try包裹可能出错的代码

catch处理错误

finally无论错误是否发生都会执行

JS-11 Promise

回调与异步

在资源加载的时候需要时间，但是代码的执行并不会等资源，如果需要可以采用回调方式进行一定的异步

但是回调的嵌套容易造成结构不清晰，多层嵌套后会造成回调地狱

使用Promise和它的结构

Promise 的结构 let pro=new Promise（function（resolve，reject）{

生产

}）

pro.then（function（result）{}，function（err）{}）接受两个参数，成功和失败

pro.catch（function（err）{}）接受一个错误参数，可以使用then（null，fun）等效

pro.finally(fucntion(){})不接受参数

Promise链

Promise可以串联，错误可以承接到下一级，最终未处理的错误可以由windows捕获

多个Promise

Promise.all([])等多个promise都resolve

Promise.allSetted([])所有的promise都setted

Promise.race([])等任意一个setted

Promise.any([])等任意一个resolve

Promise.resolve([])创建一个resolve的promise

Promise.reject([])创建一个reject的promise

promise本身是宏任务，后面的then，catch是微任务

async该函数会返回一个resolve的promise对象，可以默认返回也可以指定返回某个promise

wait，仅仅能再async中使用，等待一个promise被完成

JS-12 生成器Generator和迭代

在函数前加*构造一个生成器，使用next可以迭代
在非迭代对象中使用*[Symbol.iterator] (){}可以将其变成可迭代对象
迭代器可以组合
使用generator.return终止迭代
value求值，done查看是否迭代完成
可以使用throw抛出错误

JS-13 导入和导出

文件导出，有自己的作用域变量，其他文件不可访问
export default p，每个文件仅仅可以导出一个default，导入时没有指定变量名称，或者使用未知名称，会导入这个默认导出项
导入导出，使用as更名

ES6新特性

ES6-1 var let const

var有变量提升：先使用后定义会自动事先声明，先使用后定义是不规范的行为
let const为块作用域，var没有块作用域的效果
const本身不可更改，但其内部如果const定义了数组或class，内部数据是可以更改的
let const不可重复定义

块级循环绑定settimeout定时器：

for循环中

var因为变量提升会共享一个变量

可用let替代var

可用const +数组使用for-in和for-of

ES6-2 字符串

新增方法

charcodeat=》codePointat

String.fromCodePoint

常用方法

startswith

endswith

includes

不可掺入正则表达式

indexof lastindexof可以

repeat()字符串重复

trim（）去掉头尾空格

模板字面量

反引号包围即可

保留符号，不再需要转义，但可识别转义

可以占位，${}插入变量

ES6-3函数

默认值

方便的传入默认值

arguments对象非严格模式和严格模式

不再会因参数的变化而改变，以往会因参数的改变而同步变化

默认参数可以是方法

默认参数的顺序，临时死区，不要在未初始化前使用，不要用后面的初始化前面的

剩余参数

声明function f (a,...keys){}

剩余参数必须放在最后，不定长，以数组的方式存在

和arguments不冲突

增强的Function构造函数

可fun ("first","Second","return first +second")函数的简写，在参数的最后添加一个return

展开运算符：

（...keys）会将数组中参数展开

（...keys,key2）可与后面的参数合并

明确函数的构造和new.target

判断是否用new来声明函数：

this instanceof person

typeof new.target != undefined

判断函数的类型

new.target == person

箭头函数

特性简介

没有this，super，new.target,arguments的绑定

不可用new创建，没有原型

不可支持arguments

不支持重复的命名参数

声明

let fun=（参数）=>{功能}

立即执行函数

函数声明后再加参数function（）{}（）函数会立即执行

箭头函数的this指向父级区域的非箭头this

尾调函数

function(){
let else=function(){}
return else//不是直接的函数
return else2()//优化
return 1+else3()//有额外的运算，不优化

}

ES6-4 扩展对象的功能性

对象字面量语法的扩展

属性名和参数名同简写

function createPerson(name,age){
	return {
		name:name,
		age:age
	}
}
function createPerson(name,age){
	return {
		name,
        age
	}
}

函数声明简写

let person = {
	sayName:function(){
		return name;
	}
}
let person = {
	sayName(){
		return name;
	}
}

可计算属性名

对象的属性加方括号，括号内的内容最终会计算为一个字符串

preson[a +b]

object.is(a,b)和===

大部分情况下很像，差异：

object.is ===

nan true false

0+0- false true

object.assign()混合数据

特点：下面的会覆盖上面的，返回首个

let person = {
	name:'hello',
	age:18
}
let car= {
	brand:'BWM',
	age:5
}
let obj={}
object.assign(obj,person,car);
//obj{name:'hello',brand:'BWM',age:5}

ES6允许属性重复定义，后面的会覆盖前面的，ES5在严格模式下会报错

属性枚举

数字类键，字符串类键，符号类键，依次升序排列

ES6-5 解构的使用

对象解构

对象解构：{a,b}=node
解构赋值：({a,b}=node)不加括号，会报错
非同名解构：{a:a1,b:b1}=node
嵌套对象解构：注意括号匹配，大括号之内是同级解构
可以有默认值undefined，可以赋值默认值undefined的时候自动生效

数组解构

用中括号取代花括号，数组和对象解构的区别,解构赋值不需要（）:

let [a,b]=['red','blue']

占位解构:

[,,c]=['red','blue','green']

未知个数参数解构,以数组的方式接受:

[a,...colors]=['red','blue','green']

数组解构应用，换位[a,b]=[b,a]
可以有默认值undefined，可以赋值默认值undefined的时候自动生效

混合解构

注意括号嵌套的位置即可

解构的方式传参，可以用解构的方式来传参，但是必须传值或者拥有默认值，否则会报错

ES6-6 Symbol和Symbol的属性

存在的意义

独立于null,undefined,number,string,boolean之外的第六个数据类型，为了以新的方式描述对象的属性

基础语法

声明

let firstname=Symbol(),

可以添加一段描述，仅仅是描述：let firstname=Symbol('first name')

不可以用new创建

console.log(firstname)//Symbol(first name)

使用

不再以.而是以[]的方式访问

let firstname=Symbol()

person[firstname]='hello';

或者使用defineProperty defineProperties来改变symbol

ES6-7 Set和Map

声明

Let set=new Set()

Let set=new Set([1,2,3,4])

常用函数

set.add

set.has

set.size

set.delete

foreach(function(value,key,ownerSet){})

和数组的相互转化

转化成set ：let set=new Set（array）

转化成数组：array=[...set]扩展运算符

WeakSet
Map0

1.初始化

let map=new Map（）

let map=new Map（[['hello',p1],['hello',p2]]）双层括号来初始化

常用方法

set，has,delete,clear

同样有foreach

foreach(function(value,key,ownerSet){})

WeakMap

原型和原型链

基本概念

原型：隐示原型 —proto—显式原型prototype实例化的原型，声明的原型

原型链:当前实例的方法，会从自身，或者继承的父类，祖先的原型中中寻找该方法

原型修改

Object.getPrototypeof(obj)//获取原型
Object.setPrototypeof(obj1,obj2)//将第二个的原型覆盖到第一个
//可以通过superd调用原型中的函数

方法

一个拥有[[HomeObject]]内部属性的方法

对象中的才叫方法，

单独的函数不定义为方法

ES6-8 迭代器和生成器

生成器

function 后面加个*,函数内用yield来生成，

yield生成后会暂停，

迭代器

使用next生成下一个，done属性表示后面已经没有对象了

next有value，key

for-of循环可以访问迭代对象
使用Symbol.iterator可以将不可迭代对象改成可迭代对象
集合对象的迭代器：含有entries，键值对values，值key，键
ES6支持对字符串的完全迭代
...展开运算符可以完全展开数组，并且可以嵌套在数组中
next传递参数，则会在yield处对应位置嵌入变量参与运算
yield处使用return语句，可以提前结束生成，return处可以返回结果
生成器可以委托，几个生成器之间可以组合

ES6-9 类class

类的由来：

ES5中使用this赋值模拟构造函数，

用给原型添加函数的方式模拟类的方法

类的声明

使用constructor作为构造函数

使用fun(){}声明方法

类的特点

类的声明不会提升，存在临时死区
类中的代码自动使用严格模式
类中的所有方法都是不可枚举的
类中的所有方法没有[[constructor]]属性不可new
于类方法中重写类名会出错，
类必须使用new声明

类表达式let person=class{ constructor（）{}，fun（）

会自动声明一个person的类

let person=class person2{constructor（）{}，fun（）{}}

类外仍然是person typeof personfunction，typeof person2 undefined
类作为一等公民

和方法一样，类作为一等公民，可以作为参数，可以给变量赋值，可以作为返回值

可计算成员变量

使用可计算成员，使用方括号声明，可在类外声明，放到类内

let methodName=“sayName”；

class PersonClass{

[methodName]（）{}

}

类与生成器迭代器，迭代器和生成器可以放在类内使用
静态方法和实例方法静态方法用static描述，只可只用类Class.调用，不可用实例调用

可以使用静态方法返回一个new的形式创建一个类
继承和派生

使用extends关键词来表示继承

只有派生类的构造函数才可以使用super调用父类的构造函数

派生类可以重写和覆盖父类的方法

从表达式中派生类：可创建对象，并将其派生出类，或再用函数封装，派生出类
内建对象的继承可以继承js的内置对象，比如数组
使用new.target判断调用的哪个构造函数

ES6-10 数组

新的数组创建方法

原始：使用let items=new Array(),new Array(2)长度为2，undefined
Array.of: let items=Array.of(2) 实例化（）内的数据，为数组
Array.from(nums,yinshe,this)从数组对象和可迭代对象（有Symbol.species属性的）转化为数组

数组的一些新方法

find ，findindex找到符合条件的元素，找到符合元素的下标

arr.find/findx(item=>item>5)
fill方法，填充数组的所有元素，替换数组的所有元素

单参数：全部双参数：替换，开始三参数：替换，开始，结束左开右闭
copywithin方法

（a,b）a复制到，b来源于，c复制长度（a,b,c）

ES6-11 Promise与异步编程

promise的目的：解决多层回调函数嵌套带来的不便，回调地狱
回调函数的生命周期
1. pending state， unsettled
2. settled=》fulfilled,rejected 内部的[[PromiseState]]会有pending，fulfilled，rejected
创建未决和已决的promise

未决：

let promise=new Promise（function（resolve，reject）{}）；两个函数，分别在成功和失败的时候会执行

已决：

let promise=Promise.resolve(value1)

let promise=Promise.reject(value2)

当成功和失败的时候resolve和reject会接受两个参数
当一个对象有可以接受resolve和reject函数的then方法，那么，可以将其作为参数传入Promise，以实例化一个Promise对象
当Promise执行器内部抛出一个错误，会自动执行reject方法
Promise链

Promise链条中，then和catch会新建一个Promise，加入宏任务队列的尾部

Promise中的错误会传递到下一个Promise中捕获

Promise可以返回值作为参数传入到下一个Promise

Promise对象可以作为返回值，作为参数传入到下一级的Promise
监听多个Promise

可以接受一个可迭代Promise对象数组

Promise.all：所有的已决，单个才已决

Promise.race ：有一个已决，立即已决
Promise可以被继承

ES6-12 代理和反射接口

ES6-13 模块化和封装

模块化的特点
1. 和类class类似，强制严格模式
2. 模块的顶级作用域创建的变量不会到全局作用域
3. 模块的顶级作用域this值为undefined
4. 模块不允许html风格的注释
5. 模块外需要用到，必须导出
6. 可以从其他模块导入绑定
使用export关键词导出

使用import关键词导入

使用import {a,b,c} from 'd.js'

使用import * as a from ‘d.js’

导入和导出都可以使用as重命名
默认值

一个组件可以导出一个默认值，唯一的除此之外可以另外导入默认值

一个组件可以导入默认值，不需要加{}，并且可以给默认值任意命名，可以同时导入默认值和非默认值组件

重难点

call bind apply

call绑定后立即执行

bind不会立即执行可以用立即执行函数（）执行，会返回一个函数

apply的第二及以后的参数需要放在一个数组中

运算符和类型判断

和= ==会先进行隐示类型转换
instanceof基于原型链，引用类型
typeof用于数据类型判断

typeof function是function

typeof（null）object

nan无论和什么都是false

事件循环

https://jishuin.proginn.com/p/763bfbd5505b

是否改变string数组的js方法

会改变

push末尾加，

pop弹出最后

splice切割

shift删除头，unshift插入头

sort排序，reverse逆转

不会改变

concat连接两个

join数字转换成数组

slice不改变的截取

严格模式

”use strict“会对一些不严谨的地方审查

作用域和作用域链

子域可用父域的元素

父域不可以用子区域的元素

闭包

函数声明之后会形成一个闭包，闭包内声明的变量闭包内其他函数可以使用

函数闭包中声明的变量，在子函数执行的时候变量并不会销毁，

闭包中的变量会维持一个缓存，可能造成内存消耗，需要手动销毁赋值为null

没看懂的

Symbol

对象原始值转换https://note.xiexuefeng.cc/post/valueof-tostring-toprimitive/

事件循环生命周期

switch，每一个case都需要有break，否则会继续下去

错题笔记

1-50

var声明会提升，赋值不会提升，未赋值则为undefined，let，const未声明会报错
箭头函数没有自己的this，在其中this会指向外部作用域，对象中使用箭头函数this可能会指向对象外
+化字符串为数字
new Number和数字不一样，它是一个对象，数字是基本数据类型
函数本身是个对象可以有属性
不可以在构造函数中添加属性，需要的话必须在原型中
不使用new 情况下使用this，会指向全局对象
事件的三个阶段，捕获，目标，冒泡
除了基本对象Object，指向null，其他对象都有原型
字符串相加，一旦碰到引号，则开始转换成字符串，数字在前面可以先运算
字面量函数，第一个为打散的字符串，剩余为传入的参数值
基本对象比较值，引用对象比较内存引用，引用对象不同== ===都是false
typeof array object，数组是对象
sessionStorage关闭标签页就没了
localstorage永远保存
对象的键都是字符串，集合map键有自己的类型
call是立即执行的函数绑定，bind是不立即执行的函数绑定
typeof a返回的是一个字符串 typeof typeof a string
setInterval ，SetTimeOut，返回的是一个唯一标识的id，可以用于计时器清除
ParseInt（‘字符串’碰到不合法的就截止，n进制）
当一个数字没有申明，要么报错，要么说明已近全局变量声明过了
当一个不存在的函数被调用则是typeerror
没有let var const声明，则设置了一个全局对象的属性var let const不可以用delete删除，delete删除为
[]=obj关注是否是解构赋值
JSON.stringify的第二个参数是 替代者(replacer). 替代者(replacer)可以是个函数或数组，用以控制哪些值如何被转换为字符串。
symbol（）是唯一的强制类型转换也一样
padStart字符串填充到几位，少了则补多了不填
String.raw ` `会显示字符串原有的样子
Promise挂起后要使用.then.catch,才变为settled状态，否则还是挂起的状态pendding
push方法，返回list的长度

50-100

76解构赋值

79for in看键 for of 看值

81 变量未赋值undefined

82 call和bind 函数.call(this或者对象)

92 箭头函数没有原型

95 return语句后面会自动加分号，如果隔行将return ；

98 箭头函数返回对象外面要嵌套圆括号

100 && 左侧真，返回右侧，左侧假不返回

100-150

101 ||返回第一个真值，否则返回最后一个值

106 访问对象的属性，点表示法和括号表示法，当表达式比较长，有.嵌套，考虑用括号表示法

107 表情符号是Unicode编码

110 JSON.parse转换成js

JSON.string转换成json字符串

111.函数有自己的执行上下文，函数会优先找自己的上下文中的变量，检查语法

找不到，再找外层

yield*可以嵌套生成函数，或者嵌套遍历可迭代对象
console.log(${(x => x)('I love')} to program)其中有字面量，和箭头函数，立即执行函数
注意函数是作为值，还是作为执行结果
！非空是 false
Number.isNaN是否是NaN isNaN判断是否是数字，是数字则false
扁平化数组arr.flat(n) 1的话就拆分一层内数组
Object.freeze()冻结一个对象。不能添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。冻结一个对象后该对象的原型也不能被修改。

Object.seal()封闭一个对象。不能添加新属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，已有属性的值以然可以修改。(也就是说descriptor里的writable变成没有变，configurable变成false了)

错题笔记二轮

11.必须通过原型链得到构造函数的属性，不然通过构造函数实例化后的对象拿不到

12.new会改变当前的指针到当前对象，不用new使用的函数，指针会指全局

17.对象字面量的首个参数是字符串，然后是占位符后的元素

18.引用对象== ===比较的均是引用

20 24

字符串化一个对象后，会自动变成”object object“

47 50

引用类型传参会改变值，基本类型传参不会

数据冒泡

NAN

js和jquery

posted @ 2022-06-13 23:36 超安全阅读(92) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 前端面试-老朱版本

· 前端遗忘知识点

· JavaScript笔记

· ES6-11语法笔记

· 学习ES6

公告

昵称：超安全
园龄： 3年3个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六