对象 Object

对象是一些相互关联的数据和功能(通常由若干变量和函数组成，被称为对象的属性和方法)的集合。

{  

属性名:属性值

  方法名:函数

}

声明对象

let ljh={

        name:{zh:'猥琐下',en :'wsx'},

        height:179,

        slzm :['是是是','对对对','说的都对','没错没错'],

}

声明包含属性和方法的数组

let babies=[{ name:{ zh:'周小凌', en:'Hathaway'}, gender:'女'}]    //声明一个对象数组

let 宝贝=[{ 名字:{ 中文:'周小凌', 英文:'Hathaway'}, 性别:'女'}]

let  jay={  name:{ zh:'周杰伦', en:'Jay'},

 height:175,  

children:babies,                                                                    //引用babies 对象数组

songs:['星晴','双节棍','七里香','简单爱','青花瓷','告白气球'],  

company:{ name:'杰威尔音乐有限公司', location:'台北', year:{ founded:2007} },

like() {return'哎哟，不错哦！'},                //   方法

intro:function(lang='zh') {

returnlang==='zh'?`大家好，我是${this.name.zh}。`:`Hi, I'm${this.name.en}.`}

}

const 周杰伦={  名字:{ 中文:'周杰伦', 英文:'Jay'},
身高:175, 
子女:宝贝, 
作品:['星晴','双节棍','七里香','简单爱','青花瓷','告白气球'], 
公司:{ 名字:'杰威尔音乐有限公司', 所在地:'台北', 创办年份:2007}, 
点赞() {return'哎哟，不错哦！'}, 
自我介绍:function(语言='中文') {return语言==='中文'?`大家好，我是${this.名字.中文}。`:`Hi, I'm${this.名字.英文}.`}}

另外声明对象的方法    new Object                     //new是可选的

let  hannah=new Object()

hannah.name={ zh:'昆凌', en:'Hannah'}

hannah.height=165

hannah.children=babies

hannah.catwalk=function() {return '🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈';}

hannah.birth=function(gender,name) { this.children.push({ gender, name });  };

不使用new

const  昆凌=Object({  

名字:{ 中文:'昆凌', 英文:'Hannah'},  

身高:165,  子女:宝贝,  

猫步() {return'🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈'; },  

分娩:function(婴儿性别, 中英文名) {this.子女.push({ 性别:婴儿性别, 名字:中英文名 }) ; },  

自我介绍:function(语言='中文') {return语言==='中文'?`大家好，我是${this.名字.中文}。`:`Hi, I'm${this.名字.英文}.`;} 

})

通过.访问对象属性

>ljh.name.zh
→猥琐下

>ljh.slzm[2]
→说的都对

>jay.like()        //访问 like()方法
→' 哎呦，不错哦'

>hannah.catwalk()                //hannah的catwalk属性函数  catwalk()
→"🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈"

>hannah.children[0].name.zh          //访问hannah的【children() = babies】变量下的数组下标 0 的name的zh数组
→"周小凌"

通过 [ ] 也可以访问对象的属性和方法，当属性名有包含有空格和特殊字符串，或 属性名是变量时，一般使用 [ ] 

>jay['height']

→175>

jay['company']['location']    //周杰伦['公司']['所在地']

→"台北">

jay['intro']()         //周杰伦['自我介绍']()

→"大家好，我是周杰伦。"

>阿星['如 来 神 掌']

→"🖐🖐🖐🖐🖐"

>['name','height'].map(function(property) {returnjay[property] })

→ [{ zh:'周杰伦', en:'Jay'},175]

>jay[prompt('查看 jay 的哪个属性？','songs')]→

>周杰伦[prompt('周杰伦的(?)是1979年1月18日。')]='1979年1月18日'

→"1979年1月18日"

语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·蘭丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。 举例来说，许多程序语言提供专门的语法来对数组中的元素进行引用和更新。

let {name,songs,height }= jay

Object.keys()

通过用Object.keys()ES5 方法 可以获取对象的的所有属性名。

Object.keys(jay)

["name","height","children","songs","company","like","intro"]

修改对象

jay.age = 38                //创建并且赋值,  jay的age = 38

jay.age -= 10              //jay 减去 10  age = 20

hannah.husband=jay

→ {name:Object, height:175, children:Array(1), songs:Array(6), company:Object}

hannah.husband是对 jay 数组的引用(Reference)，因此以下代码会直接修改jay。

>hannah.jay.name.zh='小周周'

"小周周"

jay.name.zh

"小周周"

delete     delete

delete可用于删除对象的属性或方法

>delete   jay.songs            //delete 周杰伦.作品

→true

>jay.songs//周杰伦.作品

→undefined

>delete    hannah.catwalk             //delete 昆凌.猫步

→true

>hannah.catwalk    //     昆凌.猫步

→undefined

delete操作总是返回true，无论属性或方法是否存在

this

this指当前对象，因此jay.intro()里面的this就是jay，hannah.intro()里面的this就是hannah。

this是当前对象，因此jay,intro()里面的this就是jay，hannah.intro()里面的this就是hannah。

>jay.intro()//周杰伦.自我介绍()

→ 大家好，我是周杰伦。

>hannah.intro()//昆凌.自我介绍()

→ 大家好，我是昆凌。

in

in用于检查对象是否具有某个属性或者方法。

>'wife' in jay

→true>

'妻子' in jay

→false>

'妻子' in 周杰伦

→true

以上代码中的引号不能省略，如果省略 JavaScript 会认为那是一个变量。

>let wife = '妻子'

→undefined

>wife in jay

→false

> wife in 周杰伦

→true

遍历对象

for...in 用于遍历对象的属性和方法，      //for...in 也可以用来遍历数组，但是并不推荐。

for(let key in jay ){
 console.log( key , jay[key]);
}

for( let 属性 in 周杰伦){
 console.log(属性 ， 周杰伦[属性])
}

结合 for...in   in 和 this  实现  周杰伦,.专辑.播放()方法

周杰伦.专辑.播放 =function(专辑或者单曲) {
let 专辑名称= 专辑或者单曲;
if(专辑名称 in this ){
return `播放专辑 ${专辑名称} ，—发行年份${this[专辑名称].发行年份}`;}

let 单曲名称 = 专辑或者单曲
for( let 专辑名 in this ){
let 专辑曲目 = this[专辑名]['专辑曲目'];
if (Array.isArray(专辑曲目)&&专辑曲目.indexOf(单曲名称) > -1 ){
return `播放单曲 ${单曲名称} ，—来自专辑${专辑名}`}
}

return `对不起，没有收录这张专辑或这首单曲。`

}

英文对象
周杰伦.专辑.play = function (aors){
let album= aors;
if( album in this ){
return ` 播放专辑${album} —发行年份${this[album].发行年份}。`}

let song = aors  ; 
for( let al in this ){
let songs = this[al]['专辑曲目'];
if( Array.isArray(songs) && songs.indexOf(song)  > -1 ){
return ` 播放单曲 ${song} — 来自专辑 ${al} `}
}
return `对不起，没有收录这张专辑或这首单曲。`

}

引用类型

对象(还有数组，函数等)属于引用类型，因此，jay.childrenhannah.childrenbabies都是引用着同一个数组。

hannah.children.push({ name:{ zh:'周小伦', en:'Jason'}, gender:'男'})//hannah 生二胎
→2
>jay.children
→ [{ name:{ zh:'小周周', en:'Hathaway'}, gender:'女'} 
     { name:{ zh:'周小伦', en:'Jason'}, gender:'男'}]

当==或===作用于对象的时候，实际是在问：这两个变量引用的是用一个对象吗？

>jay.children===hannah.children//周杰伦.子女 === 昆凌.子女
→true
>jay.children===babies
→true
>hannah.children===babies
→true
>empty===空对象
→false
>{ name:'韩梅梅'}==={ name:'韩梅梅'}
→false

s