js函数说明
Object.setPrototypeOf
在 JavaScript 中用于设置一个对象的原型（即内部的 [[Prototype]] 属性）。这个方法通常用于改变对象的继承链，或者将一个对象的原型设置为 null 来防止进一步的原型继承。
// 构造函数
function Animal(name) {
this.name = name;
}
// 添加一个方法到 Animal 原型上
Animal.prototype.speak = function() {
console.log(this.name + ' makes a sound.');
};
// 使用构造函数创建一个实例
const animal = new Animal('Generic animal');
// 创建另一个构造函数
function Vehicle(make, model) {
this.make = make;
this.model = model;
}
// 添加一个方法到 Vehicle 原型上
Vehicle.prototype.describe = function() {
console.log('This is a ' + this.make + ' ' + this.model + ' vehicle.');
};
// 使用构造函数创建一个 Vehicle 实例
const car = new Vehicle('Toyota', 'Corolla');
// 现在，我们将 car 实例的原型设置为 animal 实例
// 这意味着 car 将继承 animal 实例的所有属性和方法
Object.setPrototypeOf(car, animal);
// 验证原型链是否已改变
console.log(Object.getPrototypeOf(car) === animal); // 输出: true
// 由于 car 的原型现在是 animal，它继承了 speak 方法
car.speak(); // 输出: Generic animal makes a sound.
// 为了演示，我们也可以将 car 的原型设置为 null，这样它就不再有原型
Object.setPrototypeOf(car, null);
// 再次验证原型链
console.log(Object.getPrototypeOf(car) === null); // 输出: true
// 现在 car 没有原型，因此不能访问 speak 方法
car.speak(); // 输出: TypeError: car.speak is not a function在这个例子中，我们首先定义了两个构造函数 Animal 和 Vehicle，并分别为它们的原型添加了方法 speak 和 describe。然后，我们分别使用这两个构造函数创建了 animal 和 car 实例。接下来，我们使用 Object.setPrototypeOf 方法将 car 实例的原型设置为 animal 实例。这意味着 car 现在继承了 animal 实例的所有属性和方法。我们通过调用 car.speak() 来验证这一点，它输出了 animal 实例的名字和声音。最后，我们再次使用 Object.setPrototypeOf 方法将 car 的原型设置为 null，这意味着 car 将不再继承任何属性和方法。当我们尝试调用 car.speak() 时，由于 car 没有 speak 方法，因此抛出了一个类型错误。这个例子展示了 Object.setPrototypeOf 方法如何用于修改对象的原型链，以及如何通过改变原型来控制对象继承的属性和方法。setPrototypeOf函数在影响了继承链的同时，也对控制对象的继承方法和属性有了更好的理解。
Object.getOwnPropertyDescriptor
Object.getOwnPropertyDescriptor 方法在 JavaScript 中用于获取指定对象上给定属性的描述信息。描述信息是一个包含属性的各种元数据的对象，例如属性是否可枚举、是否可写、默认值以及 getter 和 setter 函数等。这个方法对于深入了解对象属性的具体行为和特征非常有用，尤其是在调试或者需要精确控制对象属性时。
// 创建一个对象，并定义一个属性
const myObject = {
myProperty: 'Hello, World!'
};
// 定义一个 getter 和一个 setter 函数
const getter = function () {
return this.myProperty + ' (accessed via getter)';
};
const setter = function (newValue) {
this.myProperty = newValue + ' (updated via setter)';
};
// 使用 Object.defineProperty 为对象添加一个带有 getter 和 setter 的属性
Object.defineProperty(myObject, 'accessorProperty', {
get: getter,
set: setter,
enumerable: true,
configurable: true
});
// 使用 Object.getOwnPropertyDescriptor 获取属性描述信息
const descriptor = Object.getOwnPropertyDescriptor(myObject, 'accessorProperty');
// 打印属性描述信息
console.log(descriptor);
// 输出:
// {
// value: 'Hello, World! (accessed via getter)',
// writable: false,
// enumerable: true,
// configurable: true,
// get: [Function: getter],
// set: [Function: setter]
// }
// 直接访问属性值
console.log(myObject.accessorProperty); // 输出: 'Hello, World! (accessed via getter)'
// 修改属性值
myObject.accessorProperty = 'Goodbye, World!';
console.log(myObject.accessorProperty); // 输出: 'Goodbye, World! (updated via setter)' 在这个例子中，我们首先创建了一个对象 myObject 并给它定义了一个普通的属性 myProperty。接着，我们定义了一个 getter 函数和一个 setter 函数，并将它们与 Object.defineProperty 方法一起使用，为 myObject 添加了一个带有访问器（accessor）的属性 accessorProperty。使用 Object.getOwnPropertyDescriptor 方法，我们获取了 accessorProperty 的描述信息，并打印出来。描述信息对象包含了属性的值、是否可写、是否可枚举、是否可配置以及 getter 和 setter 函数的引用。然后，我们通过直接访问 accessorProperty 来触发 getter 函数，并打印出它的返回值。之后，我们尝试修改 accessorProperty 的值，这将触发 setter 函数，并将修改后的值打印出来。通过这个例子，我们可以看到 Object.getOwnPropertyDescriptor 方法如何帮助我们获取和理解对象属性的详细信息。
另外要提醒一下，对于定义在对象里面的不可枚举的一些属性的时候，getOwnPropertyDescriptor 方法是不可以枚举出这些属性的。要用getOwnPropertyNames 方法。
Object.getOwnPropertyNames
Object.getOwnPropertyNames 方法在 JavaScript 中用于获取一个对象的所有可枚举的自有属性的名称，包括那些不可枚举的属性。这个方法返回一个字符串数组，数组中的每个元素都是对象的一个属性名。这个方法对于理解对象的内部属性非常有用，尤其是当你想要获取对象所有的属性，包括那些可能在常规枚举中被忽略的属性时。下面是一个使用 Object.getOwnPropertyNames 方法的例子：
// 定义一个对象
const myObject = {
enumerableProperty: 'I am enumerable',
nonEnumerableProperty: 'I am not enumerable'
};
// 添加一个不可枚举的属性
Object.defineProperty(myObject, 'anotherNonEnumerableProperty', {
value: 'Another non-enumerable property',
enumerable: false
});
// 使用 Object.keys 获取对象的键（只能获取可枚举的键）
const keys = Object.keys(myObject);
console.log(keys); // 输出: ["enumerableProperty"]
// 使用 Object.getOwnPropertyNames 获取对象的所有自有属性名称
const allPropertyNames = Object.getOwnPropertyNames(myObject);
console.log(allPropertyNames); // 输出: ["enumerableProperty", "nonEnumerableProperty", "anotherNonEnumerableProperty"] 在这个例子中，我们首先定义了一个对象 myObject，它包含一个可枚举属性 enumerableProperty 和一个不可枚举属性 nonEnumerableProperty。然后，我们使用 Object.defineProperty 方法添加了另一个不可枚举属性 anotherNonEnumerableProperty。当我们使用 Object.keys 方法时，它只返回了可枚举的属性 enumerableProperty。然而，当我们使用 Object.getOwnPropertyNames 方法时，它返回了所有的自有属性名称，包括那些不可枚举的属性 nonEnumerableProperty 和 anotherNonEnumerableProperty。这个方法在调试或者当你需要分析一个对象的所有属性时非常有用，尤其是当你不确定对象中是否存在某些属性时。
Object.getOwnPropertySymbols
在 JavaScript 中用于获取一个对象的所有自有符号属性（Symbol properties）。符号属性是一种特殊的属性，它通过 Symbol 函数创建，具有唯一性，即使两个不同的 Symbol 看起来可能相同，它们在技术上也是不同的。这个方法对于处理那些希望避免属性名冲突的高级用例非常有用，因为 Symbol 值是唯一的，不会与其他属性名或 Symbol 值冲突。
下面是一个使用 Object.getOwnPropertySymbols 方法的例子：
// 创建一个对象
const myObject = {};
// 定义两个符号属性并添加到对象中
const sym1 = Symbol('uniqueDescription1');
const sym2 = Symbol('uniqueDescription2');
myObject[sym1] = 'This is a symbol property with description 1';
myObject[sym2] = 'This is another symbol property with description 2';
// 使用 Object.getOwnPropertyNames 获取对象的所有自有字符串属性名称
const stringPropertyNames = Object.getOwnPropertyNames(myObject);
console.log(stringPropertyNames); // 输出: []
// 使用 Object.getOwnPropertySymbols 获取对象的所有自有符号属性
const symbolProperties = Object.getOwnPropertySymbols(myObject);
console.log(symbolProperties); // 输出: [Symbol(uniqueDescription1), Symbol(uniqueDescription2)]
// 打印符号属性的描述和值
symbolProperties.forEach(sym => {
console.log(`Symbol description: ${sym.description}, Symbol value: ${myObject[sym]}`);
});
// 输出:
// Symbol description: uniqueDescription1, Symbol value: This is a symbol property with description 1
// Symbol description: uniqueDescription2, Symbol value: This is another symbol property with description 2在这个例子中，我们首先创建了一个空对象 myObject，然后定义了两个具有不同描述的符号，并使用这些符号作为属性名将它们添加到 myObject 中。我们还为这些符号属性赋予了字符串值。当我们使用 Object.getOwnPropertyNames 方法时，它没有返回任何属性名称，因为 myObject 中没有可枚举的字符串属性。然而，当我们使用 Object.getOwnPropertySymbols 方法时，它返回了一个包含所有自有符号属性的数组。最后，我们遍历了符号属性数组，并打印了每个符号的描述和对应的值。这展示了如何访问和使用符号属性，尽管在大多数情况下，我们更倾向于使用 Object.keys 或 Object.getOwnPropertyNames 来处理常规属性。
Object.getPrototypeOf
Object.getPrototypeOf方法在 JavaScript 中用于获取指定对象的原型对象，即对象链中的下一个链接。原型对象是对象继承属性和方法的来源。这个方法对于理解对象的继承结构和访问对象原型上的属性和方法非常有用。用来改变原有的继承链，也同时像setPrototypeOf 一样，去改变原有的继承对象的属性与方法。下面是一个使用 Object.getPrototypeOf 方法的例子：
// 构造函数
function Animal(name) {
this.name = name;
}
// 添加一个方法到 Animal 原型上
Animal.prototype.speak = function() {
console.log(this.name + ' makes a sound.');
};
// 使用构造函数创建一个实例
const animal = new Animal('Generic animal');
// 获取 animal 实例的原型对象
const proto = Object.getPrototypeOf(animal);
// 由于 Animal.prototype 被设置为 animal 的原型，proto 将指向 Animal.prototype
console.log(proto === Animal.prototype); // 输出: true
// 调用通过原型继承的 speak 方法
proto.speak.call(animal); // 输出: Generic animal makes a sound.
// 创建另一个对象，使用 Object.create 方法设置其原型为 animal 实例
const anotherAnimal = Object.create(animal);
// 此时，anotherAnimal 的原型是 animal 实例
const anotherProto = Object.getPrototypeOf(anotherAnimal);
console.log(anotherProto === animal); // 输出: true
// 由于 anotherAnimal 是以 animal 为原型创建的，它不会继承 Animal.prototype 上的方法
anotherProto.speak.call(anotherAnimal); // 输出: undefined makes a sound. 在这个例子中，我们首先定义了一个 Animal 构造函数，并为其原型添加了一个 speak 方法。然后，我们使用 new 关键字创建了一个 animal 实例。通过 Object.getPrototypeOf 方法，我们获取了 animal 实例的原型对象，它指向 Animal.prototype。因此，当我们调用 proto.speak.call(animal) 时，它能够正确地输出 animal 实例的名字和它发出的声音。接下来，我们使用 Object.create 方法创建了一个新的对象 anotherAnimal，其原型被设置为 animal 实例。这意味着 anotherAnimal 继承自 animal 实例，而不是 Animal.prototype。当我们尝试通过 anotherProto.speak.call(anotherAnimal) 调用 speak 方法时，由于 animal 实例上没有 speak 方法，所以输出为 undefined makes a sound.。这个例子展示了 Object.getPrototypeOf 方法如何帮助我们访问和理解对象的原型链，以及如何通过原型链访问对象的属性和方法。
另外说一下，在实际的工作场景中使用到这个方法的案例不是特别常见，我们可以通过在不同的场景对象下使用不同的方法来获取到原型对象：
在p实例化对象的场景下，用.__proto__的方法，即是p.__proto__；在person构造函数的情况下用.prototype的方法来获取到原型对象，最后得到的结果是一样的。
Object.keys
Object.keys 方法在 JavaScript 中用于获取一个对象自身的所有可枚举属性的键名（属性名），并以数组的形式返回。这个方法通常用于遍历对象的属性，尤其是当你需要对对象的属性进行操作时。下面是一个使用 Object.keys 方法的例子：
// 创建一个对象，包含多个属性，其中一些属性是不可枚举的
const myObject = {
enumerableProperty: 'This property is enumerable',
nonEnumerableProperty: 'This property is not enumerable',
anotherEnumerableProperty: 'Another enumerable property'
};
// 使用 Object.defineProperty 为对象添加一个不可枚举的属性
Object.defineProperty(myObject, 'anotherNonEnumerableProperty', {
value: 'This is another non-enumerable property',
writable: true,
enumerable: false,
configurable: true
});
// 使用 Object.keys 获取对象的可枚举属性键名
const keys = Object.keys(myObject);
console.log(keys); // 输出: ["enumerableProperty", "anotherEnumerableProperty"]
// 尝试使用 for...in 循环遍历对象的所有属性
for (const key in myObject) {
console.log(key + ': ' + myObject[key]);
}
// 输出:
// enumerableProperty: This property is enumerable
// nonEnumerableProperty: This property is not enumerable
// anotherEnumerableProperty: Another enumerable property
// anotherNonEnumerableProperty: This is another non-enumerable property
// 说明：for...in 循环会枚举对象自身的属性以及其原型链上可枚举的属性在这个例子中，我们首先创建了一个 myObject 对象，它包含一个可枚举属性 enumerableProperty，一个不可枚举属性 nonEnumerableProperty，以及一个通过 Object.defineProperty 添加的不可枚举属性 anotherNonEnumerableProperty。当我们使用 Object.keys 方法时，它只返回了可枚举的属性键名，即 enumerableProperty 和 anotherEnumerableProperty。不可枚举的属性 nonEnumerableProperty 和 anotherNonEnumerableProperty 没有被包含在内。随后，我们使用 for...in 循环遍历对象的所有属性，包括可枚举和不可枚举的属性。这是因为 for...in 循环不仅枚举对象自身的属性，还会枚举其原型链上可枚举的属性。通过这个例子，我们可以看到 Object.keys 方法如何用于获取对象的可枚举属性键名，这对于编写只处理可枚举属性的代码非常有用。同时，我们也了解了 for...in 循环与 Object.keys 方法在枚举属性方面的差异。
Object.preventExtensions
Object.preventExtensions 方法在 JavaScript 中用于阻止一个对象被添加新的属性，即冻结对象。如果操作成功，该方法返回 true；如果对象已经是不可扩展的，或者操作失败（例如，对象是密封的），则返回 false。这个方法对于确保对象的完整性和安全性非常有用，尤其是在你不希望对象的结构在运行时被改变的情况下。下面是一个使用 Object.preventExtensions 方法的例子：
// 创建一个对象
const myObject = {
property1: 42
};
// 检查对象是否可扩展
console.log(Object.isExtensible(myObject)); // 输出: true
// 阻止对象扩展新的属性
const success = Object.preventExtensions(myObject);
console.log(success); // 输出: true
// 尝试添加新的属性
myObject.property2 = 'Hello';
console.log(myObject.property2); // 输出: undefined
// 再次检查对象是否可扩展
console.log(Object.isExtensible(myObject)); // 输出: false
// 修改现有属性的值
myObject.property1 = 100;
console.log(myObject.property1); // 输出: 100
// 删除现有属性
delete myObject.property1; // 返回 true，表示删除成功
console.log(myObject.property1); // 输出: undefined在这个例子中，我们首先创建了一个对象 myObject 并给它定义了一个属性 property1。使用 Object.isExtensible 方法检查对象是否可扩展，此时输出为 true，表示对象可以添加新属性。接着，我们调用 Object.preventExtensions 方法来防止对象扩展新属性。尝试给对象添加一个新属性 property2，但是操作失败，新属性没有被添加到对象中，且 property2 的值为 undefined。尽管我们阻止了对象扩展新属性，但是现有的属性仍然可以被修改或删除。我们修改了 property1 的值，并成功将其删除。这个例子展示了 Object.preventExtensions 方法如何用于控制对象的结构，防止对象被意外地修改，同时保持对现有属性的灵活性。
拦截器
首先，我们在这儿定义了一个这样的方法，然后给它在这个属性就是my project, 这个对象是绑定了一个方法，绑定这个方法之后，它就有这两个属性。一个属性是get，另一个属性是set，结合上面分别定义了getter和setter方法。get属性起到的作用是通知，当有人调用我们这个方法时，我们会通过定义的getter函数来达到通知的作用。set属性起到的作用是拦截，当有人调用我们这个方法时，通过写好的setter函数来达到拦截的作用。
js中一些知识点补充
js中>>>
js中>>
特殊函数调用方式
function s(n)
{
var n = new z[M1](T1 + n + C1);
return (n = z[I][P1][A1](n)) ? z[g2](n[2]) : F
}let str = "123";
let num = +str;
console.log(num); // 输出 123const regex = new RegExp("^hello");
console.log(regex.test("hello world")); // true
console.log(regex.test("world hello")); // falselet escapedStr = "Hello%2C%20world%21%20%F0%9F%98%8A";
let unescapedStr = unescape(escapedStr);
console.log(unescapedStr); // 输出: "Hello, world! 😊"forEach(function(n) {
if (n == p)
return !B;
hasOwnProperty(n) && a['push'](t["params"][n])
})r.prototype.use = function(e, t) {
return this.handlers.push({
fulfilled: e,
rejected: t
}),
this.handlers.length - 1
}node js里转base64的方法
const str = 'hello world';
const base64Str = Buffer.from(str).toString('base64');
console.log(base64Str); // aGVsbG8gd29ybGQ=
将 base64 格式的字符串解码为原始数据
const base64Str = 'aGVsbG8gd29ybGQ=';
const originalData = Buffer.from(base64Str, 'base64').toString();
console.log(originalData); // hello worldfunction hh(n, t) {
t = t || u();
for (var e = (n = n["split"](_))["length"], r = t["length"], a =
"charCodeAt", i = 0; i < e; i++)
n[i] = o(n[i]["charCodeAt"](0) ^ t[(i + 10) % r]["charCodeAt"]
(0));
return join(_)
}获取对象中键的方法
const obj = { a: 1, b: 2 };
const objKeys = Object.keys(obj);
console.log(objKeys); // ['a', 'b']
fromCharCode() 是一个 String 对象上的方法，可以将一个 Unicode 编码的整数序列转换成对应的字符
串。该方法接受一个或多个 Unicode 编码点的整数序列作为参数，并返回对应的字符串。例如：
// 将 Unicode 编码点序列 72, 101, 108, 108, 111 转换为字符串
const str = String.fromCharCode(72, 101, 108, 108, 111);
console.log(str); // output: "Hello"
在这个例子中，fromCharCode() 方法接受了 5 个整数参数，分别是 Unicode 编码点 72 101 108
108 111，然后将它们转换成对应的字符并拼接成字符串 Hello" 并返回。
可以用 fromCharCode() 来生成某个范围内的 Unicode 编码点序列，并将它们转换成字符串，例
如：
// 将 ` `a` 到 ` `z` 的字符转换为对应的 Unicode 编码点序列，然后拼接成字符串
const unicodePoints = [];
for (let i = 97; i <= 122; i++) {
unicodePoints.push(i);
}
const str = String.fromCharCode(...unicodePoints);
console.log(str); // output: "abcdefghijklmnopqrstuvwxyz"
1065
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
