Object方法讲解

最新推荐文章于 2024-05-15 10:56:58 发布
最新推荐文章于 2024-05-15 10:56:58 发布
阅读量676 收藏
点赞数 1
文章标签： 原型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clytza/article/details/129450096
版权

概述：

Object 这个类是所有类的父类，也就是说它的方法和属性所有的对象都可以使用。Object的相关方法和属性是提供给其他的对象进行使用的。

属性

  • __proto__ ：表示对象的原型指定当前构造函数的原型prototype

console.log({}.__proto__) //指向对应的Object的原型prototype

  • constructor ：表示对象的构造函数

console.log({}.constructor) //指向Object构造函数

原型方法

  • hasOwnProperty ：判断本身是否具备这个属性 不包含原型上的
  • isPrototypeof ：判断当前对象是否存在原型链上
  • propertyIsEnumerable ：判断属性是否枚举
  • toString ：将对象转为字符串
  • toLocalString ：将对象转为本地格式字符串
  • valueOf ：得到本身的值
  • 四个废弃的方法

  • hasOwnProperty （判断本身是否具备这个属性 不包含原型上的） *

//原型添加的属性
Object.prototype.age = 18
//本身的对象
let obj = {
    name:'jack'
    }
obj.sex = '男'
console.log(obj.age) //18 原型上的属性
console.log(obj.name) //本身的属性
//hasOwnProperty 判断对象本身是否具备属性 不包含原型上的属性的
//传入属性名
console.log(obj.hasOwnProperty('name'))//true
console.log(obj.hasOwnProperty('age')) //false
console.log(obj.hasOwnProperty('sex'))//true

  • isPrototypeof 判断当前对象是否存在原型链上 *

class Person{
    constructor(){
        this.name = 'tom'
    }
}
class Child extends Person{
    constructor(){
        super()
        this.age = 19
    }
}
let child = new Child()
let person = new Person()
console.log(child.isPrototypeOf(person))//false child对象是否存在于person的原型链上
console.log(person.isPrototypeOf(child))//false person是否存在于child的原型链上
//判断是否存在原型链上 传入的是对应的对象
console.log(Person.prototype.isPrototypeOf(child)) //true  对应的Person的原型是否存在于child的原型链上
//将对应的child的原型进行赋值
child.__proto__ = person
//isPrototypeOf 传入的是对应查找原型链的对象
console.log(person.isPrototypeOf(child)) //true  person对象是否存在于child的原型链上

  • propertyIsEnumerable 判断属性是否枚举（是否可以被for in遍历）*

//判断是否可以被for in遍历（是否枚举）propertyIsEnumerable
class Animal{
    constructor(){
        this.name = 'dog'
        this.run = ()=>{}
    }
    //不能被枚举的
    eat(){
    }
}
let animal = new Animal()
animal.age = 18 //默认的赋值对应的属性可以被枚举
for(var key in animal){
    console.log(key) //name run age
}
//检索是否可以枚举 （for in只能遍历可以枚举的属性）
console.log(animal.propertyIsEnumerable('run')) //true
console.log(animal.propertyIsEnumerable('name')) //true
console.log(animal.propertyIsEnumerable('age')) //true
console.log(animal.propertyIsEnumerable('eat')) //false

  • toString 将对象转为字符串、toLocalString 将对象转为本地格式字符串

  • valueOf 得到本身的值

        class Animal {
            constructor() {
                    //可枚举
                    this.color = 'pink'
                }
                // 不可枚举 
            Jump() {
                console.log('跳得好高丫');
            }
        }
        class Dog extends Animal {
            constructor() {
                super()
                this.bark = function() {
                    console.log('汪汪');
                }
            }
        }
        let animal = new Animal()
        let dog = new Dog()
        //toString 转为字符串
        console.log(Object.prototype.toString.call(new Animal())); //[object Object]
        console.log(dog.valueOf());

结果：

  • 废弃的四个方法

  • __defineGetter__ ：定义getter函数
  • __defineSetter__ ：定义setter函数
  • __lookUpGetter__ ：返回getter函数
  • __lookUpSetter__ ：返回setter函数
    //废弃的四个方法
        let obj1 = {
            name: 'jack ',
            age: 18
        }
        let _obj = {
            name: 'jack ',
            age: 18
        }
        //__defineGetter__ __defineSetter__ 定义getter和setter方法
        //传递的属性名 和对应的处理函数
        obj1.__defineGetter__('name', () => {
            console.log('执行了')
            return _obj.name //getter不允许调用自身
        })
        obj1.__defineSetter__('age', (value) => {
            // obj1.age = value 报错 栈溢出
            _obj.age = value
        })
        console.log(obj1.name) //访问getter 获取getter中的返回值
        obj1.age = 30 //调用setter方法
        //__lookupGetter__ __lookupSetter__ 返回对应的getter方法和setter方法
        console.log(obj1.__lookupGetter__('name'))
        console.log(obj1.__lookupSetter__('age'))

结果：

静态方法

  • Object.assign ：浅拷贝对象
  • Object.create ：创建一个对象
  • Object.keys ：返回对象所有的key组成的数组
  • Object.values ：返回对象所有的value组成的数组
  • Object.entries ：返回对象所有的键值对组成的数组
  • Object.is ：判断俩个对象是否一致
  • Object.getPrototypeOf ：获取原型
  • Object.setPrototypeOf ：设置原型

  • Object.assign 将传入的对象的内容填入第一个传入的对象内容内，返回的是第一个对象 *

        //里面可以传入任意对象 将对应的后面的参数的内容填入到第一个对象中 返回第一个对象
        let first = {
            name: 'jack ',
            likes: ['苹果']
        }
        let object = Object.assign(first, {
            age: 18
        }, {
            sex: '男'
        })
        console.log(object) //{name:'jack',age:18,sex:'男'}
        console.log(first == object) //true
        console.log(first)
        //object.assign 可以完成对象的浅拷贝（拷贝第一层值 深层拷贝地址 产生新的对象）
        let copyObj = Object.assign({}, first)
        console.log(copyObj == first) //false
        //第二层拷贝地址 copyObj的likes对应的地址 和 first的likes的地址是一样的
        console.log(copyObj.likes == first.likes) //true

  • Object.create 创建一个对象 *

        //根据传入的内容来创建对应的内容
        let first1 = {
            name: 'jack '
        }
        //create它是将对应的传入的对象放入创建对象的原型上
        let newObj = Object.create(first1) //根据传入的first来创建新的对象
        console.log(newObj)
        let obj = create(first1)
        console.log(obj)
            //简单实现一下Object的create方法
        function create(obj) {
            //创建一个新的对象
            let newObj = {}
                //将传入的对象放入新的对象的原型上
            newObj.__proto__ = obj
                //返回这个新的对象
            return newObj
        }

  • Object.keys 返回对象所有的key组成的数组

  • Object.values 返回对象所有的value组成的数组

  • Object.entries 返回对象所有的键值对组成的数组

        let obj = {
            name: ' hello ',
            age: '17 '
        }
        class Person {
            constructor() {}
                //不可枚举的
            eat() {}
        }
        //原型上的属性
        Person.prototype.age = 18
        //返回都是数组
        console.log(Object.keys(obj)) //所有key的数组
        console.log(Object.values(obj)) //value的数组
        console.log(Object.entries(obj)) //所有的键值对 组成的二维数组
        //Object.keys不包含不可枚举的属性 也不包含原型上的属性
        let person = new Person()
        console.log(Object.keys(person))
        //for in不包含不可枚举的属性 包含原型上的属性
        for (var key in person) {
            console.log(key)
        }

  • Object.is 判断俩个对象是否一致

//Object.is判断两个对象是否一致

        let first = { }

        let last = { }

        console.log ( Object . is( first , last ) ); //false

  • Object.getPrototypeOf 获取原型

  • Object.setPrototypeOf 设置原型

        function Person() {}
        Person.prototype.age = 19
        let person = new Person()
        console.log(Object.getPrototypeOf(person)); //{age: 19, constructor: ƒ}
        let obj = {
                name: 'jack'
            }
            //将obj做为person的原理
        Object.setPrototypeOf(person, obj)
        console.log(obj.isPrototypeOf(person)); //true
        console.log(person); //Person {}

对象相关操作限制的方法 *

  • preventExtensions 不可扩展 ：不能进行内容添加 （判断是否可扩展 isExtensible）
  • seal 密封 ：只能查询和修改，其他操作不允许（判断是否密封 isSealed ）
  • freeze 冻结 ：只能查询（isFrozen 判断是否冻结）
        //查询都能做的 不然的话对应的对象创建就没有意义
        let obj = {
                name: 'jack '
            }
            //不可扩展 返回当前的对象
        Object.preventExtensions(obj)
            //检测是否可以扩展
        console.log(Object.isExtensible(obj)) //false
            //添加新的属性
        obj.age = 18 //无效
        obj.name = 'tom' //改
        console.log('name' in obj) //查询
        delete obj.name //删除
        console.log(obj)
            //密封 修改和查询其他操作都不允许
        let obj1 = {
                name: 'jack '
            }
            //使用对象密封
        Object.seal(obj1)
            //密封会导致不可扩展
        console.log(Object.isExtensible(obj1)) //false
            //判断是否密封
        console.log(Object.isSealed(obj1)) //true
        obj1.age = 18 //无效
        obj1.name = 'tom' //改
        console.log('name' in obj1) //查询
        delete obj1.name //无效
        console.log(obj1)
            //冻结 只能查询
        let obj2 = {
                name: 'jack '
            }
            //冻结对象 只能执行查询操作
        Object.freeze(obj2)
            //冻结会导致密封
        console.log(Object.isSealed(obj2)) //true
            //判断是否冻结
        console.log(Object.isFrozen(obj2)) //true
        obj2.age = 18 //无效
        obj2.name = 'tom' //无效
        console.log('name' in obj2) //查询
        delete obj2.name //无效
        console.log(obj2)

属性相关的获取方法 *

  • Object.getOwnPropertyNames （获取对象上的所有属性名 ，不包含symbol修饰和原型上的）
  • Object.getOwnPropertySymbols （获取对象上名字为symbol的属性名，不包含原型上的）
  • Object.getOwnPropertyDescriptor （获取对应的属性的详情对象 ，不包含原型上的）
  • Object.getOwnPropertyDescriptors （获取所有的属性的详情对象 ，不包含原型上的）
        function Person() {
            this.name = 'jack'
        }
        Person.prototype.age = 18
        Person.prototype[Symbol('原型上的')] = 'hello'
        let person = new Person()
        person[Symbol('对象中的')] = 'world'
        person.sex = '男'
        let names = Object.getOwnPropertyNames(person)
        console.log(names); //['name', 'sex']
        let symbols = Object.getOwnPropertySymbols(person)
        console.log(symbols); //[Symbol(对象中的)]
        let descriptor = Object.getOwnPropertyDescriptor(person, 'name')
        console.log(descriptor); 
        //{value: 'jack', writable: true, enumerable: true, configurable: true}
        let descriptors = Object.getOwnPropertyDescriptors(person)
        console.log(descriptors); //{name: {…}, sex: {…}, Symbol(对象中的): {…}}

 属性对象 （descriptor 对象）

【属性属性】

  • configable 是否可以删除
  • enumerable 是否可以枚举
  • value 值
  • writable 是否可以修改

【性访问器属】

  • configable 是否可以删除
  • enumerable 是否可以枚举
  • get 相当于getter方法，访问的时候调用
  • set 相当于setter方法，设置的时候调用

Object.defineProperty 用于定义对象的属性 （vue2的底层实现）*

实现数据驱动，也就是数据劫持（vue2中用于双向数据绑定）

        let obj = {}
            //传入对象，传入属性，传入属性对象
        Object.defineProperty(obj, 'name', {
            configurable: false, //无法删除
            enumerable: false, //无法枚举、遍历
            value: 'tom',
            writable: false //无法修改
        })
        console.log(obj); //{name: 'tom'}
        obj.name = 'mary'
        for (var key in obj) {
            console.log(key);
        }
        delete obj.name
        console.log(obj); //{name: 'tom'}
        //访问器属性方法,利用数据来驱动页面变化
        let _obj = {}
        Object.defineProperty(obj, 'age', {
            configurable: false, //无法删除
            enumerable: false, //无法枚举、遍历
            get() {
                console.log(1);
                return _obj.age
            },
            set(value) {
                //先调用set
                console.log(2);
                _obj.age = value
            }
        })
        obj.age = 11
        console.log(obj);

Object.defineProperties 用于定义对象的多个属性 *

        let obj1 = {}
        let _obj1 = {}
        Object.defineProperties(obj1, {
            name: {
                value: '蜡笔小新',
                configurable: false, //无法删除
                enumerable: false, //无法枚举、遍历
                writable: false //无法修改
            },
            age: {
                onfigurable: false, //无法删除
                enumerable: false, //无法枚举、遍历
                get() {
                    console.log(1);
                    return _obj1.age
                },
                set(value) {
                    //先调用set
                    console.log(2);
                    _obj1.age = value
                }
            }
        })
        obj1.age = 55
        console.log(obj1);

面试题

for in 和 Object.keys 和 Object.getOwnPropertyNames的区别

  • for in 包含继承的属性及自身的属性 （不包含不可枚举的、symbol修饰的，包含原型上的和继承的属性）
  • Object.keys 只包含自身的属性 （不包含继承、不可枚举、symbol修饰的、原型上的属性）
  • Object.getOwnPropertyNames 只包含自身的属性 （不包含继承、原型上和symbol修饰的，包含不可枚举的）
  • 三个内容都不包含symbol的属性
东日是个卷毛
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ES6中部分数组的新增方法和对象的新增方法
云朵朵๑的博客
08-20 1056
一些ES6中部分数组的新增方法和对象的新增方法的简单介绍 Array.of()方法用于将一组数值转为数组，并且弥补了ES5中的Array()的不足，Array()传入参数小于2时，返回的结果是不同的，而Array.of()就完美解决了这个问题。代码如下： 3.数组实例的方法 3.1 find() find()方法用于找出数组中第一个符合的成员，和indexOf()类似，但是它得到的是成员和undefined，而不是下标和-1；fi
Object类的九个方法
wyyblog
08-14 2229
在java里面所有的对象都会继承Object类 1. clone 方法 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用此方法，否则抛出CloneNotSupportedException异常。 2. getClass方法 final方法，获得运行时的类型 3. toString方法 该方法使用的比较多，一般子类都有覆盖 4. finaliz...
浅谈 JS 中的相等运算
小天才程序员的博客乐园
10-04 8643
JavaScript中===和==的区别和一些需要注意的陷阱。
Python内置函数object()详解
最新发布
嘻嘻爱编码的博客
05-15 489
Python内置函数object()详解
J S中Object构造函数
追梦者的博客
08-03 531
Object.assign() 通过复制一个或多个对象来创建一个新的对象。 Object.create() 使用指定的原型对象和属性创建一个新对象。 Object.defineProperty() 给对象添加一个属性并指定该属性的配置。 Object.defineProperties() 给对象添加多个属性并分别指定它们的配置。 Object.entries() 返回给定对象自身可枚举属性的[key, value]数组。 Object.freeze() 冻结对象：其他代码不能删除或更改任何属性。 Objec
Object常用方法
福小娟儿的博客
03-30 2540
1、Object.getPrototypeOf() 返回参数对象上的原型，获取原型对象的标准方法。 三种特殊原型 2、Object.setPrototypeOf() 为参数对象设置原型并返回改参数对象，它接收两个参数 第一个是现有对象 第二个实原型对象 new命令可以用Object.setPrototypeOf()进行模拟 3、Object.create() 该方法生成的对象继承了它的原型对象的构造函数 语法 Object.create(Object,{item1,item2}) 其中Objec
JS学习笔记——Object.is到底是何物
MRlaochen的博客
07-07 2253
Object.is() 方法确定两个值是否是相同的值。 1、Object.is的背景 ES5比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。他们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。JavaScript缺乏一种运算，在所有环境中，只要两个值是一样的，他们就应该相等。 ES6提出“Same-value equality”（同值相等）算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较
Python object类中的特殊方法代码讲解
12-20
在Python 3.8版本中，`object`类包含了一些特殊的方法，这些方法通常用于控制对象的行为，比如访问属性、比较、格式化以及创建新实例等。下面是对这些特殊方法的详细解释： 1. `__delattr__(self, *args, **kwargs)...
Active Object技术讲解
03-01
Active Object技术讲解
Tutorial06object
10-05
在软件开发中，尤其是面向对象编程（Object-Oriented Programming, OOP）中，对象是程序的基本构建块，它封装了数据和操作这些数据的方法。本教程可能深入讲解如何在编程语言中创建、定义和使用对象。 【描述】虽然...
（21）es6——Object原型新增方法is,assign,getPrototypeof,setPrototypeof和es10新增方法fromEntries
浪头的博客
04-24 327
is Object.is 比较两个数是否相等 可以用来判断一个值是不是NaN console.log(Object.is(100,100));//true console.log(Object.is(NaN,NaN));//true console.log(NaN === NaN);//false,NaN使用===和任何比较都是false assign 合并对象 const obj1 = { a:1, b:2, c:3 } const obj2 = { a:2, b:3, d:4 }
Object.freeze()
weixin_39593900的博客
02-22 508
本文转载自https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性...
Object的方法有哪些
冯小石
12-15 3278
Java中的超类Object，都包含哪些方法，都是用来做什么的，用处和关联。
【深入理解ES6】对象
wgf1997的博客
03-27 1389
对象的分类 普通对象（Ordinary Object）：具备Javascript 对象所有的默认内部行为。 特异对象（Exotic Object）：具备某些与默认行为不符的内部行为。 标准对象（Standard Object）：ES6中定义的对象，例如 Array、Date 等。既可以是普通对象，又可以是特异对象 内置对象(Build-in Object)：JS脚本中的环境对象（window、document等） 对象字面量的扩充 属性初始值简写 // ES5 function create.
Object以及四种对象函数创建
ZhouXiongLan的博客
03-27 623
对象：object; 什么叫做对象： 在程序中，对象就是我们所需要描述目标以及所需要使用任何一种方法，数据或者是某一种数据的属性 对象的作用：1，可以直接实现对需要重复使用的代码进行一个封装；实现对代码的利用效率； 2，减少了开发人员书写代码的工作量 3，减少对于程序的维护成本； 对象的基本语法：{} var obj={};直接量创建原始对象； 对象里面的组成部分：1，对象的属性；2，对象方法； ...
Object类方法解析
wjl62135246的博客
02-23 153
Object类方法解析
WaitForSingleObject函数用法
热门推荐
心情第一
06-05 3万+
用户模式的线程同步机制效率高，如果需要考虑线程同步问题，应该首先考虑用户模式的线程同步方法。 　　但是，用户模式的线程同步有限制，对于多个进程之间的线程同步，用户模式的线程同步方法无能为力。这时，只能考虑使用内核模式。 　　Windows提供了许多内核对象来实现线程的同步。对于线程同步而言，这些内核对象有两个非常重要的状态：“已通知”状态，“未通知”状态（也有翻译为：受信状态，未受信状态）。Wi...
Page Object具体讲解
06-10
Page Object 是一种设计模式，用于测试自动化中的 Web 应用程序。它将页面的逻辑和测试用例分离开来，使测试代码更加简洁、可读和易于维护。 Page Object 模式基于以下两个原则： 1. 页面对象应该封装页面的逻辑，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值