4359 字
22 分钟
JS-高级

目录#

JSON方法#

标准JSON格式#

  • 键必须是双引号
  • 值如果是字符串,也必须是双引号,必须是一个确定的值,不能是一个函数调用
  • 多个键值对之间用逗号相隔,最后一个键值对后面不能加逗号(js中可加可不加)
{
"key1": "value1",
"key2": "value2"
}

stringify#

JSON 支持以下数据类型:

  • Objects { ... }
  • Arrays [ ... ]
  • Primitives:
    • strings,
    • numbers,
    • boolean values true/false,
    • null。

JSON 是语言无关的纯数据规范,因此一些特定于 JavaScript 的对象属性会被 JSON.stringify 跳过。

即:

  • 函数属性(方法)。
  • Symbol 类型的键和值。
  • 存储 undefined 的属性。

JSON.stringify 的完整语法是:

let json = JSON.stringify(value[, replacer, space])

value

要编码的值。

replacer

要编码的属性数组或映射函数 function(key, value)。

space

用于格式化的空格数量

let obj = {
name: "阿坤",
age: 27,
hobby: ['唱','跳','rap','篮球']
}
let json = JSON.stringify(obj);
console.log(typeof json); // string
console.log(json); // {"name":"阿坤","age":27,"hobby":["唱","跳","rap","篮球"]}
let obj = {
name: "阿坤",
age: 27,
hobby: ["唱", "跳", "rap", "篮球"],
};
// 只编码指定属性
let json = JSON.stringify(obj, ['name', 'hobby']);
console.log(json); // {"name":"阿坤","hobby":["唱","跳","rap","篮球"]}
let json1 = JSON.stringify(obj, (key, value) => key === "name" ? "坤坤" : value);
console.log(json1); // {"name":"坤坤","age":27,"hobby":["唱","跳","rap","篮球"]}
let json2 = JSON.stringify(obj, null, 4);
console.log(json2); // 格式化输出, 如下
{
"name": "阿坤",
"age": 27,
"hobby": [
"唱",
"跳",
"rap",
"篮球"
]
}

重写

let obj = {
name: "阿坤",
age: 27,
hobby: ["唱", "跳", "rap", "篮球"],
toJSON() {
return "我是toJSON";
},
};
let json = JSON.stringify(obj);
console.log(json); // 我是toJSON

parse#

要解码 JSON 字符串,我们需要另一个方法 JSON.parse。

语法:

let value = JSON.parse(str, [reviver]);

str

要解析的 JSON 字符串。

reviver

可选的函数 function(key,value),该函数将为每个 (key, value) 对调用,并可以对值进行转换。

let obj = {
name: "阿坤",
age: 27,
hobby: ['唱','跳','rap','篮球']
}
let json = JSON.stringify(obj);
console.log(typeof json); // string
console.log(json); // {"name":"阿坤","age":27,"hobby":["唱","跳","rap","篮球"]}
let obj1 = JSON.parse(json);
console.log(typeof obj1); // object
console.log(obj1); // { name: '阿坤', age: 27, hobby: [ '唱', '跳', 'rap', '篮球' ] }
let user = {
sayHi() { // 被忽略
alert("Hello");
},
[Symbol("id")]: 123, // 被忽略
something: undefined // 被忽略
};
console.log( JSON.stringify(user) ); // {}(空对象)

第二个参数

let str = '{"title":"Conference","date":"2017-11-30T12:00:00.000Z"}';
// 解析时将date转为Date对象
let obj = JSON.parse(str, (key, value) =>
key === "date" ? new Date(value) : value
);
console.log(obj.date.getDate()); // 30

调度#

有时我们并不想立即执行一个函数,而是等待特定一段时间之后再执行。这就是所谓的“计划调用(scheduling a call)”。

目前有两种方式可以实现:

  • setTimeout 允许我们将函数推迟到一段时间间隔之后再执行。
  • setInterval 允许我们重复运行一个函数,从一段时间间隔之后开始运行,之后以该时间间隔连续重复运行该函数。

setTimeout#

语法:

let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...)

参数说明:

func|code

想要执行的函数或代码字符串。 一般传入的都是函数。由于某些历史原因,支持传入代码字符串,但是不建议这样做。

delay

执行前的延时,以毫秒为单位(1000 毫秒 = 1 秒),默认值是 0;

arg1,arg2…

要传入被执行函数(或代码字符串)的参数列表(IE9 以下不支持)

setTimeout 在调用时会返回一个“定时器标识符(timer identifier)”,在我们的例子中是 timerId,我们可以使用它来取消执行。

let timerId = setTimeout(...);
clearTimeout(timerId);
fun.count = 0;
function fun(...args) {
fun.count++;
console.log(fun.count, args);
}
let timer = setTimeout(fun, 1000, 1, 2, 3); // 1 [ 1, 2, 3 ]
// clearTimeout(timer); // 取消定时器

setInterval#

setInterval 方法和 setTimeout 的语法相同:所有参数的意义也是相同的。

不过与 setTimeout 只执行一次不同,setInterval 是每间隔给定的时间周期性执行。

// 用 setTimeout实现 setInterval, 更灵活
// 采用这种方式可以根据当前执行结果来调度下一次调用,因此下一次调用可以与当前这一次不同。
let timerId = setTimeout(function tick() {
console.log("tick");
timerId = setTimeout(tick, 1000); // (*)
}, 1000);
// 原生setInterval, 更简洁
let timer = setInterval(() => console.log("tick"), 1000);

区别

对 setInterval 而言,内部的调度程序会每间隔 100 毫秒执行一次 func(i++):

  • 如果函数执行时间超过100毫秒,那么两次函数之间将不会有任何时间间隔

嵌套的 setTimeout 就能确保延时的固定(这里是 100 毫秒)。

  • 保证的是函数执行完后,开始计时延迟时间

  • 只有在当前正在执行的脚本执行完成后,调度程序才会调用它。
setTimeout(() => console.log("World"));
console.log("Hello"); // Hello World

在浏览器环境下,嵌套定时器的运行频率是受限制的。根据 HTML5 标准 所讲:“经过 5 重嵌套定时器之后,时间间隔被强制设定为至少 4 毫秒”。

对于服务端的 JavaScript,就没有这个限制,并且还有其他调度即时异步任务的方式。例如 Node.js 的 setImmediate。

请注意,所有的调度方法都不能 保证 确切的延时。

例如,浏览器内的计时器可能由于许多原因而变慢:

  • CPU 过载。
  • 浏览器页签处于后台模式。
  • 笔记本电脑用的是省电模式。

所有这些因素,可能会将定时器的最小计时器分辨率(最小延迟)增加到 300ms 甚至 1000ms,具体以浏览器及其设置为准。

原型/原型链#

在 JavaScript 中,对象有一个特殊的隐藏属性 [[Prototype]](如规范中所命名的),它要么为 null,要么就是对另一个对象的引用。该对象被称为“原型”:

  • 通过原型继承属性
function User(name, birthday) {
this.name = name;
this.birthday = birthday;
}
let GEM = new User("邓紫棋", new Date(1991, 8, 16));
let GEM_chirld = {};
GEM_chirld.__proto__ = GEM;
console.log(GEM_chirld); // User {}
// 从 GEM_chirld 中读取一个它没有的属性,JavaScript 会自动从 GEM 中获取。
console.log(GEM_chirld.name); // 邓紫棋
// 原型是只读的, 不能通过原型修改继承对象的值, 这样只会给当前对象添加一个新属性,
// GEM 的 name仍是"邓紫棋"
GEM_chirld.name = '小邓紫棋';
console.log(GEM_chirld); // User { name: '小邓紫棋' }

在这儿我们可以说 “GEM 是 GEM_chirld 的原型”,或者说 “GEM_chirld 的原型是从 GEM 继承而来的”。

let people = {
name: "邓紫棋",
};
let woman = {
sex: "女",
__proto__: people,
};
let GEM = {
occupation: "songer",
__proto__: woman,
};
console.log(GEM.name, GEM.sex, GEM.occupation); // 邓紫棋 女 songer
// 原型链的尽头是null
console.log(people.__proto__); // [Object: null prototype] {}

这里只有两个限制:

  1. 引用不能形成闭环。如果我们试图给 __proto__ 赋值但会导致引用形成闭环时,JavaScript 会抛出错误。
  2. __proto__ 的值可以是对象,也可以是 null。而其他的类型都会被忽略。

遍历键

'use strict';
let people = {
name: "邓紫棋",
};
let woman = {
sex: "女",
__proto__: people,
};
let GEM = {
occupation: "songer",
__proto__: woman,
};
GEM.name = 'g e m';
// 遍历自己的及继承的键
for (const key in GEM) {
console.log(key); // occupation name sex
}
// 遍历自己的键
console.log(Object.keys(GEM)); // [ 'occupation', 'name' ]

prototype#

let people = {
study(){
console.log('学习原子弹');
}
}
function Genenius(name) {
this.name = name;
}
Genenius.prototype = people;
let g = new Genenius('爱因斯坦');
g.study(); // 学习原子弹

F.prototype 属性仅在 new F 被调用时使用,它为新对象的 [[Prototype]] 赋值。

常规对象中prototype只是常规属性, 没有特殊意义

function Rabbit() {}
// 默认:
// Rabbit.prototype = { constructor: Rabbit }
alert( Rabbit.prototype.constructor == Rabbit ); // true
let rabbit = new Rabbit(); // 继承自 {constructor: Rabbit}
alert(rabbit.constructor == Rabbit); // true (from prototype)
let rabbit2 = new rabbit.constructor("Black Rabbit");

原生的原型#

let obj = {};
alert(obj.__proto__ === Object.prototype); // true
alert(obj.toString === obj.__proto__.toString); //true
alert(obj.toString === Object.prototype.toString); //true

一切都是从对象继承而来#

let arr = [1, 2, 3];
// 它继承自 Array.prototype?
alert( arr.__proto__ === Array.prototype ); // true
// 接下来继承自 Object.prototype?
alert( arr.__proto__.__proto__ === Object.prototype ); // true
// 原型链的顶端为 null。
alert( arr.__proto__.__proto__.__proto__ ); // null

所以数组中的方法都是原型链上继承的

更改原生原型#

  • 知道可以这么做, 但通常不推荐这么做
  • 更改原型是一个非常缓慢的操作,因为它破坏了对象属性访问操作的内部优化。
String.prototype.show = function () {
console.log(this.toString());
};
"BOOM!".show(); // BOOM!
  • 字符串: String.prototype
  • 数字: Number.prototype
  • 数组: Array.prototype
  • Map: Map.prototype
  • Set: Set.prototype
  • 对象: Object.prototype

在现代编程中,只有一种情况下允许修改原生原型。那就是 polyfilling。

Polyfilling 是一个术语,表示某个方法在 JavaScript 规范中已存在,但是特定的 JavaScript 引擎尚不支持该方法,那么我们可以通过手动实现它,并用以填充内建原型。

借用原生原型中的方法

let obj = {
0: "Hello",
1: "world!",
length: 2,
};
obj.join = Array.prototype.join;
alert( obj.join(',') ); // Hello,world!

原型方法#

现代的获取/设置原型的方法有:

__proto__ 不被反对的唯一的用法是在创建新对象时,将其用作属性:{ __proto__: ... }。

虽然,也有一种特殊的方法:

let clone = Object.create(
Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj)
);

此调用可以对 obj 进行真正准确地拷贝,包括所有的属性:可枚举和不可枚举的,数据属性和 setters/getters —— 包括所有内容,并带有正确的 [[Prototype]]。

Mixin#

Mixin 模式 https://zh.javascript.info/mixins

Mixin —— 是一个通用的面向对象编程术语:一个包含其他类的方法的类。

一些其它编程语言允许多重继承。JavaScript 不支持多重继承,但是可以通过将方法拷贝到原型中来实现 mixin。

我们可以使用 mixin 作为一种通过添加多种行为(例如上文中所提到的事件处理)来扩充类的方法。

let eventMixin = {
/**
* 订阅事件,用法:
* menu.on('select', function(item) { ... }
*/
on(eventName, handler) {
if (!this._eventHandlers) this._eventHandlers = {};
if (!this._eventHandlers[eventName]) {
this._eventHandlers[eventName] = [];
}
this._eventHandlers[eventName].push(handler);
},
/**
* 取消订阅,用法:
* menu.off('select', handler)
*/
off(eventName, handler) {
let handlers = this._eventHandlers?.[eventName];
if (!handlers) return;
for (let i = 0; i < handlers.length; i++) {
if (handlers[i] === handler) {
handlers.splice(i--, 1);
}
}
},
/**
* 生成具有给定名称和数据的事件
* this.trigger('select', data1, data2);
*/
trigger(eventName, ...args) {
if (!this._eventHandlers?.[eventName]) {
return; // 该事件名称没有对应的事件处理程序(handler)
}
// 调用事件处理程序(handler)
this._eventHandlers[eventName].forEach(handler => handler.apply(this, args));
}
};
  1. .on(eventName, handler) — 指定函数 handler 以在具有对应名称的事件发生时运行。从技术上讲,这儿有一个用于存储每个事件名称对应的处理程序(handler)的 _eventHandlers 属性,在这儿该属性就会将刚刚指定的这个 handler 添加到列表中。
  2. .off(eventName, handler) — 从处理程序列表中删除指定的函数。
  3. .trigger(eventName, ...args) — 生成事件:所有 _eventHandlers[eventName] 中的事件处理程序(handler)都被调用,并且 ...args 会被作为参数传递给它们。
// 创建一个 class
class Menu {
choose(value) {
this.trigger("select", value);
}
}
// 添加带有事件相关方法的 mixin
Object.assign(Menu.prototype, eventMixin);
let menu = new Menu();
// 添加一个事件处理程序(handler),在被选择时被调用:
menu.on("select", value => alert(`Value selected: ${value}`));
// 触发事件 => 运行上述的事件处理程序(handler)并显示:
// 被选中的值:123
menu.choose("123");

错误处理#

try…catch#

try {
// ...
} catch (err) { // <-- “error 对象”,也可以用其他参数名代替 err
// ...
}
try {
// ...
} catch { // <-- 没有 (err)
// ...
}

Error对象#

对于所有内建的 error,error 对象具有两个主要属性:

name

Error 名称。例如,对于一个未定义的变量,名称是 "ReferenceError"。

message

关于 error 的详细文字描述。

还有其他非标准的属性在大多数环境中可用。其中被最广泛使用和支持的是:

stack

当前的调用栈:用于调试目的的一个字符串,其中包含有关导致 error 的嵌套调用序列的信息。

try {
lalala; // error, variable is not defined!
} catch (err) {
alert(err.name); // ReferenceError
alert(err.message); // lalala is not defined
alert(err.stack); // ReferenceError: lalala is not defined at (...call stack)
// 也可以将一个 error 作为整体显示出来
// error 信息被转换为像 "name: message" 这样的字符串
alert(err); // ReferenceError: lalala is not defined
}

throw#

技术上讲,我们可以将任何东西用作 error 对象。甚至可以是一个原始类型数据,例如数字或字符串,但最好使用对象,最好使用具有 name 和 message 属性的对象(某种程度上保持与内建 error 的兼容性)。

JavaScript 中有很多内建的标准 error 的构造器:Error,SyntaxError,ReferenceError,TypeError 等。我们也可以使用它们来创建 error 对象。

throw <error object>

finally#

  • 即使try或catch中return出函数, 也会执行finally中的代码
  • promise 的处理程序 .then、.catch 和 .finally 都是异步的。
try {
... 尝试执行的代码 ...
} catch (err) {
... 处理 error ...
} finally {
... 总是会执行的代码 ...
}

自定义异常#

class ValidationError extends Error {
constructor(message) {
super(message); // (1)
this.name = "ValidationError"; // (2)
}
}
function test() {
throw new ValidationError("Whoops!");
}
try {
test();
} catch(err) {
alert(err.message); // Whoops!
alert(err.name); // ValidationError
alert(err.stack); // 一个嵌套调用的列表,每个调用都有对应的行号
}

generator#

常规函数只会返回一个单一值(或者不返回任何值)。

而 generator 可以按需一个接一个地返回(“yield”)多个值。它们可与 iterable 完美配合使用,从而可以轻松地创建数据流。

要创建一个 generator,我们需要一个特殊的语法结构:function*,即所谓的 “generator function”。

function* generator() {
yield 1;
yield 2;
yield 3;
return 4;
}
console.log(generator()); // Object [Generator] {}
let gen = generator();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: 4, done: true }
console.log(gen.next()); // { value: undefined, done: true }

next() 的结果始终是一个具有两个属性的对象:

  • value: 产出的(yielded)的值。
  • done: 如果 generator 函数已执行完成则为 true,否则为 false。

迭代#

// 可迭代的函数
function* generator() {
yield 1;
yield 2;
yield 3;
return 4;
}
console.log([...generator()]); // [ 1, 2, 3 ]
// 不会遍历出return的值
for (let value of generator()) {
console.log(value); // 1 2 3
}

实现Range对象#

class Range {
constructor(from, to) {
this.from = from;
this.to = to;
}
*[Symbol.iterator]() {
// [Symbol.iterator]: function*() 的简写形式
for (let value = this.from; value <= this.to; value++) {
yield value;
}
}
}
let range = new Range(1, 5);
console.log([...range]); // 1,2,3,4,5
for (let value = from; value <= to; value++) {
yield value;
}
}
console.log([...range(1, 5)]); // 1,2,3,4,5

Yield#

function* generator() {
let res1 = yield "hello";
console.log(res1);
}
let gen = generator();
// 获取yield的值
console.log(gen.next().value); // hello
// 向yield传递值, 返回到res1中打印
gen.next("world").value; // world
  1. 第一次调用 generator.next() 应该是不带参数的(如果带参数,那么该参数会被忽略)。它开始执行并返回第一个 yield "2 + 2 = ?" 的结果。此时,generator 执行暂停,而停留在 (*) 行上。
  2. 然后,正如上面图片中显示的那样,yield 的结果进入调用代码中的 question 变量。
  3. 在 generator.next(4),generator 恢复执行,并获得了 4 作为结果:let result = 4。

模块#

模块 https://zh.javascript.info/modules

一个模块(module)就是一个文件。一个脚本就是一个模块。就这么简单。

模块可以相互加载,并可以使用特殊的指令 export 和 import 来交换功能,从另一个模块调用一个模块的函数:

  • export 关键字标记了可以从当前模块外部访问的变量和函数。
  • import 关键字允许从其他模块导入功能。
命名的导出默认的导出
export class User {...}export default class User {...}
import {User} from ...import User from ...

export default#

每个文件应该只有一个 export default:

否则报错: Uncaught SyntaxError: Identifier '.default' has already been declared

func.js

// 默认导出, 一个文件中只能存在一个, 此处不设定名称, 但是导入时可以自定义名称
export default function(){
console.log('我是func.js中的函数')
}
let obj = {
name: 'zs',
}
function fun(){
console.log('我是func.js中的函数 fun')
}
// 导出暴露给其他文件使用
export {obj, fun}
// 声明的时候同时导出
export function fun1(){
console.log('我是func.js中的函数 fun1')
}
export function fun2(){
console.log('我是func.js中的函数 fun2')
}

class.js

// 从 ./func.js 中导入 obj ,再将其导出
export { obj } from "./func.js";
// 重新导出默认导出, 必须为之重命名
export {default as default_fun} from "./func.js";
// 此模块中不能使用obj

main.js

// 引入默认导出的模块并命名为func
import func from "./func.js";
// 引入非默认导出的模块中的obj和fun, 名称必须与导出时的名称一致
// 使用as将导入的obj名称重命名为obj1
import { obj as obj1, fun, fun1, fun2 } from "./func.js";
func();
console.log(obj1);
fun();
fun1();
fun2();
import { obj as obj2, default_fun } from "./class.js";
default_fun();
console.log(obj2);

import#

fun.js

console.log('我是fun.js中的代码')

main.js

// 导入并且执行fun.js中的代码, 类似于将fun.js中的全部代码代码复制到这里
import './fun.js'

import *#

fun.js

function fun1(){
console.log('我是fun.js中的 fun1函数')
}
function fun2(){
console.log('我是fun.js中的 fun2函数')
}
export {fun1,fun2}

main.js

// 导入整个模块中导出的内容, 不推荐
import * as obj from './fun.js'
console.log(obj); // module对象
obj.fun1();
obj.fun2();

动态导入-import()#

fun.js

function fun1() {
console.log('fun1()');
}
function fun2() {
console.log('fun2()');
}
export { fun1, fun2 };

main.js

let fun1, fun2;
async function main() {
if (true) {
({ fun1 } = await import("./fun.js"));
return fun1;
} else {
({ fun2 } = await import("./fun.js"));
return fun2;
}
}
main().then((fun) => fun());

Proxy/Reflect#

Proxy 和 Reflect https://zh.javascript.info/proxy

JS-高级
https://blog.tiamix.cn/posts/js-高级/
作者
Tiam
发布于
2023-02-21
许可协议
CC BY-NC-SA 4.0