目录
- Symbol
- 对象的基本类型转换
- 基本类型数据的方法
- 数组
- 可迭代对象 | 类数组对象
- Map | Set
- WeakMap | WeakSet
- 解构赋值
- date对象
- JSON对象
- spread语法与rest参数
- 词法环境与闭包
- 全局对象
- 函数进阶
- 调度
- 装饰器
- 间谍装饰器
- 延时装饰器
- 防抖装饰器
- 节流装饰器*有问题
- 绑定this | this
- 绑定参数
- 对象属性配置
- getter,setter
- 原型继承
- Prototype
- 原型借用
【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)); // ageconsole.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 => 1621466959278console.log(String(date)); // string => 2023-08-04 10:44:33console.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) === trueObject.is(0, -0) === false
// 只能通过isNaN() 函数判断在内部,数字是以 64 位格式 IEEE-754 表示的,所以正好有 64 位可以存储一个数字:其中 52 位被用于存储这些数字,其中 11 位用于存储小数点的位置,而 1 位用于符号。
如果一个数字真的很大,则可能会溢出 64 位存储,变成一个特殊的数值 Infinity:
判断是否为常规数字: isFinite()
alert( isFinite("15") ); // truealert( isFinite("str") ); // false,因为是一个特殊的值:NaNalert( 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') ); // 100alert( 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可迭代对象 | 类数组对象
- 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**]**ofuser**)*
解构对象
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); // Menualert(w); // 100alert(h); // 200date对象
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:16JSON对象
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,6console.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 显示的是 10army[1](); // 编号为 1 的 shooter 显示的是 10army[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);/*1010201530074005500060107012*/使用“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 OKconsole.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); // 3work(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 wrapperslet 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
'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 方法的代码xObject.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__"