目录
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); // stringconsole.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); // 我是toJSONparse
要解码 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); // stringconsole.log(json); // {"name":"阿坤","age":27,"hobby":["唱","跳","rap","篮球"]}
let obj1 = JSON.parse(json);console.log(typeof obj1); // objectconsole.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
// 原型链的尽头是nullconsole.log(people.__proto__); // [Object: null prototype] {}这里只有两个限制:
- 引用不能形成闭环。如果我们试图给
__proto__赋值但会导致引用形成闭环时,JavaScript 会抛出错误。 __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); //truealert(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!原型方法
现代的获取/设置原型的方法有:
- Object.getPrototypeOf(obj) —— 返回对象
obj的[[Prototype]]。 - Object.setPrototypeOf(obj, proto) —— 将对象
obj的[[Prototype]]设置为proto。
__proto__ 不被反对的唯一的用法是在创建新对象时,将其用作属性:{ __proto__: ... }。
虽然,也有一种特殊的方法:
- Object.create(proto, [descriptors]) —— 利用给定的
proto作为[[Prototype]]和可选的属性描述来创建一个空对象。
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)); }};.on(eventName, handler)— 指定函数handler以在具有对应名称的事件发生时运行。从技术上讲,这儿有一个用于存储每个事件名称对应的处理程序(handler)的_eventHandlers属性,在这儿该属性就会将刚刚指定的这个handler添加到列表中。.off(eventName, handler)— 从处理程序列表中删除指定的函数。.trigger(eventName, ...args)— 生成事件:所有_eventHandlers[eventName]中的事件处理程序(handler)都被调用,并且...args会被作为参数传递给它们。
// 创建一个 classclass Menu { choose(value) { this.trigger("select", value); }}// 添加带有事件相关方法的 mixinObject.assign(Menu.prototype, eventMixin);
let menu = new Menu();
// 添加一个事件处理程序(handler),在被选择时被调用:menu.on("select", value => alert(`Value selected: ${value}`));
// 触发事件 => 运行上述的事件处理程序(handler)并显示:// 被选中的值:123menu.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,5Yield
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- 第一次调用
generator.next()应该是不带参数的(如果带参数,那么该参数会被忽略)。它开始执行并返回第一个yield "2 + 2 = ?"的结果。此时,generator 执行暂停,而停留在(*)行上。 - 然后,正如上面图片中显示的那样,
yield的结果进入调用代码中的question变量。 - 在
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";
// 此模块中不能使用objmain.js
// 引入默认导出的模块并命名为funcimport func from "./func.js";// 引入非默认导出的模块中的obj和fun, 名称必须与导出时的名称一致// 使用as将导入的obj名称重命名为obj1import { 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());