object.keys()

• 返回值：該方法返回一個數(shù)組
• 該數(shù)組包含給對象的自身可枚舉屬性名
  • 自身屬性：直接定義在對象上的屬性就是自身屬性。與繼承屬性相對應(yīng)。
  • 可枚舉屬性：字面量法創(chuàng)建的對象屬性都是可枚舉的
    語法

Object.keys(對象名)

key是什么

• key：是屬性名

object.values()

• 該方法返回一個數(shù)組
• 該數(shù)組包含給對象的自身可枚舉屬性值

//Object.values()
const obj = {
x:1,
y:2
}
obj.o = 5
obj.__proto__.z = 3
Object.getPrototypeOf(obj).w = 4
const arr = Object.values(obj)
console.log(arr);

object.entries()

• 該方法返回一個數(shù)組
• 該數(shù)組包含給對象的自身可枚舉屬性名和屬性值
• 自身屬性：直接定義在對象上的屬性就是自身屬性。與繼承屬性相對應(yīng)。
• 可枚舉屬性：字面量法創(chuàng)建的對象屬性都是可枚舉的

屬性的檢測

1.如何檢測一個屬性是否是自身屬性
2.如何檢測一個屬性是否可枚舉

        const obj = {
            x:1,
            y:2
        }
        obj.o = 5
        obj.__proto__.z = 3
        console.log(obj.__proto__)
        Object.getPrototypeOf(obj).w = 4

object-hasownproperty()

定義：檢測一個屬性是否是自身屬性
返回值：布爾值

• true：表示該屬性是對象的自身屬性
• false：表示該屬性
  語法

obj-hasownproperty(prop)
obj.hasOwnProperty(屬性名)

示例

//Object.hasOwnProperty()檢查的?個屬性是否是?身屬性
const obj = {
x:1,
y:2
}
obj.o = 5
obj.__proto__.z = 3
Object.getPrototypeOf(obj).w = 4
//語法：對象.hasOwnProperty(屬性名)
const r1 = obj.hasOwnProperty('o')//true
const r2 = obj.hasOwnProperty('w')//false
console.log(r1,r2);

Object.prototype.propertyIsEnumerable()

定義：該方法用于檢測自身屬性是否可枚舉。
返回值：布爾值

• true
• false
  語法：

obj.propertyIsEnumerable(prop)

示例：

//obj.propertyIsEnumerable(prop)
const obj = {
x:1,
y:2,
z:3,
}
//請把y改成不可枚舉 > 修改enumerable屬性 > Object.defineProperty()
Object.defineProperty(obj,'y',{
enumerable:false
})
const r1 = obj.propertyIsEnumerable('x')
const r2 = obj.propertyIsEnumerable('y')
console.log(r1,r2);

Object.assign()

定義：Object.assign()方法將所有可枚舉屬性從一個對象復制到另一個對象。
返回值：修改后的對象。
語法：

Object.assign(obj1,obj2)

• obj1：目標對象
• obj2：原對象

const obj1 = {x:1, y:5}
const obj2 = {y:2, z:3}
obj2.__proto__.w = 4
object.assign(obj1,obj2)
console.log(obj1) //輸出{x:1,y:2,z:3}

數(shù)據(jù)類型

Symbol是一種基本數(shù)據(jù)類型

• Symbol是原始值

Biglnt

Biglnt表示任意大的整數(shù)。
定義：

• Biglnt是一種內(nèi)置函數(shù)
• 表示所有的整數(shù)
• 不支持new調(diào)用
  返回值：返回一個bigint類型的整數(shù)
  語法：

//字面量法定義bigint
const bi1 = 10000000n
//不能定義小數(shù)

//內(nèi)置函數(shù)法
const bi2 = BigInt(1000000);1000000n
const bi2 = BigInt('1000000');//1000000n

?法

• 1.symbol之間可以做運算
• 2.不可以使?math?法
• 3. 不能和number混合運算
• 4.bigint可以和number做?較
  示例：

        //BigInt表示任意大的整數(shù)
        const b1 = 10n
        const b2 = BigInt(20)

        console.log(b1)
        console.log(b2)
        console.log(b1 + b2)
        console.log(typeof b1)
        //console.log(Math.abs(b1)) //不可以使用Math方法
        //console.log(b2 + 20) //不能和number運行
        console.log(20n === 20)
        console.log(20n == 20) //bigint可以和number做比較

        const bi1 = BigInt(100n)
        const bi2 = BigInt(100)
        const bi3 = BigInt(100n)
        const bi4 = BigInt('100')

Symbol

• Symbol是?種基本數(shù)據(jù)類型
• Symbol是原始值

//1. Number(任意)=>原始值 2. new Number(任意)=>對象
const n1 = Number(100)
const n111 = Number(100)
console.log(n1=== n111);//
// const n2 = Number()
// console.log(n2);
// const n3 = Number(Infinity)
// console.log(n3);
// const n4 = Number(NaN)
// console.log(n4);
// const n5 = Number('100')
// console.log(n5);
// const n6 = Number('abc')
// console.log(n6);
// const n7 = Number({x:1})
// console.log(n7);
// const n8 = Number([])
// console.log(n8);
//1.String(任意) =>原始值 2.new String(任意) =>對象
const str1 = String('hello')
const str2 = String('hello')
console.log(str1 === str2);//true
//Symbol(字符串) 返回?個具有唯?性的標識符
const sym1 = Symbol()
const sym2 = Symbol()
console.log(sym1 === sym2);//false
// const sym3 = new Symbol() //報錯
const sym3 = Symbol()
const sym4 = Symbol()
const obj = {
x:1,
y:10,
 [sym3]: 'hello',
 [sym4]: 'world'
}
console.log(obj[sym3]);
console.log(obj[sym4]);

對象的拷貝

示例：把obj2的屬性復制到obj1里面

const obj1 = {x:1}
const obj2 = {y:2,z:3}
for(key of Object.keys(obj2)){
  obj1[key] = obj2[key]
}

console.log(obj1) //輸出{x:1,y:2,z:3}

什么是?身屬性和繼承屬性?

• 定義在對象原型上的屬性是繼承屬性
• 直接定義在對象上的屬性是?身屬性

如何為字面量對象的原型添加屬性

• proto
• Object.getPrototypeOf()