JS 之 操作 Object 对象

已于 2022-07-29 10:17:22 修改
阅读量409 收藏 1
点赞数 1
分类专栏： JS 文章标签： javascript object 前端 defineProperty
于 2022-07-17 14:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15297701931/article/details/125828659
版权

目录​​​​​​​

Object - JavaScript | MDN

一. 对象的使用

二. 对象的创建方式

1 - 对象字面量

2 - 构造函数

3 - 类创建 

三. 对象的操作

1 - 定义

2 - 访问对象属性 

3 - 修改对象属性

4 - 增加对象属性 

5 - 删除对象属性 

四. 对象的方括号 [] 使用法

五. 对象的遍历 

1 - 普通for循环

2 - for ... in ...

3 - Object.keys( )

4 - Object.values( )

5 - Object.entries( )

6 - Object.fromEntries( )

六. 对象的内存分配

1 - 面试题一

2 - 面试题二

3 - 面试题三

4 - 面试题四

5 - 面试题五

七. 创建一系列对象的方式

1 - 一个一个写

2 - 通过for循环写

3 - 通过工厂函数 

4 - 通过new操作符来创建

八. Object.defineProperty Object.defineProperty() | MDN

数据属性描述符

Configurable

Enumerable

Writable

value 

存取属性描述符

Configurable

Enumerable

get

set

Object.defineProperties

额外方法补充

01 - 获取对象的属性描述符

02 - 禁止对象扩展新属性

03 - 密封对象，不允许配置和删除属性

04 - 冻结对象，不允许修改现有属性

九. 对象的解构

1 - 简单的解构

2 - 解构并重命名

3 - 解构的默认值

​​​​​​​4 - 解构的剩余内容

十. 判断对象属性

1 - hasOwnProperty

2. hasOwn

3. 两者的区别 

1. 挂载的地方不同

2. 当创建的对象为顶层对象时

Object - JavaScript | MDN

一. 对象的使用

  • key: 字符串类型, 但是在定义对象的属性名时, 大部分情况下引号都是可以省略的
  • value : 可以是任意值
const person = {
  name: 'why',
  age: 18,
  height: 1.88,
  // 这种的就要加上''号
  'my friend': {
    name: 'kobe',
    age: 30
  },
  run: function () {
    console.log('running');
  },
  eat: function () {
    console.log('eat foods');
  },
};

二. 对象的创建方式

1 - 对象字面量

// 直接花括号赋值即可，用的最多
const obj1 = {
   name: "why"
}

2 - 构造函数

// 当函数被new关键词调用时，该函数就被称为构造函数
const obj = new Object()
obj.name = "star"
obj2.runing = function(){}

3 - 类创建 

class Person {
  constructor(name) {
    this.name = name;
  }
}
const stu = new Person('star');

三. 对象的操作

1 - 定义

const info = {
  name: "star",
  age: 18,
  friend: {
    name: "coder",
    age: 30
  },
  running: function() {
    console.log("running~")
  }
}

2 - 访问对象属性 

console.log(info.name)
console.log(info.friend.name)
info.running()

3 - 修改对象属性

info.age = 25
info.running = function() {
  alert("I am running~")
}
console.log(info.age)
info.running()

4 - 增加对象属性 

info.height = 1.88
info.studying = function() {
  console.log("I am studying~")
}

5 - 删除对象属性 

delete info.age
delete info.height

四. 对象的方括号 [] 使用法

const obj = {
  name: "why",
  "my friend": "kobe",
  "eating something": function() {
    console.log("eating~")
  }
}

// 这里 . 语法不能用
console.log(obj["my friend"])

console.log(obj.name)
// 这和 . 语法一个意思
console.log(obj["name"])

// 用变量的值充当对象的key
var eatKey = "eating something"
obj[eatKey]()

// 可连在一起使用
obj["eating something"]()

五. 对象的遍历 

1 - 普通for循环

// Object.keys() => 拿到对象的所有key
const infoKeys = Object.keys(info)
for (let i = 0; i < infoKeys.length; i++) {
  // 拿到key的值
  let key = infoKeys[i]
  // 拿到value的值
  let value = info[key]
  console.log(`key: ${key}, value: ${value}`)
}

2 - for ... in ...

// 可直接拿到对象的key
for (let key in info) {
  let value = info[key]
  console.log(`key: ${key}, value: ${value}`)
}

3 - Object.keys( )

const obj = {
  name: 'star',
  age: 18,
  height: 1.88
};

// 获取所有的key
const keys = Object.keys(obj);
console.log(keys); // ['name', 'age', 'height']

4 - Object.values( )

const obj = {
  name: 'star',
  age: 18,
  height: 1.88
};

// 获取所有的value
const values = Object.values(obj);
console.log(values); //  ['star', 18, 1.88]

5 - Object.entries( )

const obj = {
  name: 'star',
  age: 18,
  height: 1.88
};

const entries = Object.entries(obj);
console.log(entries); // [[key,value], ...] =>  [['name', 'star'], ['age', 18], ['height', 1.88]]
for (const entry of entries) {
  // 解构一下
  const [key, value] = entry;
  console.log(key, value);
}

6 - Object.fromEntries( )

const obj = {
  name: 'star',
  age: 18,
  height: 1.88,
  friends: [1, 2, 3]
};

const entries = Object.entries(obj);
console.log(entries); // [ ['name', 'star'], ['age', 18], ['height', 1.88] ]

// 可以装换回对象
const info = Object.fromEntries(entries);
console.log(info); // {name: 'star', age: 18, height: 1.88}
// 是一个浅拷贝
console.log(info === obj, info.friends === obj.friends); // false , true

六. 对象的内存分配

js代码可以运行在浏览器，也可运行在node环境，无论是什么环境，最终都是运行在内存中

内存会映射在真实的电脑物理内存中，所以内存越大，跑的速度越快～～～

  • 基本类型 : 存储在内存中的栈内存
  • 引用类型 : 存储在内存中的堆内存

​

1 - 面试题一

const obj1 = {}
const obj2 = {}
console.log(obj1 === obj2) // false

​

2 - 面试题二

const info = {
  name: "why",
  friend: {
    name: "kobe"
  }
}

const friend = info.friend
friend.name = "james"
console.log(info.friend.name) // james

​

3 - 面试题三

function foo(a) {
  a = 200
}
const num = 100
foo(num)
console.log(num) // 100

​

4 - 面试题四

function foo(a) {
  a = {
    name: "star"
  }
}
const obj = {
  name: "obj"
}
foo(obj)
console.log(obj) //{ name:obj }

​

5 - 面试题五

function foo(a) {
  a.name = "star"
}

const obj = {
  name: "obj"
}
foo(obj)
console.log(obj) // {name : star}

​

七. 创建一系列对象的方式

1 - 一个一个写

有点小蠢～

const stu1 = {
  name: 'star',
  age: 16,
  height: 1.66,
  running: function () {
    console.log('running~');
  }
};
const stu2 = {
  name: 'coder',
  age: 17,
  height: 1.77,
  running: function () {
    console.log('running~');
  }
};
const stu3 = {
  name: 'liuli',
  age: 18,
  height: 1.88,
  running: function () {
    console.log('running~');
  }
};

2 - 通过for循环写

还是有点蠢～

const nameArr = ['star', 'coder', 'liuli'];
const ageArr = [16, 17, 18];
const heightArr = [1.66, 1.77, 1.88];
const funcs = {
  running: function () {
    console.log('running~');
  }
};

for (let i = 0; i < nameArr.length; i++) {
  let stu = {
    name: nameArr[i],
    age: ageArr[i],
    height: heightArr[i],
    running: funcs.running
  };
  console.log(stu); //{name: 'star', age: 16, height: 1.66, running: ƒ} ...
}

3 - 通过工厂函数 

// 工厂函数(工厂生产student对象) -> 一种设计模式
// 通过工厂设计模式, 自己来定义了一个这样的函数
function createStudent(name, age, height) {
  const stu = {};
  stu.name = name;
  stu.age = age;
  stu.height = height;
  stu.running = function () {
    console.log('running~');
  };
  return stu;
}

const stu1 = createStudent('stare', 16, 1.66);
const stu2 = createStudent('coder', 17, 1.77);
const stu3 = createStudent('liuli', 18, 1.88);
console.log(stu1);
console.log(stu2);
console.log(stu3);

弊端 :  拿到的数据的类型都是Object类型

4 - 通过new操作符来创建

简单理解下构造函数

​

​

// JavaScript已经默认提供给了我们可以更加符合JavaScript思维方式(面向对象的思维方式)的一种创建对象的规则
// 在函数中的this一般指向某一个对象
/*
  如果一个函数被new操作符调用
    1.创建出来一个新的空对象
    2.这个对象的 __proto__ 指向构造函数的 prototype
    3.让this指向这个空对象
    4.执行函数体的代码块
    5.如果没有明确的返回一个非空对象, 那么this指向的对象会自动返回
*/
function Coder(name, age, height) {
  //  相当于new操作符做了
  //  let obj = {}
  //  this = obj
  this.name = name
  this.age = age
  this.height = height
  this.running = function() {
    console.log("running~")
  }
  // return this
}

// 在函数调用的前面加 new 关键字(操作符)
const stu1 = new coder("why", 18, 1.88)
const stu2 = new coder("kobe", 30, 1.98)
console.log(stu1, stu2)

八. Object.defineProperty Object.defineProperty() | MDN

  • 通过属性描述符可以精准的添加或修改对象的属性
  • 属性描述符需要使用 Object.defineProperty 来对属性进行添加或者修改

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象

Object.defineProperty(obj, prop, descriptor)

可接收三个参数：
        obj要定义属性的对象
        prop要定义或修改的属性的名称或 Symbol
        descriptor要定义或修改的属性描述符
返回值：
        被传递给函数的对象。

属性描述符的类型有两种 : 

  • 数据属性（Data Properties）描述符（Descriptor）
  • 存取属性（Accessor访问器 Properties）描述符（Descriptor）

数据属性描述符

Configurable

  • [[Configurable]] : 表示属性是否可以通过delete删除属性，是否可以修改它的特性，或者是否可以将它修改为存取属性描述符
    • 当直接在一个对象上定义某个属性时，这个属性的[[Configurable]]为true
    • 当通过属性描述符定义一个属性时，这个属性的[[Configurable]]默认为false
const obj = {
  name: 'star',
  age: 18
};
// 修改configurable
Object.defineProperty(obj, 'name', {
  configurable: false // 定义不可删除
});
// 不能删除
delete obj.name;
console.log(obj); // {name: 'star', age: 18}

// 不能再次配置，这里报错
Object.defineProperty(obj, 'name', {
  configurable: true 
});

Enumerable

  • [[Enumerable]] : 表示属性是否可以通过for-in或者Object.keys()返回该属性
    • 当直接在一个对象上定义某个属性时，这个属性的[[Enumerable]]为true
    • 当通过属性描述符定义一个属性时，这个属性的[[Enumerable]]默认为false
const obj = {
  name: 'star',
  age: 18
};
// 修改configurable
Object.defineProperty(obj, 'name', {
  enumerable: false // 不可枚举
});

for (const key in obj) {
  console.log('key:', key, ' === value:', obj[key]); // key: age  === value: 18
}

Writable

  • [[Writable]] : 表示是否可以修改属性的值
    • 当直接在一个对象上定义某个属性时，这个属性的[[Writable]]为true
    • 当通过属性描述符定义一个属性时，这个属性的[[Writable]]默认为false
const obj = {
  name: 'star',
  age: 18
};
// 修改configurable
Object.defineProperty(obj, 'name', {
  writable: false // 不可修改
});
// 修改失败
obj.name = 'coder';

console.log(obj); // {name: 'star', age: 18}

value 

  • [[value]] : 属性的value值，读取属性时会返回该值，修改属性时，会对其进行修改
    • 默认情况下这个值是undefined
const obj = {
  name: 'star',
  age: 18
};
// 修改configurable
Object.defineProperty(obj, 'name', {
  value: 'coder' // 优先读取和修改这里的值
});
console.log(obj); // {name: 'coder', age: 18}

obj.name = 'coderstar';
console.log(obj); // {name: 'coderstar', age: 18}

存取属性描述符

Configurable

  • [[Configurable]] : 表示属性是否可以通过delete删除属性，是否可以修改它的特性，或者是否可以将它修改为存取属性描述符
    • 和数据属性描述符是一致的
    • 当直接在一个对象上定义某个属性时，这个属性的[[Configurable]]为true
    • 当通过属性描述符定义一个属性时，这个属性的[[Configurable]]默认为false

Enumerable

  • [[Enumerable]] : 表示属性是否可以通过for-in或者Object.keys()返回该属性
    • 和数据属性描述符是一致的
    • 当直接在一个对象上定义某个属性时，这个属性的[[Enumerable]]为true
    • 当通过属性描述符定义一个属性时，这个属性的[[Enumerable]]默认为false

get

  • [[get]]：获取属性时会执行的函数。默认为undefined

set

  • [[set]]：设置属性时会执行的函数。默认为undefined
const obj = {
  name: 'star',
  age: 18
};
// 这里通过一个闭包来实现获取值
let _name = '';
// 修改configurable
Object.defineProperty(obj, 'name', {
  configurable: true,
  enumerable: false,
  // 获取属性的值时会促发的函数
  get() {
    // return obj.name 千万不要这么写，会形成死循环
    console.log('get函数触发');
    return _name;
  },
  // 设置属性的值时会促发的函数
  set(value) {
    _name = value;
    console.log('set函数触发', value);
  }
});
obj.name = 'coder'; // set函数触发 coder
obj.name = 'coderstar'; // set函数触发 coderstar

console.log(obj.name); // get函数触发  coderstar

Object.defineProperties

直接在一个对象上定义 多个 新的属性或修改现有属性，并且返回该对象,其他和上面辣个一样

const obj = {
  name: 'star',
  age: 18
};

Object.defineProperties(obj, {
  name: {
    configurable: true,
    enumerable: false,
    writable: false,
    value: 'star'
  },
  age: {
    configurable: true,
    enumerable: true,
    set(value) {
      console.log('set响应', value);
    }
  }
});
console.log(obj.name); // 'star'
obj.age = '19'; // set响应 19

额外方法补充

01 - 获取对象的属性描述符

getOwnPropertyDescriptor : 获得单个属性的描述符
getOwnPropertyDescriptors : 获得好多个属性的描述符

const obj = {
  name: 'star',
  age: 18
};
/**
 * {
 *    value: 'star',
 *    writable: true,
 *    enumerable: true,
 *    configurable: true
 * }
*/
console.log(Object.getOwnPropertyDescriptor(obj, 'name'));
/**
 * {
 *    age: {value: 18, writable: true, enumerable: true, configurable: true}
 *    name: {value: 'star', writable: true, enumerable: true, configurable: true
 * }
*/
console.log(Object.getOwnPropertyDescriptors(obj));

02 - 禁止对象扩展新属性

const obj = {
  name: 'star',
  age: 18
};
// 阻止扩展新属性
Object.preventExtensions(obj);
// 添加失败
obj.address = '广州市';

console.log(obj); // {name: 'star', age: 18}

03 - 密封对象，不允许配置和删除属性

  • 实际是调用preventExtensions

  • 并且将现有属性的configurable:false

const obj = {
  name: 'star',
  age: 18
};
// 密封对象(不能进行配置)
Object.seal(obj);
delete obj.name;

console.log(obj); // {name: 'star', age: 18}

04 - 冻结对象，不允许修改现有属性

const obj = {
  name: 'star',
  age: 18
};
// 密封对象(不能进行配置)
Object.freeze(obj);
obj.name = 'coder';

console.log(obj); // {name: 'star', age: 18}

九. 对象的解构

1 - 简单的解构

const obj = { name: "star", age: 18, height: 2.05 }

// 对象的解构，不根据顺序解构，根据key解构
const { age, name, height } = obj
console.log(name, age, height) // star 18 2.05

2 - 解构并重命名

const obj = { name: "star", age: 18, height: 2.05 }

const { height: SHeight, name: SName, age: SAge } = obj
console.log(SName, SAge, SHeight) // star 18 2.05

3 - 解构的默认值

const obj = { name: "star", age: 18, height: 2.05 }

const { 
  height: SHeight, 
  name: SName, 
  // 如果值有值的情况下，不会使用默认值
  age: SAge = 29, 
  // 如果值为undefined的属性值，会使用默认值
  address: SAddress = "中国"
} = obj
console.log(SName, SAge, SHeight, SAddress) // star 18 2.05 中国

​​​​​​​4 - 解构的剩余内容

const obj = { name: "star", age: 18, height: 2.05 }

const {
  name,
  // 剩下没解构的数据会全部生成到这里
  ...newObj
} = obj
console.log(name) // star
console.log(newObj) // { age: 18, height: 1.88 }

十. 判断对象属性

1 - hasOwnProperty

对象是否有某一个属于自己的属性（不是在原型上的属性）

const obj = {
  name: 'star',
  age: '19'
};
obj.__proto__ = {
  address: '北京'
};
 
console.log(obj, obj.address); // {name: 'star', age: '19'} '北京'

// 判断是否是自己的属性，是为true
console.log(obj.hasOwnProperty('name')); // true
console.log(obj.hasOwnProperty('address')); // false
// 没有的属性也为false
console.log(obj.hasOwnProperty('abc')); // false

2. hasOwn

Object中新增了一个静态方法（类方法）： hasOwn(obj, propKey)

该方法用于判断一个对象中是否有某个自己的属性

const obj = {
  name: 'star',
  age: '19'
};
obj.__proto__ = {
  address: '北京'
};
 
console.log(obj, obj.address); // {name: 'star', age: '19'} '北京'

// 判断是否是自己的属性，是为true
console.log(Object.hasOwn(obj, "name")) // true
console.log(Object.hasOwn(obj, "address")) // false

3. 两者的区别 

1. 挂载的地方不同

hasOwnProperty : 挂载的地方为Object.prototype上，也就是显示原型

hasOwn : 挂载的地方为构造函数中，也就是类方法，static上

2. 当创建的对象为顶层对象时

// 创建一个顶层对象
// 因为顶层就时null，也就是说，相当于info.__proto__ === null
const info = Object.create(null);
info.name = 'why';

// 可以使用这个，因为是直接使用类方法的
console.log(Object.hasOwn(info, 'name')); // true

// 这个时候，这个对象都不继承自object类，所以根本没有这个方法
console.log(info.hasOwnProperty('name')); // 报错

玄鱼殇
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS 对象
yleave的博客
11-27 337
文章目录对象JS 中，对象的 `key` 都会被转为 `string` 类型。判断对象是否为空1. object.keys()2.将对象转化为json字符串，再判断该字符串是否为"{}"3.for in 循环判断4.Object.getOwnPropertyNames()方法比较对象中的内容是否相同，编写 Object.equals 函数对象的一些方法Object.prototype.hasOwnProperty()Object.defineProperty()Object.entriesObject.as
大白话JS中Object.entires()和Object.assign()的使用
ChuanyangChen的博客
08-11 487
使用场景：需要提取对象形式的键值对数据。
JavaScript操作Object的方法合集
Etc.End的博客
11-28 1230
JavaScript操作Object的方法合集
js Object方法大全
顺其自然~专栏
05-28 1412
Object 静态方法总结 create 创建一个对象 const obj = Object.create({a:1}, {b: {value: 2}}) 第一个参数为对象，对象为函数调用之后返回新对象的原型对象，第二个参数为对象本身的实例方法（默认不能修改,不能枚举） obj.__proto__.a === 1 // true obj.b = 3; console.log(obj.b) // 2 //创建一个可写的,可枚举的,可配置的属性p obj2 = Object.c
js object 常用方法总结
weixin_30443075的博客
01-22 285
Object.assign(target,source1,source2,...) 该方法主要用于对象的合并，将源对象source的所有可枚举属性合并到目标对象target上,此方法只拷贝源对象的自身属性，不拷贝继承的属性。 Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。同名属...
js Object常用方法
zxl1990_ok的博客
04-03 642
这一篇简单介绍es6 Object的新属性方法. is 说明： 用于判断两个值是否是相同的值。 语法： Object.is(value1, value2); 参数： value1，value2分别表示第一个，第二个需要比较的值 返回值： Boolean 表示两个参数是否相同。 ...
JavaScript创建一个object对象并操作对象属性的用法
12-10
本文实例讲述了JavaScript创建一个object对象并操作对象属性的用法。分享给大家供大家参考。具体分析如下： 下面的JS代码创建了一个myMovie对象，并给对象title和director属性赋值，通过Object定义对象，其属性可以...
Javascript 对象（object）合并操作实例分析
12-09
本文实例讲述了Javascript 对象（object）合并操作。分享给大家供大家参考，具体如下： 对象的合并 需求：设有对象 o1 ,o2,需要得到对象 o3 var o1 = { a:'a' }, o2 = { b:'b' }; // 则 var o3 = { a:'a', b:'b' } ...
详解Javascript中的Object对象
10-22
JavaScript中的Object对象提供了丰富的特性，帮助开发者更好地管理和操作对象。理解并熟练运用这些方法和属性，能够提高编写代码的效率和质量，也是成为JavaScript高手的重要一步。在实践中，根据需求选择合适的方法...
JavaScript中的Object对象学习教程
11-25
JavaScript中的Object对象是语言的核心部分，它提供了许多用于操作和管理对象的方法和属性。这篇教程主要探讨了如何使用和理解Object对象。 首先，Object构造函数是创建新对象的关键。当你使用`new Object()`或者...
js中常见的几种对象遍历方式Object
热门推荐
qq_873366938的博客
08-07 2万+
一：自身可枚举属性 Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in 循环遍历该对象时返回的顺序一致 。如果对象的键-值都不可枚举，那么将返回由键组成的数组。 这是合理的，因为大多数时候只需要关注对象自身的属性。 来看看一个对象拥有自身和继承属性的例子，Object.keys()只返回自己的属性键： let s...
JS中Object.entries()方法
qq_42526440的博客
02-27 1315
Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for…in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）。 const object1 = { a: 'somestring', b: 42 }; for (const [key, value] of Object.entries(object1)) { console.log(`${key}: ${value}`); } // expected outpu
JavaScript中的Object.entries（）方法
07-16 1645
We know that everything in JavaScript is an object. It's essential to get the hang of the ways we can play around these objects, traverse them, sort them, access the key-value pairs and values individ...
js中的~~、Object.entires用法（转）
weixin_33895475的博客
06-14 371
传送门：https://www.cnblogs.com/tangjiao/p/9131993.html Object.entries()用法：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/entries 转载于:https://www.cnblogs...
关于JavaScript的Object所有方法
qq_45142260的博客
07-27 3779
关于Javascript的Object的所有方法，最全，最全，最全
JavaScript的对象（object）操作
qq_45799465的博客
01-30 475
创建 构造函数 var 变量 = Object（）； 字面量 var 变量 = {键名：键值 /属性：属性名} ； <script> // 字面量，在{}中定义对象存储的键名键值。 var obj = {name:"张三",sex:'男',age:18}; // 构造函数 var object = Object(); </script> 删除 delete( 对象.属性 ) dele.
JavaScript 日常开发中常用的 Object 操作方法总结
web前端开发
12-14 340
来源 |https://juejin.cn/post/6991335772137734152今天这篇文章，我主要想给大家总结一下我们日常开发中一些常用的Object的操作方法，希望可以对...
ES6，对象的扩展：对象属性名的两种表示方法、属性的枚举和遍历及规则，super关键字，对象的扩展运算符、链判断运算符、Null判断运算符
zz2230633069的博客
09-09 1128
1.属性名的两种表示方法 （1）简洁表示法 ES6 允许在大括号里面，直接写入变量和函数，作为对象的属性和方法。简洁表示法的特点是在对象定义中直接使用变量名。 对于属性：变量foo直接写在大括号里面。这时，属性名就是变量名, 属性值就是变量值。 对于方法：可以省略function关键字，方法名即函数名。 注意，简写的方式不能用作构造函数，会报错。 属性的简写 const foo = 'bar'; const baz = {foo}; // 等同于 const baz = {foo: foo};
js对象和object对象的关系
最新发布
06-07
在 JavaScript 中，对象是一种数据类型，它可以存储键值对（key-value pairs）的集合。JavaScript 中的对象可以通过对象字面量（object literal）语法进行创建，也可以通过 Object 构造函数进行创建。Object 是 JavaScript 中的一个内置对象，它提供了一些方法和属性，可以用来操作和处理对象。因此，可以说 JavaScript 中的对象是基于 Object 的。也就是说，JavaScript 中的对象和 Object 对象是密切相关的，Object 是 JavaScript 中的一个内置对象，用来创建和操作对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值