JS对象中常见的操作方法，2024年最新滴滴前端三面问什么

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

五、作为函数参数

---

const displayPerson = (person) => {

console.log(name: ${person.name || '无名氏'})

console.log(age: ${person['age'] || 0})

}

displayPerson({ name: ‘dengke’, age: 18 })

// name: dengke

// age: 18

displayPerson({ })

// name: 无名氏

// age: 0

复制代码

六、枚举对象的属性

---

在JS里面枚举对象属性一共有三种方法：

1. for in: 会遍历对象中所有的可枚举属性（包括自有属性和继承属性）

2. Object.keys(): 会返回一个包括所有的可枚举的自有属性的名称组成的数组

3. Object.getOwnPropertyNames(): 会返回自有属性的名称 （不管是不是可枚举的）

1. for...in 会遍历对象中所有的可枚举属性（包括自有属性和继承属性）

const obj = {

itemA: ‘itemA’,

itemB: ‘itemB’

}

// 使用Object.create创建一个原型为obj的对象 （模拟继承来的属性）

var newObj = Object.create(obj)

newObj.newItemA = ‘newItemA’

newObj.newItemB = ‘newItemB’

for(i in newObj){

console.log(i)

}

// newItemA

// newItemB

// itemA

// itemB

// 现在我们将其中的一个属性变为不可枚举属性

Object.defineProperty(newObj, ‘newItemA’, {

enumerable: false

})

for(i in newObj){

console.log(i)

}

// newItemB

// itemA

// itemB

复制代码

补充

如果不想让for...in枚举继承来的属性可以借助Object.prototype.hasOwnProperty()

// 接上例

for(i in newObj){

if( newObj.hasOwnProperty(i) ) console.log(i)

}

// newItemB

复制代码

Object.prototype.hasOwnProperty()该方法在下文有更具体的介绍

2. Object.keys(): 会返回一个包括所有的可枚举的自有属性的名称组成的数组

// 接上例

const result = Object.keys(newObj)

console.log(result) // [“newItemB”]

复制代码

Object.keys()该方法在下文有更具体的介绍

3. Object.getOwnPropertyNames() 会返回自有属性的名称 （不管是不是可枚举的）

// 接上例

const result = Object.keys(newObj)

console.log(result) // [‘newItemA’,‘newItemB’]

复制代码

Object.getOwnPropertyNames()该方法在下文有更具体的介绍

七、数据类型检测

---

• typeof 常用 多用于原始数据类型的判断

const fn = function(n){

console.log(n)

}

const str = ‘string’

const arr = [1,2,3]

const obj = {

a:123,

b:456

}

const num = 1

const b = true

const n = null

const u = undefined

console.log(typeof str) // string

console.log(typeof arr) // object

console.log(typeof obj) // object

console.log(typeof num) // number

console.log(typeof b) // boolean

console.log(typeof n) // object null是一个空的对象

console.log(typeof u) // undefined

console.log(typeof fn) // function

复制代码

通过上面的检测我们发现typeof检测的Array和Object的返回类型都是Object，因此用typeof是无法检测出来数组和对象的。

• tostring 常用 最实用的检测各种类型

我们经常会把这个封装成一个函数，使用起来更加方便

/**

* @description: 数据类型的检测

* @param {any} data 要检测数据类型的变量

* @return {string} type 返回具体的类型名称【小写】

*/

const isTypeOf = (data) => {

return Object.prototype.toString.call(data).replace(/[object (\w+)]/, ‘$1’).toLowerCase()

}

console.log(isTypeOf({})) // object

console.log(isTypeOf([])) // array

console.log(isTypeOf(“ss”)) // string

console.log(isTypeOf(1)) // number

console.log(isTypeOf(false)) // boolean

console.log(isTypeOf(/w+/)) // regexp

console.log(isTypeOf(null)) // null

console.log(isTypeOf(undefined)) // undefined

console.log(isTypeOf(Symbol(“id”))) // symbol

console.log(isTypeOf(() => { })) // function

复制代码

八、Object常用的API

---

1. Object.assign()

Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象分配到目标对象。它将返回目标对象。常用来合并对象。

const obj1 = { a: 1, b: 2 }

const obj2 = { b: 4, c: 5 }

const obj3 = Object.assign(obj1, obj2)

const obj4 = Object.assign({}, obj1) // 克隆了obj1对象

console.log(obj1) // { a: 1, b: 4, c: 5 } 对同名属性b进行了替换 obj1发生改变是因为obj2赋给了obj1

console.log(obj2) // { b: 4, c: 5 }

console.log(obj3) // { a: 1, b: 4, c: 5 }

console.log(obj4) // { a: 1, b: 4, c: 5 }

复制代码

语法

Object.assign(target, …sources)

复制代码

• 参数：target 目标参数，sources源对象

• 返回值：目标对象

注意

• 如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。

• Object.assign 方法只会拷贝源对象自身的并且可枚举的属性到目标对象。

• assign其实是浅拷贝而不是深拷贝

也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。同名属性会替换。

const obj5 = {

name: ‘dengke’,

a: 10,

fn: {

sum: 10

}

}

const obj6 = Object.assign(obj1, obj5)

console.log(obj6) // { a: 10, b: 2, name: ‘dengke’, fn: {…}}

console.log(obj1) // {a: 10, b: 2, name: ‘dengke’, fn: {…}} 对同名属性a进行了替换

复制代码

• Object.assign 不会在那些source对象值为null或undefined的时候抛出错误。

2. Object.keys()

上边枚举对象属性时有用到了Object.keys()，在这里就具体为大家介绍一下它。

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致。与Object.values()相似，区别在于这个返回的是数据的属性就是key。接下来就会介绍Object.values()，不要着急。???

const arr = [‘a’, ‘b’, ‘c’]

console.log(Object.keys(arr)) // [‘0’, ‘1’, ‘2’]

const obj = { 0: ‘a’, 1: ‘b’, 2: ‘c’ }

console.log(Object.keys(obj)) // [‘0’, ‘1’, ‘2’]

const obj2 = { 100: ‘a’, 2: ‘b’, 7: ‘c’ }

console.log(Object.keys(obj2)) // [‘2’, ‘7’, ‘100’]

复制代码

语法

Object.keys(obj)

复制代码

• 参数：obj要返回其枚举自身属性的对象。

• 返回值：一个表示给定对象的所有可枚举属性的字符串数组。

注意

• 在ES5里，如果此方法的参数不是对象（而是一个原始值），那么它会抛出 TypeError。在ES2015中，非对象的参数将被强制转换为一个对象。

Object.keys(“foo”) // TypeError: “foo” is not an object       (ES5 code)

Object.keys(“foo”) // [“0”, “1”, “2”]                         (ES2015 code)

复制代码

3. Object.values()

Object.values() 方法返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。与Object.keys()相似，区别在于这个返回的是数据的值也就是value

const obj1 = { foo: ‘bar’, baz: 42 }

console.log(Object.values(obj1)) // [‘bar’, 42]

const obj2 = { 0: ‘a’, 1: ‘b’, 2: ‘c’ }

console.log(Object.values(obj2)) // [‘a’, ‘b’, ‘c’]

复制代码

语法

Object.values(obj)

复制代码

• 参数：obj被返回可枚举属性值的对象。

• 返回值：一个包含对象自身的所有可枚举属性值的数组。

注意

• 对象key为number的话，会从升序枚举返回。

const obj3 = { 100: ‘a’, 2: ‘b’, 7: ‘c’ }

console.log(Object.values(obj3)) // [‘b’, ‘c’, ‘a’]

复制代码

4. Object.entries(obj)

Object.entries() 方法返回一个给定对象自身可枚举属性的键值对数组。可使用Object.fromEntries()方法，相当于反转了Object.entries()方法返回的数据结构。接下来也会介绍Object.fromEntries()

const obj1 = {

name: ‘dengke’,

age: 18

};

for (const [key, value] of Object.entries(obj1)) {

console.log(${key}: ${value});

}

// “name: dengke”

// “age: 18”

const obj2 = { foo: ‘bar’, baz: 42 }

console.log(Object.entries(obj2)) // [ [‘foo’, ‘bar’], [‘baz’, 42] ]

const obj3 = { 0: ‘a’, 1: ‘b’, 2: ‘c’ }

console.log(Object.entries(obj3)) // [ [‘0’, ‘a’], [‘1’, ‘b’], [‘2’, ‘c’] ]

复制代码

语法

Object.entries(obj)

复制代码

• 参数：obj可以返回其可枚举属性的键值对的对象。

• 返回值：给定对象自身可枚举属性的键值对数组。

补充

• 将Object转换为Map，new Map()构造函数接受一个可迭代的entries。借助Object.entries方法你可以很容易的将Object转换为Map:

const obj = { foo: “bar”, baz: 42 }

const map = new Map(Object.entries(obj))

console.log(map) // Map { foo: “bar”, baz: 42 }

复制代码

5. Object.fromEntries()

Object.fromEntries() 方法把键值对列表转换为一个对象。与Object.entries()相反。相当于反转了Object.entries()方法返回的数据结构。（下面补充里有具体的演示）

const entries = new Map([

[‘foo’, ‘bar’],

[‘baz’, 42]

]);

const obj = Object.fromEntries(entries);

console.log(obj);

// Object { foo: “bar”, baz: 42 }

复制代码

语法

Object.fromEntries(iterable)

复制代码

• 参数：iterable类似Array、Map或者其它实现了可迭代协议的可迭代对象。

• 返回值：一个由该迭代对象条目提供对应属性的新对象。

补充

• Map 转化为 Object

通过 Object.fromEntries， 可以将Map转换为Object:

const map = new Map([ [‘foo’, ‘bar’], [‘baz’, 42] ])

const obj = Object.fromEntries(map)

console.log(obj)

// { foo: “bar”, baz: 42 }

复制代码

• Array 转化为 Object

通过 Object.fromEntries， 可以将Array转换为Object:

const arr = [ [‘0’, ‘a’], [‘1’, ‘b’], [‘2’, ‘c’] ]

const obj = Object.fromEntries(arr)

console.log(obj)

// { 0: “a”, 1: “b”, 2: “c” }

复制代码

• 对象转换

Object.fromEntries 是与 Object.entries()相反的方法，用 数组处理函数 可以像下面这样转换对象：

const object1 = { a: 1, b: 2, c: 3 }

const object2 = Object.fromEntries(

Object.entries(object1)

.map(([ key, val ]) => [ key, val * 2 ])

)

// Object.entries(object1) >>> [[“a”,1],[“b”,2],[“c”,3]]

console.log(object2) // { a: 2, b: 4, c: 6 }

复制代码

6. Object.prototype.hasOwnProperty()

上边枚举对象属性时为了避免for..in遍历继承来的属性，给大家补充了可以借助Object.prototype.hasOwnProperty()方法进行判断，在这里也具体为大家介绍一下它。

hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。

const obj1 = {};

obj1.property1 = 42

console.log(obj1.hasOwnProperty(‘property1’)) // true

console.log(obj1.hasOwnProperty(‘toString’)) // false

console.log(obj1.hasOwnProperty(‘hasOwnProperty’)) // false

复制代码

语法

obj.hasOwnProperty(prop)

复制代码

• 参数：prop 要检测的属性的String字符串形式表示的名称，或者Symbol。

• 返回值：用来判断某个对象是否含有指定的属性的布尔值Boolean。

注意

• 只会对自身属性进行判断，继承来的一律返回false。配合for...in使用，可以避免其遍历继承来的属性。

const o = new Object()

o.prop = ‘exists’

console.log(o.hasOwnProperty(‘prop’)) // true

console.log(o.hasOwnProperty(‘toString’)) // false

console.log(o.hasOwnProperty(‘hasOwnProperty’)) // false

复制代码

• 即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true。

const o = new Object();

o.propOne = null

o.propTwo = undefined

console.log(o.hasOwnProperty(‘propOne’)) // true

console.log(o.hasOwnProperty(‘propTwo’)) // true

复制代码

7. Object.getOwnPropertyNames()

上边枚举对象属性时也有用到该方法，在这里也具体为大家介绍一下它。

Object.getOwnPropertyNames() 返回一个数组，该数组对元素是 obj自身拥有的枚举或不可枚举属性名称字符串。数组中枚举属性的顺序与通过for...in循环Object.keys迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

const arr = [“a”, “b”, “c”];

console.log(Object.getOwnPropertyNames(arr).sort()) // [“0”, “1”, “2”, “length”]

// 类数组对象

const obj = { 0: “a”, 1: “b”, 2: “c”};

console.log(Object.getOwnPropertyNames(obj).sort()) // [“0”, “1”, “2”]

// 使用Array.forEach输出属性名和属性值

Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {

console.log(val + " -> " + obj[val]);

})

// 0 -> a

// 1 -> b

// 2 -> c

// 不可枚举属性

const my_obj = Object.create({}, {

getFoo: {

value: function() { return this.foo; },

enumerable: false

}

});

my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort())

// [“foo”, “getFoo”]

复制代码

语法

obj.getOwnPropertyNames(obj)

复制代码

-参数：obj一个对象，其自身的可枚举和不可枚举属性的名称被返回。

• 返回值：在给定对象上找到的自身属性对应的字符串数组。

补充

• Object.getOwnPropertyNames和Object.keys的区别：Object.keys只适用于可枚举的属性，而Object.getOwnPropertyNames返回对象的全部属性名称(包括不可枚举的)。

‘use strict’

(function () {

// 人类的构造函数

const person = function (name, age, sex) {

this.name = name

this.age = age

this.sex = sex

this.sing = () => {

console.log(‘sing’);

}

}

最后

好了，这就是整理的前端从入门到放弃的学习笔记，还有很多没有整理到，我也算是边学边去整理，后续还会慢慢完善，这些相信够你学一阵子了。

做程序员，做前端工程师，真的是一个学习就会有回报的职业，不看出身高低，不看学历强弱，只要你的技术达到应有的水准，就能够得到对应的回报。

学习从来没有一蹴而就，都是持之以恒的，正所谓活到老学到老，真正懂得学习的人，才不会被这个时代的洪流所淘汰。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
.create({}, {

getFoo: {

value: function() { return this.foo; },

enumerable: false

}

});

my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort())

// [“foo”, “getFoo”]

复制代码

语法

obj.getOwnPropertyNames(obj)

复制代码

-参数：obj一个对象，其自身的可枚举和不可枚举属性的名称被返回。

• 返回值：在给定对象上找到的自身属性对应的字符串数组。

补充

• Object.getOwnPropertyNames和Object.keys的区别：Object.keys只适用于可枚举的属性，而Object.getOwnPropertyNames返回对象的全部属性名称(包括不可枚举的)。

‘use strict’

(function () {

// 人类的构造函数

const person = function (name, age, sex) {

this.name = name

this.age = age

this.sex = sex

this.sing = () => {

console.log(‘sing’);

}

}

最后

好了，这就是整理的前端从入门到放弃的学习笔记，还有很多没有整理到，我也算是边学边去整理，后续还会慢慢完善，这些相信够你学一阵子了。

做程序员，做前端工程师，真的是一个学习就会有回报的职业，不看出身高低，不看学历强弱，只要你的技术达到应有的水准，就能够得到对应的回报。

学习从来没有一蹴而就，都是持之以恒的，正所谓活到老学到老，真正懂得学习的人，才不会被这个时代的洪流所淘汰。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）
[外链图片转存中…(img-lA254BAO-1713319709195)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！