6854 字
34 分钟
javascript复习

目录#

【2023-8-4 10:18:06 星期五】

7种基本类型:

string, symbol 可用作对象键的类型

number, bigint 数字类型

null, undefind 自成类型, 只有单独一个值

boolean 布尔类型

Symbol#

// Symbol类型的特点
// 1. 所有 symbol 都具有 description 属性。
// 2. 每个symbol都是独一无二的
console.log(Symbol('id') == Symbol('id')); // false
// 3. 全局Symbol, 拥有相同描述的symbol视为是相同的
console.log(Symbol.for('id') == Symbol.for('id')); // true
// 4. 通常用作对象的键, 以防止键名冲突
/*
根据规范,只有两种原始类型可以用作对象属性键:
- 字符串类型
- symbol 类型
*/
const id = Symbol('id');
const user = {
[id]: 1,
name: '张三',
age: 18,
// 无法被访问到, 因为每个Symbol('id')都是不同的
[Symbol('id')]: 2,
// 可以被访问到, 因为Symbol.for('id')是全局的, 每个Symbol.for('id')都是相同的
[Symbol.for('id')]: 3,
};
// for in 以及Object.keys 无法遍历symbol键
for (const key in user) {
console.log(key);
}
console.log(Object.keys(user));
// 只获取所有symbol键
console.log(Object.getOwnPropertySymbols(user));
// 获取全部键, 包括symbol键
console.log(Reflect.ownKeys(user));
// 访问symbol值
console.log(user[id]); // 1
console.log(user[Symbol('id')]); // undefined
console.log(user[Symbol.for('id')]); // 3
let name = Symbol("name");
console.log(name.description); // name
let age = Symbol.for("age");
// 全局 symbol 可通过 keyFor 获取 key, 即description属性
console.log(Symbol.keyFor(age)); // age
console.log(age.description); // age

对象的基本类型转换#

/*
为了进行转换,JavaScript 尝试查找并调用三个对象方法:
调用 obj[Symbol.toPrimitive](hint) —— 带有 symbol 键 Symbol.toPrimitive(系统 symbol)的方法,如果这个方法存在的话,
否则,如果 hint 是 "string" —— 先尝试调用 obj.toString() 或 obj.valueOf(),无论哪个存在。
否则,如果 hint 是 "number" 或 "default" —— 先尝试调用 obj.valueOf() 或 obj.toString(),无论哪个存在。
所以, 自定义对象的转换规则有两个方法:
1. 复写默认的toString和valueOf方法;
2. 实现[Symbol.toPrimitive](hint)方法;
通常情况下, 只复写toString方法转为"可读"字符串即可
*/
// 对象具有默认的toString和valueOf方法,
let user = {name: "Tiam"};
console.log(user.toString()); // [object Object]
// valueOf方法返回对象本身
console.log(user.valueOf() === user); // true
// 但是不具有默认的[Symbol.toPrimitive](hint)方法, 需自己实现
// console.log(user[Symbol.toPrimitive]("string")); // user[Symbol.toPrimitive] is not a function
// 模拟Date对象
class _Date {
// 时间戳
timestamp = 0;
constructor() {
this.timestamp = Date.now(); // 从原来的Date那里偷一个时间戳
}
// 返回一个表示当前时间的字符串(只能返回一个基本类型的值, 通常是一个字符串或者数字)
[Symbol.toPrimitive](hint) {
// 当对象被转换为原始类型的值时会调用, hint参数的值有三种:
// - number: 该对象需要转换为一个数字
// - string: 该对象需要转换为一个字符串
// - default: 该对象可以转换为一个数字或者字符串
console.log(hint);
return hint == "string" ? this.toString() : this.valueOf();
}
valueOf() {
return this.timestamp;
}
toString() {
return _Date.timestampToTime(this.timestamp);
}
// 时间戳转换为时间
static timestampToTime(timestamp) {
timestamp = timestamp ? timestamp : null;
let date = new Date(timestamp); //时间戳为10位需*1000,时间戳为13位的话不需乘1000
let Y = date.getFullYear() + "-";
let M = (date.getMonth() + 1 < 10 ? "0" + (date.getMonth() + 1) : date.getMonth() + 1) + "-";
let D = (date.getDate() < 10 ? "0" + date.getDate() : date.getDate()) + " ";
let h = (date.getHours() < 10 ? "0" + date.getHours() : date.getHours()) + ":";
let m = (date.getMinutes() < 10 ? "0" + date.getMinutes() : date.getMinutes()) + ":";
let s = date.getSeconds() < 10 ? "0" + date.getSeconds() : date.getSeconds();
return Y + M + D + h + m + s;
}
}
const date = new _Date();
console.log(date); // _Date { timestamp: 1691116927614 }
console.log(+date); // number => 1621466959278
console.log(String(date)); // string => 2023-08-04 10:44:33
console.log(date + 1000); // default => 1691117074560
console.log(date[Symbol.toPrimitive]("string"));
let a = { value: 0 };
a[Symbol.toPrimitive] = function (hint) {
console.log(hint); // default
return ++this.value;
};
console.log(a == 1 && a == 2 && a == 3); // true
let b = { value: 0 };
b.valueOf = function () {
return ++this.value;
};
console.log(b == 1 && b == 2 && b == 3); // true
let c = { value: 0 };
c.toString = function () {
return ++this.value;
};
console.log(c == 1 && c == 2 && c == 3); // true

基本类型数据的方法#

通过临时对象为原始类型提供方法, 使用后即销毁

“对象包装器”对于每种原始类型都是不同的,它们被称为 String、Number、Boolean、Symbol 和 BigInt。因此,它们提供了不同的方法。

数字#

特殊的值 “NaN” 是独一无二的,它不等于任何东西,包括它自身:

alert( NaN === NaN ); // false
// 但是
Object.is(NaN, NaN) === true
Object.is(0, -0) === false
// 只能通过isNaN() 函数判断

在内部,数字是以 64 位格式 IEEE-754 表示的,所以正好有 64 位可以存储一个数字:其中 52 位被用于存储这些数字,其中 11 位用于存储小数点的位置,而 1 位用于符号。

如果一个数字真的很大,则可能会溢出 64 位存储,变成一个特殊的数值 Infinity:

判断是否为常规数字: isFinite()

alert( isFinite("15") ); // true
alert( isFinite("str") ); // false,因为是一个特殊的值:NaN
alert( isFinite(Infinity) ); // false,因为是一个特殊的值:Infinity

浮点数的相关操作一定一定考虑精度问题!!!

alert( 0.1 + 0.2 == 0.3 ); // false
// 死循环
let i = 0;
while (i != 10) {
i += 0.2;
}

数字类型 https://zh.javascript.info/number#parseint-he-parsefloat

它们可以从字符串中“读取”数字,直到无法读取为止。如果发生 error,则返回收集到的数字。函数 parseInt 返回一个整数,而 parseFloat 返回一个浮点数:

// 通常用作转换带单位的字符串
alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5

字符串#

字符串的内部格式始终是 UTF-16,它不依赖于页面编码。

在 JavaScript 中,字符串不可更改。改变字符是不可能的。

32-bit 整数,~n 等于 -(n+1)。 所以 ~-1 === 0

只要记住:if (~str.indexOf(...)) 读作 “if found”。

更现代的方法 str.includes(substr, pos) 根据 str 中是否包含 substr 来返回 true/false。

JavaScript 中有三种获取字符串的方法:substring、substr 和 slice。(推荐slice)

方法选择方式……负值参数
slice(start, end)从 start 到 end(不含 end)允许
substring(start, end)从 start 到 end(不含 end)负值被视为 0
substr(start, length)从 start 开始获取长为 length 的字符串允许 start 为负数

调用 str.localeCompare(str2) 会根据语言规则返回一个整数,这个整数能指示字符串 str 在排序顺序中排在字符串 str2 前面、后面、还是相同:

  • 如果 str 排在 str2 前面,则返回负数。
  • 如果 str 排在 str2 后面,则返回正数。
  • 如果它们在相同位置,则返回 0。

总结推荐使用函数

作用函数
判断是否包含includes
截取子串slice
比较localeCompare

more: String - JavaScript | MDN (mozilla.org)

// 字符串转数组
console.log(Array.from("Hello"));
console.log("Hello".split(''));
console.log([..."Hello"]);

数组#

获取数组最后一个元素

// 旧
arr[arr.length-1]
// 新
arr.at(-1)

换句话说,arr.at(i):

  • 如果 i >= 0,则与 arr[i] 完全相同。
  • 对于 i 为负数的情况,它则从数组的尾部向前数。

添加/删除元素: pop/push, shift/unshift 方法

清空数组:arr.length = 0;


遍历数组

  • fori
  • for of
  • for in (不推荐)

比较数组, 不能使用==运算符

[] == [] // false
[].toString() == [].toString() // true

more:数组方法 (javascript.info)

可迭代对象 | 类数组对象#

  • Iterable 如上所述,是实现了 Symbol.iterator 方法的对象。
  • Array-like 是有索引和 length 属性的对象,所以它们看起来很像数组。
class Range {
from;
to;
constructor(to, from = 0) {
if (to === undefined) {
throw new Error("Range: to is required");
}
this.from = from;
this.to = to;
}
[Symbol.iterator]() {
return {
current: this.from,
last: this.to,
next() {
if (this.current < this.last) {
return { done: false, value: this.current++ };
} else {
return { done: true };
}
},
};
}
}
let range = new Range(5);
for (const num of range) {
console.log(num); // 0 1 2 3 4
}
const arrayLike = {
0: "Hello",
1: "World",
length: 2,
}
// 由 可迭代对象/类数组对象 创建一个新数组
const arr = Array.from(arrayLike);
arr.push("!");
console.log(Array.isArray(Array.from(range))); // true

对象映射转换

通过entries转为数组, 使用数组的map方法操作, 再fromEntries转回数组

let doublePrices = Object.fromEntries(
// 将价格转换为数组,将每个键/值对映射为另一对
// 然后通过 fromEntries 再将结果转换为对象
Object.entries(prices).map(entry => [entry[0], entry[1] * 2])
);

Map | Set#

  • Map 允许任何类型的键(key)。
  • Map 使用 SameValueZero 算法来比较键是否相等。它和严格等于 === 差不多,但区别是 NaN 被看成是等于 NaN。所以 NaN 也可以被用作键。

这个算法不能被改变或者自定义。

  • 迭代的顺序与插入值的顺序相同, 是有序的。(但是不能根据序号/索引 访问值, 因为他们并没有)

对象转为map (转为二维数组, 在new Map 时初始化)

const user = {
name: '张三',
age: 18,
};
const arr = Object.entries(user);
console.log(arr); // [ [ 'name', '张三' ], [ 'age', 18 ] ]
const map = new Map(arr);
console.log(map); // Map(2) { 'name' => '张三', 'age' => 18 }
// Object.fromEntries() 方法把键值对列表转换为一个普通对象
let obj = Object.fromEntries(map);
console.log(obj);
obj = Object.fromEntries(arr);
console.log(obj);

set 可通过一个数组进行初始化

let set = new Set(["oranges", "apples", "bananas"]);

WeakMap | WeakSet#

  • WeakMap 和 Map 的第一个不同点就是,WeakMap 的键必须是对象,不能是原始值;
  • WeakMap 在这方面有着根本上的不同。它不会阻止垃圾回收机制对作为键的对象(key object)的回收。
let john = { name: "John" };
let weakMap = new WeakMap();
weakMap.set(john, "...");
john = null; // 覆盖引用
// john 被从内存中删除了!
// 若使用普通的Map, john并不会被删除, 因为我们可以使用 map.keys() 来获取它
  • WeakMap 不支持迭代以及 keys(),values() 和 entries() 方法。所以没有办法获取 WeakMap 的所有键或值。

WeakMap 的主要应用场景是 额外数据的存储以及缓存

假如我们正在处理一个“属于”另一个代码的一个对象,也可能是第三方库,并想存储一些与之相关的数据,那么这些数据就应该与这个对象共存亡 —— 这时候 WeakMap 正是我们所需要的利器。

我们将这些数据放到 WeakMap 中,并使用该对象作为这些数据的键,那么当该对象被垃圾回收机制回收后,这些数据也会被自动清除。

当对象被回收时, 对象作为键 对应的值存在也无意义, 随即也自动被回收


  • 与 Set 类似,但是我们只能向 WeakSet 添加对象(而不能是原始值)。
  • 对象只有在其它某个(些)地方能被访问的时候,才能留在 WeakSet 中。
  • 跟 Set 一样,WeakSet 支持 add,has 和 delete 方法,但不支持 size 和 keys(),并且不可迭代。
let visitedSet = new WeakSet();
let john = { name: "John" };
let pete = { name: "Pete" };
visitedSet.add(john); // John 访问了我们
visitedSet.add(pete); // 然后是 Pete
john = null;
// john 在weakset中没了, 被回收了
console.log(visitedSet.has(john)); // false

解构赋值#

let guest = "Jane";
let admin = "Pete";
// 让我们来交换变量的值:使得 guest = Pete,admin = Jane
[guest, admin] = [admin, guest];
  • 可以通过添加额外的逗号来丢弃数组中不想要的元素:
  • 右侧可以是任何可迭代对象
  • for* (let [key, value**]** of user**)*

解构对象

let options = {
title: "Menu",
width: 100,
height: 200
};
// { sourceProperty: targetVariable }
let {width: w, height: h, title} = options;
// 重命名对象属性
// width -> w
// height -> h
// title -> title
alert(title); // Menu
alert(w); // 100
alert(h); // 200

date对象#

const date = new Date();
console.log(date); // 2023-08-04T09:22:54.807Z
console.log(date.toString()); // Fri Aug 04 2023 17:22:54 GMT+0800 (中国标准时间)
console.log(+date); // 1691140974807
console.log(date.toDateString()); // Fri Aug 04 2023
console.log(date.toLocaleDateString()); // 2023/8/4
console.log(date.toLocaleTimeString()); // 17:22:54
// 可读日期时间格式
console.log(date.toLocaleString()); // 2023/8/4 17:28:16

JSON对象#

let user = {
name: "John",
age: 25,
roles: {
isAdmin: false,
isEditor: true,
},
};
console.log(JSON.stringify(user, null, 2)); // 2表示缩进2个空格, 默认压缩在一行
// 自定义stringify调用结果
user.toJSON = function () {
return `name: ${this.name}, age: ${this.age}, roles: ${this.roles.isAdmin ? "admin" : "editor"}`;
};
console.log(JSON.stringify(user)); // "name: John, age: 25, roles: editor"

spread语法与rest参数#

【2023-8-10 10:42:25 星期四】

'use strict';
function sum(...args){
// 在函数内部, 变量并不会与函数命名冲突
const sum = args.reduce((prev, curr) => prev + curr, 0);
console.log(sum);
return sum;
}
sum(1,2,3,4,5); // 15

词法环境与闭包#

/**
* 词法作用域
* @returns
*/
/*
在 JavaScript 中,每个运行的函数,代码块 {...} 以及整个脚本,都有一个被称为 词法环境(Lexical Environment) 的内部(隐藏)的关联对象。
词法环境对象由两部分组成:
1. 环境记录(Environment Record) —— 一个存储所有局部变量作为其属性(包括一些其他信息,例如 this 的值)的对象。
2. 对 外部词法环境 的引用,与外部代码相关联。
*/
function makeCounter() {
let count = 0;
return function () {
return count++;
};
}
const counter = makeCounter();
console.log(counter());
console.log(counter());
console.log(counter());
const counter1 = makeCounter();
console.log(counter1());
function Counter() {
let count = 0;
this.up = function () {
return ++count;
};
this.down = () => {
return --count;
};
}
const counter2 = new Counter();
console.log(counter2.up());
console.log(counter2.down());

封装函数参数

// 封装函数参数
/* .. inBetween 和 inArray 的代码 */
function inBetween(a, b) {
return function (item) {
return item >= 3 && item <= 6;
};
}
function inArray(arr) {
return item => arr.includes(item);
}
let arr = [1, 2, 3, 4, 5, 6, 7];
console.log(arr.filter(inBetween(3, 6))); // 3,4,5,6
console.log(arr.filter(inArray([1, 2, 10]))); // 1,2
let users = [
{ name: "John", age: 20, surname: "Johnson" },
{ name: "Pete", age: 18, surname: "Peterson" },
{ name: "Ann", age: 19, surname: "Hathaway" },
];
function byField(field) {
return (a, b) => (a[field] > b[field] ? 1 : -1);
}
console.log(users.sort(byField("name")));
const log = console.log;
function makeArmy() {
let shooters = [];
/* let i = 0;
while (i < 10) {
// let j = i; // *****不临时存, 每次输出都会变成10
let shooter = function () {
// 创建一个 shooter 函数,
log(j); // 应该显示其编号
};
shooters.push(shooter); // 将此 shooter 函数添加到数组中
i++;
} */
/* 或者使用for循环 */
for(let i = 0; i < 10; ++i){
let shooter = () => log(i);
shooters.push(shooter);
}
// ……返回 shooters 数组
return shooters;l
}
let army = makeArmy();
// ……所有的 shooter 显示的都是 10,而不是它们的编号 0, 1, 2, 3...
army[0](); // 编号为 0 的 shooter 显示的是 10
army[1](); // 编号为 1 的 shooter 显示的是 10
army[2](); // 10,其他的也是这样。

全局对象#

const log = console.log;
log(globalThis);
// function声明的函数会在全局对象身上
function test(){
log("全局对象?");
// var 有函数作用域, 函数内声明的外部无法访问
var display = "27寸显示屏";
}
globalThis.test();
log(globalThis.display); // undefind
{
// var没有块级作用域, 声明的变量也会在全局对象身上
var quite = 12345;
}
log(globalThis.quite); // 12345

函数进阶#

函数的属性

function fun1(a, b) {}
const fun2 = function (a, b, c, ...d) {};
// 获取函数名
console.log(fun1.name);
console.log(fun2.name);
// 获取函数入参个数, rest 参数不参与计数。
console.log(fun1.length);
console.log(fun2.length);
// 统计函数的被调用次数
hello.count = 0;
function hello() {
++hello.count;
console.log(hello); // 跟this不是同一个东西
return hello;
}
hello();
hello();
console.log(hello.count);

函数对象,NFE https://zh.javascript.info/function-object#wei-counter-tian-jia-set-he-decrease-fang-fa

使用函数的属性实现, 拥有count属性, 可直接赋值和获取

function makeCounter() {
counter.count = 0;
function counter() {
return ++counter.count;
}
counter.decrease = () => --counter.count;
counter.set = value => (counter.count = value);
return counter;
}
const counter = makeCounter();
console.log(counter());
console.log(counter());
console.log(counter.decrease());
console.log(counter.set(10));
counter.count = 99; // 赋值
console.log(counter.count); // 读取值

使用闭包实现, 对count访问限制更为严格, 不可直接访问和复制, 需添加set get方法

function makeCounter() {
let count = 0;
counter.decrease = () => --count;
counter.set = value => (count = value);
counter.get = () => count;
function counter() {
return ++count;
};
return counter;
}
const counter = makeCounter();
console.log(counter());
console.log(counter());
console.log(counter.decrease());
console.log(counter.set(10));
console.log(counter.get());

函数对象,NFE https://zh.javascript.info/function-object#ren-yi-shu-liang-de-kuo-hao-qiu-he

function sum(x){
// 这里只执行第一次
let res = x;
function cal(y){
res += y;
return cal;
}
cal.valueOf = () => res; // 转为数字输出
return cal;
}
// alert 会自动试图将参数转为字符串类型, 而console.log并不会
console.log(sum(1) == 1);
console.log(sum(1)(2) == 3);
console.log(sum(1)(2)(3) == 6);

动态创建函数

使用 new Function 创建一个函数,那么该函数的 [[Environment]] 并不指向当前的词法环境,而是指向全局环境。

const functionParam = 'x'
const functionBody = `
// 这里只执行第一次
let res = x;
function cal(y){
res += y;
return cal;
}
cal.valueOf = () => res;
return cal;`
{
const sum = new Function(functionParam, functionBody);
console.log(sum(1) == 1); // true
console.log(sum(1)(2) == 3); // true
console.log(sum(1)(2)(3) == 6); // true
}

调度#

/*
setTimeout 允许我们将函数推迟到一段时间间隔之后再执行。
setInterval 允许我们重复运行一个函数,从一段时间间隔之后开始运行,之后以该时间间隔连续重复运行该函数。
*/
// 延时调度
setTimeout(console.log, 1000, "你滴大眼睛!");
setTimeout(() => console.log("我每天都想起"), 1000);
// 定时调度
// 1. 通过setIntervel, 间隔时间包括了函数的执行时间, 如果函数执行时间大于等于1000ms, 那么执行完成后则会立刻调用下一次执行
let first = Date.now();
setInterval(() => {
let secend = Date.now();
console.log(secend - first);
first = secend;
}, 1000);
// 2. 等待函数执行完成后, 等待1000ms, 再次调用下一次
setTimeout(function run(){
console.log("比方说当我遇见你")
setTimeout(run, 1000);
}, 1000)
// 自定义每次的间隔时间
let count = 1;
let prev = Date.now();
setTimeout(function run() {
console.log(Date.now() - prev);
prev = Date.now();
setTimeout(run, ++count * 1000);
}, 1000);
/*
1010
2015
3007
4005
5000
6010
7012
*/

使用“setTimeout与setIntervel`做定时器的区别:

测试间隔时间的区别

function sleep(time) {
return new Promise(resolve => setTimeout(resolve, time));
}
/*
let first = Date.now();
setInterval(async () => {
// 第一次直接等待1000ms开始执行函数
console.log("间隔时间:",Date.now() - first);
// 模拟函数所需的执行时间
await sleep(10)
first = Date.now();
}, 1000);
*/
let first = Date.now();
setTimeout(async function run(){
console.log("间隔时间:",Date.now() - first);
// 模拟函数所需的执行时间
await sleep(10)
setTimeout(run, 1000);
first = Date.now();
}, 1000)

调度:setTimeout 和 setInterval https://zh.javascript.info/settimeout-setinterval#mei-miao-shu-chu-yi-ci

/*
function printNumbers(from, to){
const timer = setInterval(()=>{
console.log(from++);
if(from == to) clearInterval(timer);
},1000)
}
printNumbers(10,15);
*/
function printNumbers1(from, to){
setTimeout(function run(){
console.log(from++);
const timer = setTimeout(run, 1000);
if(from == to) clearTimeout(timer);
}, 1000)
}
printNumbers1(10,15);

装饰器#

call 和 apply 之间唯一的语法区别是,call 期望一个参数列表,而 apply 期望一个包含这些参数的类数组对象。

apply 可能会更快,因为大多数 JavaScript 引擎在内部对其进行了优化。

只有一个关于 args 的细微的差别:

  • Spread 语法 ... 允许将 可迭代对象 args 作为列表传递给 call。
  • apply 只接受 类数组 args。

即, 对于可迭代对象args,

func.call(context, ...args); // 这是OK的
func.apply(context, args); // 但是这个不行哦, 它只能接受类数组

通常,用装饰的函数替换一个函数或一个方法是安全的,除了一件小东西。如果原始函数有属性,例如 func.calledCount 或其他,则装饰后的函数将不再提供这些属性。因为这是装饰器。因此,如果有人使用它们,那么就需要小心。

const user = {
name: "邓紫棋",
getName() {
return this.name;
},
setName(name) {
this.name = name;
return this;
},
};
const getUserName = user.getName;
console.log(getUserName()); // undefind (丢失上下文this)
console.log(getUserName.call(user)); // 邓紫棋 (调用时绑定this)
console.log(getUserName.apply(user)); // 邓紫棋 (调用时绑定this)
const setUserName = user.setName.bind(user); // 赋值时绑定
setUserName("鞠婧祎"); // It's OK
console.log(getUserName.call(user)); // 鞠婧祎
function joinNum(...nums){
console.log(nums.join());
// console.log(arguments.join()); // 这是不行的, 因为arguments不是一个数组
console.log([].join.call(arguments)); // 但是这是OK的 (方法借用) *太骚了
// 当然也可以通过转换为真正的数组去使用join()方法
console.log(Array.from(arguments).join());
console.log([...arguments].join());
}
joinNum(1,2,3,4,5)

间谍装饰器#

function work(a, b) {
console.log(a + b); // work 是一个任意的函数或方法
}
function spy(func) {
wrapper.calls = [];
function wrapper(...args) {
wrapper.calls.push(args);
return func.apply(this, args);
}
return wrapper;
}
work = spy(work);
work(1, 2); // 3
work(4, 5); // 9
for (let args of work.calls) {
console.log("call:" + args.join()); // "call:1,2", "call:4,5"
}

延时装饰器#

function f(x) {
console.log(x);
}
function delay(func, time) {
return function (...args) {
// setTimeout(func, time, ...args);
setTimeout(() => func.apply(this, args), time);
};
}
// create wrappers
let f1000 = delay(f, 1000);
let f1500 = delay(f, 1500);
f1000("test"); // 在 1000ms 后显示 "test"
f1500("test"); // 在 1500ms 后显示 "test"

防抖装饰器#

function debounce(func, time) {
let timer = null;
return function (...args) {
// 取消上一次的执行
timer && clearTimeout(timer);
// 重新延时执行这一次, 若1000ms内被再次调用, 就会取消执行; 没有被再次调用, 则执行函数
timer = setTimeout(() => func.apply(this, args), time);
};
}
let f = debounce(console.log, 1000);
f("a");
setTimeout(() => f("b"), 200);
setTimeout(() => f("c"), 500);

节流装饰器*有问题#

function f(a) {
console.log(a);
}
function throttle(func, time) {
let timer = null;
return function (...args) {
if (!timer) {
timer = setTimeout(() => {
func.apply(this, args);
timer = null;
}, time);
}
};
}
function throttle1(func, time) {
let flag = false,
saveThis,
saveArgs;
return function wrapper(...args) {
if (flag) {
saveThis = this;
saveArgs = args;
return;
}
func.apply(this, args);
flag = true;
setTimeout(() => {
if (saveArgs) {
wrapper.apply(saveThis, saveArgs);
saveArgs = null;
}
flag = false;
}, time);
};
}
function throttle2(func, time) {
let isThrottled = false,
savedArgs,
savedThis;
function wrapper() {
if (isThrottled) {
savedArgs = arguments;
savedThis = this;
return;
}
isThrottled = true;
func.apply(this, arguments); // (1)
setTimeout(function () {
isThrottled = false; // (3)
if (savedArgs) {
wrapper.apply(savedThis, savedArgs);
savedArgs = savedThis = null;
}
}, time);
}
return wrapper;
}
const _ = require("lodash");
// f1000 最多每 1000ms 将调用传递给 f 一次
let f1000 = _.throttle(f, 1000);
f1000(1); // 显示 1
f1000(2); // (节流,尚未到 1000ms)
f1000(3); // (节流,尚未到 1000ms)
setTimeout(f1000, 100, 4);
setTimeout(f1000, 800, 5);
setTimeout(f1000, 1000, 6);
setTimeout(f1000, 2400, 7);
setTimeout(f1000, 2700, 8);
// 当 1000ms 时间到...
// ...输出 3,中间值 2 被忽略

绑定this | this#

思考输出结果?

"use strict";
function f() {
alert( this ); // ?
}
let user = {
g: f.bind(null)
};
user.g();
"use strict";
function f() {
console.log(this);
}
let user = {
name: "jack",
g: f.bind(this),
j: f,
k() {
console.log(this);
},
};
user.j();
user.g();
user.k();

// 对象中, 但是在对象方法外部的this并不指向当前对象


function sayHi() {
alert( this.name );
}
sayHi.test = 5;
let bound = sayHi.bind({
name: "John"
});
alert( bound.test ); // 输出将会是什么?为什么?
function sayHi() {
console.log(this.name);
}
sayHi.test = 5;
let bound = sayHi.bind({
name: "John",
test: 18,
});
console.log(bound.test); // 输出将会是什么?为什么?
bound();
console.log(sayHi.test);

绑定参数#

function pow(a, b){
return a ** b;
}
const twoPow = pow.bind(null, 2);
console.log(twoPow(1));
console.log(twoPow(2));
console.log(twoPow(3));
const threePow = pow.bind(null,3);
console.log(threePow(1));
console.log(threePow(2));
console.log(threePow(3));

对象属性配置#

"use strict";
let user = {
name: "Rose",
};
// 修改原有属性为只读
Object.defineProperty(user, "name", {
writable: false,
});
// user.name = "Kate"; // TypeError: Cannot assign to read only property 'name' of object '#<Object>'
// 添加一个只读属性
Object.defineProperty(user, "age", {
value: 18,
writable: false,
// 对于新属性,我们需要明确地列出哪些是 true
enumerable: true,
configurable: true,
});
// user.age = 30;
console.log(user);
user.toString = function(){
return this.name;
}
console.log(String(user));
for(const key in user){
console.log(key); // toString 被遍历出来了
}
// 将toString修改为不可遍历
Object.defineProperty(user, "toString", {
enumerable: false,
})
for(const key in user){
console.log(key); // toString 不会被遍历出来了
}
/* attention !
使属性变成不可配置是一条单行道。我们无法通过 defineProperty 再把它改回来。
请注意:configurable: false 防止更改和删除属性标志,但是允许更改对象的值。
例外: 对于不可配置的属性,我们可以将 writable: true 更改为 false,从而防止其值被修改(以添加另一层保护)。但无法反向行之。
*/
console.log(Object.getOwnPropertyDescriptors(user));
/*
{
name: {
value: 'Rose',
writable: false,
enumerable: true,
configurable: true
},
age: { value: 18, writable: false, enumerable: true, configurable: true },
toString: {
value: [Function (anonymous)],
writable: true,
enumerable: false,
configurable: true
}
}
*/

getter,setter#

let user = {
_birthday: new Date(2000, 6, 24),
get age() {
return new Date().getFullYear() - this._birthday.getFullYear();
},
set age(value){
throw new Error("无法修改年龄! 请通过修改生日修改年龄")
},
get birthday(){
return this._birthday;
},
set birthday(value){
if(Object.prototype.toString.call(value) !== "[object Date]"){
throw new Error("参数类型错误!请传入Date类型的值")
}
this._birthday = value;
}
};
console.log(user.age);
// user.birthday = "1988-12-31";
user.birthday = new Date(1988,11,31);
console.log(user.birthday.toLocaleString());
console.log(user.age);

原型继承#

let animal = {
name: "animal",
food: "food",
eat(){
console.log("吃吃吃", this.food);
}
}
let cat = {
feature: "cute",
food: "猫粮",
__proto__: animal,
}
// 对于在cat中无法读取到的属性, 会沿着原型链向上寻找
console.log(cat.name);
// 赋值并不会向上寻找, 没有直接创建一个新属性
cat.name = "哈基米";
console.log(animal.name);
console.log(cat);
// 谁调用的, this就指向谁, 与方法所在哪个对象无关
cat.eat();
// Object.keys等方法不会遍历继承的属性
console.log(Object.keys(cat));
// for in 会遍历继承的属性
for(const key in cat){
console.log(Object.hasOwnProperty(key)?'继承的':'原生的', key);
}

Prototype#

// 默认的 "prototype" 是一个只有属性 constructor 的对象,属性 constructor 指向函数自身。
function Dog(){
}
console.log(Dog.prototype.constructor === Dog); //true

<svg xmlns=“http://www.w3.org/2000/svg” width=“692” height=“411” viewBox=“0 0 692 411”><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans,italic,bolditalic%7CPT+Mono);@font-face{font-family:‘PT Mono’;font-weight:700;font-style;src(‘PT MonoBold’),url(/font/PTMonoBold.woff2) format(‘woff2’),url(/font/PTMonoBold.woff) format(‘woff’),url(/font/PTMonoBold.ttf) format(‘truetype’)}</style></defs><g id=“inheritance” fill=“none” fill-rule=“evenodd” stroke=“none” stroke-width=“1”><g id=“native-prototypes-classes.svg”><path id=“Rectangle-1” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M240 93h198v58H240z”/><text id=“toString:-function” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“250” y=“116”>toString: function</tspan> <tspan x=“250” y=“131”>other object methods</tspan></text><text id=“Object.prototype” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“239” y=“85”>Object.prototype</tspan></text><path id=“Line-2” fill=“#7a7f9c” fill-rule=“nonzero” d=“M299.5 27.5l7 14h-6v28h-2v-28h-6l7-14z”/><path id=“Line-3” fill=“#7a7f9c” fill-rule=“nonzero” d=“M299.5 160.5l7 14h-6v28h-2v-28h-6l7-14z”/><text id=“null” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“285” y=“16”>null</tspan></text><path id=“Rectangle-1” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M14 224h198v58H14z”/><text id=“slice:-function” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“24” y=“247”>slice: function</tspan> <tspan x=“24” y=“262”>other array methods</tspan></text><text id=“[[Prototype]]” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“66” y=“174”>[[Prototype]]</tspan></text><text id=“[[Prototype]]-Copy-6” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“518” y=“175”>[[Prototype]]</tspan></text><text id=“[[Prototype]]-Copy” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“310” y=“187”>[[Prototype]]</tspan></text><text id=“[[Prototype]]-Copy-2” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“310” y=“54”>[[Prototype]]</tspan></text><text id=“[[Prototype]]” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“310” y=“317”>[[Prototype]]</tspan></text><text id=“[[Prototype]]-Copy-4” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“582” y=“317”>[[Prototype]]</tspan></text><text id=“[[Prototype]]-Copy-5” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“117” y=“317”>[[Prototype]]</tspan></text><text id=“Array.prototype” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“13” y=“216”>Array.prototype</tspan></text><path id=“Rectangle-1” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M243 224h198v58H243z”/><text id=“call:-function-other” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“253” y=“247”>call: function</tspan> <tspan x=“253” y=“262”>other function methods</tspan></text><text id=“Function.prototype” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“242” y=“216”>Function.prototype</tspan></text><path id=“Rectangle-1” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M474 224h198v58H474z”/><text id=“toFixed:-function” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“484” y=“247”>toFixed: function</tspan> <tspan x=“484” y=“262”>other number methods</tspan></text><text id=“Number.prototype” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“473” y=“216”>Number.prototype</tspan></text><path id=“Line” fill=“#7a7f9c” fill-rule=“nonzero” d=“M204.855 157.011l15.645.489-9.778 12.223-2.515-5.448-65.288 30.133-.908.419-.838-1.816.908-.419 65.288-30.133-2.514-5.448zM478.147 157.088l-2.542 5.435 64.319 30.071.905.424-.847 1.811-.906-.423-64.318-30.071-2.54 5.436L462.5 157.5l15.647-.412z”/><path id=“Rectangle-5” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M48 339h117v23H48z”/><text id=“[1,-2,-3]” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“71” y=“354”>[1, 2, 3]</tspan></text><path id=“Rectangle-6” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M243 339h198v65H243z”/><text id=“function-f(args)-{” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“264” y=“358”>function f(args) {</tspan> <tspan x=“264” y=“373”> …</tspan> <tspan x=“264” y=“388”>}</tspan></text><path id=“Rectangle-7” fill=“#252732” stroke=“#4b4e65” stroke-width=“2” d=“M541 339h69v23h-69z”/><text id=“5” fill=“#7a7f9c” font-family=“PTMono-Regular, PT Mono” font-size=“14” font-weight=“normal”><tspan x=“573” y=“355”>5</tspan></text><path id=“Line-4” fill=“#7a7f9c” fill-rule=“nonzero” d=“M299.5 290.5l7 14h-6v28h-2v-28h-6l7-14z”/><path id=“Line-5” fill=“#7a7f9c” fill-rule=“nonzero” d=“M576.5 290.5l7 14h-6v28h-2v-28h-6l7-14z”/><path id=“Line-6” fill=“#7a7f9c” fill-rule=“nonzero” d=“M106.5 290.5l7 14h-6v28h-2v-28h-6l7-14z”/></g></g></svg>

'use strict'
let animal = {
eat: "大鱼大肉"
}
Cat.prototype = animal;
function Cat(name){
this.name = name;
}
const xm = new Cat("小明");
console.log(xm.eat);
// 默认的 "prototype" 是一个只有属性 constructor 的对象,属性 constructor 指向函数自身。
function Dog(){
}
console.log(Dog.prototype.constructor === Dog);
console.log("--------");
let obj = {}
console.log(obj.__proto__ === Object.prototype); // true
// 通过原型查看数组, 字符串等相关的函数(可在浏览器环境下直接使用String.prototype)
// console.log(Object.getOwnPropertyDescriptors(Array.prototype));
console.log(Object.getOwnPropertyNames(Array.prototype));
/* [
'length', 'constructor', 'concat',
'copyWithin', 'fill', 'find',
'findIndex', 'lastIndexOf', 'pop',
'push', 'reverse', 'shift',
'unshift', 'slice', 'sort',
'splice', 'includes', 'indexOf',
'join', 'keys', 'entries',
'values', 'forEach', 'filter',
'flat', 'flatMap', 'map',
'every', 'some', 'reduce',
'reduceRight', 'toLocaleString', 'toString',
'at'
] */
// 所有函数或属性名
console.log(Object.getOwnPropertyNames(String.prototype));
/* [
'length', 'constructor', 'anchor',
'big', 'blink', 'bold',
'charAt', 'charCodeAt', 'codePointAt',
'concat', 'endsWith', 'fontcolor',
'fontsize', 'fixed', 'includes',
'indexOf', 'italics', 'lastIndexOf',
'link', 'localeCompare', 'match',
'matchAll', 'normalize', 'padEnd',
'padStart', 'repeat', 'replace',
'replaceAll', 'search', 'slice',
'small', 'split', 'strike',
'sub', 'substr', 'substring',
'sup', 'startsWith', 'toString',
'trim', 'trimStart', 'trimLeft',
'trimEnd', 'trimRight', 'toLocaleLowerCase',
'toLocaleUpperCase', 'toLowerCase', 'toUpperCase',
'valueOf', 'at'
] */
console.log(Object.getOwnPropertyNames(Number.prototype));
/* [
'constructor',
'toExponential',
'toFixed',
'toPrecision',
'toString',
'valueOf',
'toLocaleString'
] */
console.log(Object.getOwnPropertyNames(Boolean.prototype));
/* [ 'constructor', 'toString', 'valueOf' ] */
console.log(Object.getOwnPropertyNames(Date.prototype));
/* [
'constructor', 'toString', 'toDateString',
'toTimeString', 'toISOString', 'toUTCString',
'toGMTString', 'getDate', 'setDate',
'getDay', 'getFullYear', 'setFullYear',
'getHours', 'setHours', 'getMilliseconds',
'setMilliseconds', 'getMinutes', 'setMinutes',
'getMonth', 'setMonth', 'getSeconds',
'setSeconds', 'getTime', 'setTime',
'getTimezoneOffset', 'getUTCDate', 'setUTCDate',
'getUTCDay', 'getUTCFullYear', 'setUTCFullYear',
'getUTCHours', 'setUTCHours', 'getUTCMilliseconds',
'setUTCMilliseconds', 'getUTCMinutes', 'setUTCMinutes',
'getUTCMonth', 'setUTCMonth', 'getUTCSeconds',
'setUTCSeconds', 'valueOf', 'getYear',
'setYear', 'toJSON', 'toLocaleString',
'toLocaleDateString', 'toLocaleTimeString'
] */
console.log(Object.getOwnPropertyNames(Map.prototype));
/* [
'constructor', 'get',
'set', 'has',
'delete', 'clear',
'entries', 'forEach',
'keys', 'size',
'values'
] */
console.log(Object.getOwnPropertyNames(WeakMap.prototype));
/* [ 'constructor', 'delete', 'get', 'set', 'has' ] */
console.log(Object.getOwnPropertyNames(Function.prototype));
/* [
'length', 'name',
'arguments', 'caller',
'constructor', 'apply',
'bind', 'call',
'toString'
] */

原型借用#

// 自定义原型方法
String.prototype.repeat = function (n) {
console.log(this);
return new Array(n + 1).join(this);
};
console.log("哈".repeat(5)); // 哈哈哈哈哈
// 借用方法
let arrayLike = {
0: "String",
1: "Number",
2: "Boolean",
length: 3,
};
// console.log(arrayLike.join(",")); //报错
console.log([].join.call(arrayLike));
arrayLike.join = Array.prototype.join;
console.log(arrayLike.join(",")); // It's OK
console.log("--------------");
function f() {
console.log("Hello!");
}
f.defer = function (ms) {
setTimeout(this, ms);
};
f.defer(1000); // 1 秒后显示 "Hello!"
{
function f(a, b) {
console.log(a + b);
}
f.defer = function (ms) {
return (...args)=>{
setTimeout(this, ms, ...args);
}
};
f.defer(1000)(1, 2); // 1 秒后显示 3
}
'use strict';
let obj = {
name: "张三",
hello() {
console.log("Hello");
},
};
// 此调用可以对 obj 进行真正准确地拷贝,包括所有的属性:可枚举和不可枚举的,数据属性和 setters/getters —— 包括所有内容,并带有正确的 [[Prototype]]。
let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
console.log(clone);
console.log("---------");
let dictionary = Object.create(null);
// 你的添加 dictionary.toString 方法的代码x
Object.defineProperty(dictionary, "toString", {
value: function(){
return Object.values(this).join(",");
},
enumerable: false
})
// 添加一些数据
dictionary.apple = "Apple";
dictionary.__proto__ = "test"; // 这里 __proto__ 是一个常规的属性键
// 在循环中只有 apple 和 __proto__
for(let key in dictionary) {
console.log(key); // "apple", then "__proto__"
}
// 你的 toString 方法在发挥作用
console.log(String(dictionary)); // "apple,__proto__"
javascript复习
https://blog.tiamix.cn/posts/javascript复习/
作者
Tiam
发布于
2023-08-04
许可协议
CC BY-NC-SA 4.0