Skip to main content
 首页 » 编程设计

详解Javascript对象

2022年07月19日145www_RR

详解Javascript对象

在Javascript中有7种类型,其中6个为原始类型,因为他们的值仅包含单个内容(如字符串、数值或其他)。
反之对象通常存储包含不同类型的键集合,更加复杂。在Javascript中,对象几乎涉及方方面面,所有我们在深入使用前必须首先理解他们。

定义

对象使用{}创建,可以包含若干个属性。属性是“键:值”方式,其中键必须是字符串类型,即属性名称,值可以是任意类型。

我们想像是带有名称的文档盒子,每个属性值通过键的方式存储在其中,通过名称(键)很方面查找其中的文件(属性值),也可以添加、删除其他文件。

有两种方式定义对象,后者通常被使用。

let user = new Object(); // "object constructor" syntax 
let user = {};  // "object literal" syntax 

对象属性

我们可以通过键值对的方式增加属性:
let user = { // an object
name: “John”, // by key “name” store value “John”
age: 30// by key “age” store value 30
};

属性在“:”前有键(名称或标识),值在冒号右边。上面的示例user对象有两个属性。
1、name属性,值为“John”。
2、age属性,值为30.

对象user可想像为有两个文档的盒子,分别命名为“name”和“age”。

我们随时可以增加、删除、查找文档。属性值可以通过.号访问。

// get fields of the object: 
alert( user.name ); // John 
alert( user.age ); // 30 

值可以是任意类型,我们增加一个布尔值。

user.isAdmin = true; 

使用delete可以删除属性,示例如下:

delete user.age; 

我们也能使用多个单词作为属性的名称,但必须使用引号:
let user = {
name: “John”,
age: 30,
“likes birds”: true // multiword property name must be quoted
};

最后属性后面可以有一个多余的逗号。

let user = { 
  name: "John", 
  age: 30, 
} 

这个特性,是我们更容易增加、删除属性,因为所有行看起来一致。

方括号

对于多个单词的属性,不能直接访问:

// this would give a syntax error 
user.likes birds = true 

因为.号需要键必须为有效的变量进行标识,即不能有空格或其他限制,另一种方式使用方括号。

let user = {}; 
 
// set 
user["likes birds"] = true; 
 
// get 
alert(user["likes birds"]); // true 
 
// delete 
delete user["likes birds"]; 

现在可以访问了,需要注意的是方括号内的字符串需要引号括起来(单引号或双引号)。
方括号也提供了通过变量名称访问属性:
let key = “likes birds”;

// same as user["likes birds"] = true; 
user[key] = true; 

这里变量key是运行时计算的,或依赖用户输入。然后使用该变量访问属性,这种方式给我们很大的灵活性,点号不能使用类似的方式:
let user = {
name: “John”,
age: 30
};

let key = prompt("What do you want to know about the user?", "name"); 
 
// access by variable 
alert( user[key] ); // John (if enter "name") 

计算属性

我们能使用方括号在对象体内,一般称为计算属性。示例如下:

let fruit = prompt("Which fruit to buy?", "apple"); 
 
let bag = { 
  [fruit]: 5, // the name of the property is taken from the variable fruit 
}; 
 
alert( bag.apple ); // 5 if fruit="apple" 

计算属性的意义很明了,[fruit]意味着属性名称应该来自fruit。所以用户输入“apple”,则bag对象的内容为{apple:5}.对应代码的表现为:

let fruit = prompt("Which fruit to buy?", "apple"); 
let bag = {}; 
 
// take property name from the fruit variable 
bag[fruit] = 5; 

方括号比点号更强大,其容许任何一个属性名称和变量,当然也更难写。所以一般属性名称已知且简单,使用点号;如果我们需要更复杂或灵活的方式,使用方括号。

简化属性值

实际开发中我们通常使用变量作为属性值,示例如下:

function makeUser() { 
  let name = prompt("Name?"); 
  let age = prompt("Age?"); 
  return { 
name: name, 
age: age 
  }; 
} 
 
let user = makeUser("John", 30); 
alert(user.name); // John 

示例中,属性名称与赋值变量同名,这种情况下,可以简写。
代替name:name,为name,代码如下:

function makeUser(name, age) { 
  return { 
    name, // same as name: name 
    age   // same as age: age 
  }; 
} 

也可以在对象中同时使用正常属性和简写方式:
let user = {
name, // same as name:name
age: 30
};

属性存在性检查

可标识对象特性是其任何属性都可以访问,如果属性不存在也不会报错。访问不存在的属性,仅返回undefined。这时一个常规方法测试属性是否存在,使其和undefined比较。

let user = {}; 
 
alert( user.noSuchProperty === undefined ); // true means "no such property" 

也可以使用in操作来检查属性。语法是:"key" in object。示例如下:

let user = { name: "John", age: 30 }; 
 
alert( "age" in user ); // true, user.age exists 
alert( "blabla" in user ); // false, user.blabla doesn't exist 

注意:在in的左边必须是属性名称,通常需要使用引号括起来。如果省略引号,则意味着是变量,其包含实际被测试的值。示例如下:

let user = { age: 30 }; 
 
let key = "age"; 
alert( key in user ); // true, takes the name from key and checks for such property 

使用in比较存储undefined的值
通常使用严格比较“===undefined”检查没有问题。但是有个特列,这时使用in没有问题。即当对象属性存在,但是其值为undefined

let obj = { 
  test: undefined 
}; 
 
alert( obj.test ); // it's undefined, so - no such property? 
 
alert( "test" in obj ); // true, the property does exist! 

上面代码,属性obj.test确实存在,所以in测试没有问题。这种场景很少发生,因为undefined通常不用来赋值,我们大多数使用null或“unknown”、“empty”值。

“for…in” 循环

为了遍历对象中所有属性(键),有个特别的循环语法:for..in,这个与for(;;)语法不同。语法如下:

for(key in object) { 
  // executes the body for each key among object properties 
} 

示例,我们遍历user对象所有属性:
let user = {
name: “John”,
age: 30,
isAdmin: true
};

for(let key in user) { 
  // keys 
  alert( key );  // name, age, 30 
  // values for the keys 
  alert( user[key] ); // John, 30, true 
} 

注所有for结构,允许在循环体内声明循环变量,如这里的let key。我们也可以使用其他的变量名称代替key,如,for(let prop in obj)也可以。

属性的顺序

如果我们循环一个对象,我们获得属性顺序和他们添加的顺序一致吗?排序的依据是什么?
下面看示例,我们考虑一个对象,使用区域代码作为键。

let codes = { 
  "49": "Germany", 
  "41": "Switzerland", 
  "44": "Great Britain", 
  // .., 
  "1": "USA" 
}; 
 
for(let code in codes) { 
  alert(code); // 1, 41, 44, 49 
} 

如果我们希望49排在第一位,但实际却不是。
USA(1)第一位,然后是Switzerland(41)等。
属性的输出顺序是按照数字的升序排序顺序,因为他们是Integer,所有是 1 41 44 49

Integer属性
integer属性是一个字符串,能够转为整数,其值不变。所以“49”是一个Integer属性名称,因为当他转成整数,仍然相同,但是“+49”和“1.2”则不是。

// Math.trunc is a built-in function that removes the decimal part 
alert( String(Math.trunc(Number("49"))) ); // "49", same, integer property 
alert( String(Math.trunc(Number("+49"))) ); // "49", not same ⇒ not integer property 
alert( String(Math.trunc(Number("1.2"))) ); // "1", not same ⇒ not integer property 

另外,如果键是非整数,那么他们按照创建顺序输出,示例:

let user = { 
  name: "John", 
  surname: "Smith" 
}; 
user.age = 25; // add one more 
 
// non-integer properties are listed in the creation order 
for (let prop in user) { 
  alert( prop ); // name, surname, age 
} 

所以,为了修复这个区域代码键问题,我们可以使用非整数属性,在数字前增加“+”,达到目的,象这样:

let codes = { 
  "+49": "Germany", 
  "+41": "Switzerland", 
  "+44": "Great Britain", 
  // .., 
  "+1": "USA" 
}; 
 
for(let code in codes) { 
  alert( +code ); // 49, 41, 44, 1 
} 

按引用拷贝

对象和原始值本质不同是他们存储和按引用拷贝。原始值:string、numbers、boolean,是作为一个整体进行赋值或拷贝。示例:

let message = "Hello!"; 
let phrase = message; 

结果是,我们有两个独立的变量,每个都存储着字符串“Hello!”。

对象与之不同。对象变量不存储对象自身,而是内存地址,即其引用。图示如下:
let user = {
name: “John”
};

这里,对象存储在内存某个地址,变量user有一个引用指向它。当一个对象变量被拷贝(赋值),是引用被拷贝,对象值没有被拷贝。

如果我们想像对象是一个盒子,然后对象有一个键指向它,拷贝变量则赋值键,而不是盒子本身。示例:
let user = { name: “John” };

let admin = user; // copy the reference 

现在我们有两个变量,每个都有一个引用,指向同一对象。

let user = { name: 'John' }; 
 
let admin = user; 
 
admin.name = 'Pete'; // changed by the "admin" reference 
 
alert(user.name); // 'Pete', changes are seen from the "user" reference 

上面代码演示了只有一个对象,就如我们有一个盒子,但是带有两个键,我们通过“admin”修改其值,然后通过另一个“user”获取值,确实已经改变。

比较引用
“==”和严格相对“===”操作,对对象作用是一样的。两个对象相等仅如果他们是同一个对象。

let a = {}; 
let b = a; // copy the reference 
 
alert( a == b ); // true, both variables reference the same object 
alert( a === b ); // true 

如果是两个独立的对象,则不相对,即使都为空。

let a = {}; 
let b = {}; // two independent objects 
 
alert( a == b ); // false 

常量对象
对象声明为const可以被改变,示例如下:
const user = {
name: “John”
};

user.age = 25; // (*) 
 
alert(user.age); // 25 

你可能会认为号行会出错,但是不会,完全没有问题。那是因为const不允许user值自身,即user始终存储同一个对象引用。号行是在对象内部,并没有给user重新赋值。

如果你试图给user赋值,则会出错,示例如下:

const user = { 
  name: "John" 
}; 
 
// Error (can't reassign user) 
user = { 
  name: "Pete" 
}; 

至于如何实现让user.age不能修改,以后再谈。

 克隆和合并,对象赋值

如上所说,拷贝对象变量,只是创建了对同一对象的一个或多个针引用。但我们如何实现复制对象,是对立的拷贝,即克隆。其实是可行的,但有点困难,因为Javascript没有内置方法,事实上,这很少需要,大多数情况下都是赋值引用。

但是如果你确实需要,那么你需要创建一个新对象,然后通过迭代每个属性,然后复制他们在原始值级别,完整地复制原对象的结构。示例:

let user = { 
  name: "John", 
  age: 30 
}; 
 
let clone = {}; // the new empty object 
 
// let's copy all user properties into it 
for (let key in user) { 
  clone[key] = user[key]; 
} 
 
// now clone is a fully independant clone 
clone.name = "Pete"; // changed the data in it 
 
alert( user.name ); // still John in the original object 

我们也可以使用Object.assign方法实现.语法为 Object.assign(dest[, src1, src2, src3...])。参数都是对象,它拷贝src1、…,srcN所有对象的所有属性至dest对象。即从第二个开始的所有参数的属性都复制到第一个,然后返回dest。

示例,我们可以合并几个对象至一个:

let user = { name: "John" }; 
 
let permissions1 = { canView: true }; 
let permissions2 = { canEdit: true }; 
 
// copies all properties from permissions1 and permissions2 into user 
Object.assign(user, permissions1, permissions2); 
 
// now user = { name: "John", canView: true, canEdit: true } 

如果接收对象(user)已经有同名属性,则会覆盖:

let user = { name: "John" }; 
 
// overwrite name, add isAdmin 
Object.assign(user, { name: "Pete", isAdmin: true }); 
 
// now user = { name: "Pete", isAdmin: true } 

我们也可以使用Object.assign方式代替loop实现简单克隆:

let user = { 
  name: "John", 
  age: 30 
}; 
 
let clone = Object.assign({}, user); 

这里拷贝了user所有属性值空对象,然后返回,与loop效果一样,但不都一样。因为我们上面user对象所有属性都是原始类型,但是属性可能是引用类型,指向其他对象,这种情况会怎么呢?代码如下:

let user = { 
  name: "John", 
  sizes: { 
    height: 182, 
    width: 50 
  } 
}; 
 
alert( user.sizes.height ); // 182 

现在做 clone.sizes = user.sizes 是不够的,因为 users.sizes 是对象,只复制了引用。所以clone和user指向同一个对象。
代码如下:
let user = {
name: “John”,
sizes: {
height: 182,
width: 50
}
};

let clone = Object.assign({}, user); 
 
alert( user.sizes === clone.sizes ); // true, same object 
 
// user and clone share sizes 
user.sizes.width++;   // change a property from one place 
alert(clone.sizes.width); // 51, see the result from the other one 

为了实现深复制,我们需要判断user[key]类型,如果为对象类型,需继续复制其下面每个属性,有兴趣的读者可以参考结构克隆算法。


本文参考链接:https://blog.csdn.net/neweastsun/article/details/69053673