Public
Edited
Feb 7
{
const testArr = [1, NaN, "1", "string", true, undefined, null];
const result = Array(),
resultType = Array();
for (let i of testArr) {
result.push(Object(i));
}
for (let i of result) {
resultType.push(typeof i);
}
return [result, resultType];
}
{
const obj = Object({ value: 100 });
return obj;
}
{
const initialObj = {
value: 100
};
const cpoy = Object(initialObj);
// 等价于 const copy = initialObj;
initialObj.value = 10;
return [initialObj, cpoy];
}
{
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const source1 = { b: 100 };
Object.assign(target, source, source1);
return target;
}
{
function my_assign() {
const target = arguments[0];
const sources = Array.from(arguments);
sources.shift();
const sourcesKeys = Array();
sources.forEach((ele) => {
const keys = Object.keys(ele);
keys.forEach((element)=>{
target[element] = ele[element]
})
});
return target;
}
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const source1 = { b: 100 };
return [my_assign(target, source, source1), target];
}
{
const obj = {
name: "li",
age: 10
};
const pro = {
age: {
value: 100,
// 如果不配置 enumerable 的话，可以访问，但是看不到
enumerable: true
},
parent: {
value: {
father: "1",
mother: "2"
},
enumerable: true
}
};
const newObj = Object.create(obj, pro);
const keys = Object.keys(newObj);
// obj 属性改变会影响新创建的对象
obj.name = "wang";
// pro 的内容也仅仅是浅复制
pro.parent.value.father = "000";
return [newObj, newObj.name, keys, newObj.age, newObj.__proto__.age];
}
// 这样简单的配置是没有效果的，需要使用特定的函数进行。
{
const obj = {
age: {
value: 10,
enumerable: false
}
};
return [obj, obj.age]
}
// 引用指向同一个地方，改变一个会导致另一个改变，推荐使用 class
{
const obj = {
age: 10
};
const pro = {
parent: {
value: {
father: "1",
mother: "2"
},
enumerable: true
}
};
const child1 = Object.create(obj, pro);
const child2 = Object.create(obj, pro);
child1.parent.father = "000";
return [child1, child2];
}
// 为 obj 定义一个属性为 age， 不可枚举
{
const obj = Object();
Object.defineProperties(obj, {
age: {
value: 10,
enumerable: false
}
});
return [Object.keys(obj), obj.age, obj];
}
{
const obj = Object();
Object.defineProperty(obj, "age", {
value: 10,
enumerable: false
});
return [Object.keys(obj), obj.age, obj];
}
{
const obj = {
name: "li",
age: 100
};
const arr = Object.entries(obj);
const newObj = Object();
arr.forEach(([key, value]) => (newObj[key] = value));
return [
obj, arr, newObj
];
}
{
const obj = {
age: 100
};
Object.freeze(obj);
const errs = Array();
try {
obj.name = "li";
} catch (error) {
errs.push(error.toString());
}
try {
obj.age = 0;
} catch (error) {
errs.push(error.toString());
}
try {
delete obj.age;
} catch (error) {
errs.push(error.toString());
}
return errs;
}
{
const obj = {
parent: {
father: "1"
}
};
Object.freeze(obj);
try {
obj.parent.father = "0";
} catch (error) {
var err = error.toString();
}
return [obj, err];
}
{
const obj = {
parent: {
father: "1"
}
};
Object.freeze(obj.parent);
try {
obj.parent.father = "0"
} catch (error) {
var err1 = error.toString();
}
try {
obj.parent = {
mother: "2"
};
} catch (error) {
var err2 = error.toString();
}
return [
obj, err1, err2
]
}
{
const obj = {
name: "li",
age: 100
};
const arr = Object.entries(obj);
const newObj1 = Object();
const newObj2 = Object.fromEntries(arr);
arr.forEach(([key, value]) => (newObj1[key] = value));
return [obj, arr, newObj1, newObj2];
}
{
const obj = {
age: 10
};
const pro = Object.getOwnPropertyDescriptor(obj, "age");
return pro;
}
{
const obj = {
age: 10,
parent: {
father: 1,
mother: 2
}
};
const pros = Object.getOwnPropertyDescriptors(obj);
return pros;
}
{
const obj = Object.create(
{},
{
age: {
value: 10,
enumerable: false
}
}
);
const keys1 = Object.keys(obj);
const keys2 = Object.getOwnPropertyNames(obj);
return [keys1, keys2]
}
{
return [
Object.getOwnPropertyNames(Object),
Object.getOwnPropertyNames(Object().__proto__)
];
}
{
const obj = {
pro1: 1,
pro2: 2,
pro3: 3
};
function get({ pro2 }) {
return pro2;
}
return get(obj);
}
{
const arr = [1, 2, 3, 4, 5];
const result = Object.groupBy(arr, (ele) => {
if (ele > 2) {
return "big";
} else {
return "little";
}
});
return result
}
{
const obj = Object.create(
{},
{
realAge: {
value: 10,
enumerable: false
},
fakeAge: {
value: 11,
enumerable: true
}
}
);
return [Object.hasOwn(obj, "realAge"), Object.hasOwn(obj, "fakeAge")];
}
{
const obj = {
null: null,
undefined: undefined,
NaN: NaN
};
return [
Object.hasOwn(obj, "null"),
Object.hasOwn(obj, "undefined"),
Object.hasOwn(obj, "NaN")
]
}
// 空槽是没有该属性
{
const arr = Array(10);
return [Object.hasOwn(arr, "0"), Object.hasOwn(arr, "length"), arr];
}
{
return [Object.getOwnPropertyDescriptors(Array()), Object.getOwnPropertyNames(Array())]
}
{
// 数字处理
// == 会在比较前做类型转化
return [
+0 == -0,
+0 === -0,
Object.is(+0, -0),
,
NaN == NaN,
NaN === NaN,
Object.is(NaN, NaN),
,
"2" == 2,
"2" === 2,
Object.is("2", 2)
];
}
{
// 逻辑处理
return [
"" == false,
0 == false,
"" === false,
0 === false,
Object.is(0, false)
];
}
// 三种不可扩展的区别
{
// 新对象是可拓展的。
const empty = {};
Object.isExtensible(empty); // true
// 它们可以变为不可拓展的
Object.preventExtensions(empty);
Object.isExtensible(empty); // false
// 根据定义，密封对象是不可拓展的。
const sealed = Object.seal({});
Object.isExtensible(sealed); // false
// 根据定义，冻结对象同样也是不可拓展的。
const frozen = Object.freeze({});
Object.isExtensible(frozen); // false
}
{
const obj = Object();
Object.freeze(obj);
return Object.isFrozen(obj);
}
{
const object1 = {
property1: 42
};
Object.seal(object1);
object1.property1 = 33;
return object1;
}
{
const object1 = {};
Object.preventExtensions(object1);
try {
Object.defineProperty(object1, "property1", {
value: 42
});
} catch (e) {
var err = e.toString();
}
return err;
}
// 新属性不可添加
{
const freeze = Object();
const seal = Object();
const prevent = Object();
Object.freeze(freeze);
Object.seal(seal);
Object.preventExtensions(prevent);
const err = Array();
try {
freeze.len = 10;
} catch (error) {
err.push(error.toString());
}
try {
seal.len = 10;
} catch (error) {
err.push(error.toString());
}
try {
prevent.len = 10;
} catch (error) {
err.push(error.toString());
}
return [freeze, seal, prevent, err];
}
// 删除现有属性
{
const freeze = Object({ age: 10 });
const seal = Object({ age: 10 });
const prevent = Object({ age: 10 });
Object.freeze(freeze);
Object.seal(seal);
Object.preventExtensions(prevent);
const err = Array();
try {
delete freeze.age;
} catch (error) {
err.push(["freeze", error.toString()]);
}
try {
delete seal.age;
} catch (error) {
err.push(["seal", error.toString()]);
}
try {
delete prevent.age;
} catch (error) {
err.push(["prevent", error.toString()]);
}
return [freeze, seal, prevent, err];
}
// 修改现有属性
{
const freeze = Object({ age: 10 });
const seal = Object({ age: 10 });
const prevent = Object({ age: 10 });
Object.freeze(freeze);
Object.seal(seal);
Object.preventExtensions(prevent);
const err = Array();
try {
freeze.age = 100;
} catch (error) {
err.push(["freeze", error.toString()]);
}
try {
seal.age = 100;
} catch (error) {
err.push(["seal", error.toString()]);
}
try {
prevent.age = 100;
} catch (error) {
err.push(["prevent", error.toString()]);
}
return [freeze, seal, prevent, err];
}
{
// freeze 保证 Object.keys() 和 Object.values() 都不变， 无法增加，删除，修改
// seal 保证 Object.keys() 不变，保证无法增加，删除，但是可以修改
// preventExtensions 保证 Object.keys() 不会增加，保证无法增加，但是可以删除和修改
// 这三种方法都是不可逆的
}
{
const obj = {
age: 10
};
return [obj.hasOwnProperty("age"), Object.hasOwn(obj, "age")]
}
{
const first = {
age: 10
};
const second = Object.create(first, {
name: {
value: "li",
enumerable: true
}
});
const third = Object.create(second, {
weight: {
value: 100,
enumerable: true
}
});
return [
third,
second.isPrototypeOf(third),
first.isPrototypeOf(second),
first.isPrototypeOf(third),
first.isPrototypeOf({
prototype: first
})
];
}
{
return [
Object.prototype.isPrototypeOf({}),
{}.prototype,
{}.__proto__
]
}
{
const obj = {
name: {
value: "li",
get: function () {
}
}
};
return obj.name.get()
}
{
console.log(10)
console.log(100)
}
{
function myFunction() {
return "code"
}
return [myFunction.name, myFunction(), myFunction.code]
}
// name 属性可以被直接调用
// code 属性不能被直接调用，但是可以通过函数名加小括号的形式调用
{
const obj = Object();
return obj.name;
}
{
function fun() {
fun.thisAge = 100;
}
// fun();
fun.age = 10;
return [fun.age, fun.thisAge];
}
{
function fun() {
return "function";
}
const obj = {
age: "li",
fun: fun
};
fun.prototype = obj;
return [fun.age];
}
{
const pro = {
name: "li"
};
const obj = Object();
obj.__proto__ = pro;
return obj.name;
}
{
function fun() {}
const newFun = new fun();
return newFun
}
{
function fun() {}
return Object.getOwnPropertyDescriptors(fun.prototype);
}
{
const obj = {
age : 10
}
return Object.getOwnPropertyDescriptors(obj)
}
{
const a = {};
return a.constructor === Object
}
{
const a = {}
return [Object.getOwnPropertyDescriptors(a.constructor), a.constructor === Object]
// 说明 constructor 是继承而来的
}
{
function fun1(name) {
this.name = name;
}
function fun2() {
return {
name: "li"
};
}
const newFun1 = new fun1("li");
const newFun2 = new fun2();
return [newFun1, newFun2];
}
// 以给定的 this 执行函数
// call 和 apply 方法功能相同，传参不同
{
function fun(name) {
this.name = name;
}
const commom = new fun("li");
const apply = {
age: 10
};
fun.apply(apply, ["li"]);
return [commom, apply];
}
// bind 创建新函数, 绑定新函数的 this 和前面一部分参数，相当于 apply 的简单调用
{
function fun(value, value1) {
if (Array.isArray(this.value)) {
this.value.push(value);
this.value.push(value1);
} else {
this.value = Array();
}
}
const bindObj = {
value: []
};
const bindFun = fun.bind(bindObj, "bindValue");
bindFun();
bindFun(2);
return bindObj;
}
// 展示源码，但是只能是 js 源码实现的代码
{
function fun(name) {
this.name = "hello" + name;
}
return fun.toString()
}
{
return Object.getOwnPropertyDescriptor.toString()
}
{
function funName() {
return "hello world";
}
return funName.displayName
}
{
function fun(name) {
return "hello" + name.toString();
}
return Object.getOwnPropertyDescriptors(fun)
}
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
