JavaScript中几乎一切都是对象：创建对象的三种方式

本文转载自公众号“读芯术”(ID：AI_Discovery)。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、网络空间、营销软件、网站建设、静海网站维护、网站推广。

Javascript中的一切几乎都是对象，无论是数组还是函数。本文将教你使用JavaScript创建对象的三种方法。

对象字面量

JavaScript对象字面量是指用大括号括起来的用逗号分隔的名称——值对列表。对象字面量用于封装代码并将其包装在有序的包中。

 
 
 
 
    
  
  
  
  
  1. let Person = { 
    2.   
  
  
  
  2.   name: "Foziya", 
    3.   
  
  
  
  3.   age: 20, 
    4.   
  
  
  
  4.   action: ["walk", " run"], 
    5.   
  
  
  
  5.   greeting: function() { 
    6.   
  
  
  
  6.     console.log("Hello"); 
    7.   
  
  
  
  7.   } 
    8.   
  
  
  
  8. }; 
    9.

对象字面量的属性值可以是任何数据类型，包括数组字面量、函数字面量和嵌套对象字面量。

 
 
 
 
    
  
  
  
  
  1. let shape = { 
    2.   
  
  
  
  2.   name: "rectangle", 
    3.   
  
  
  
  3.   color: "red", 
    4.   
  
  
  
  4.   size: { 
    5.   
  
  
  
  5.     length: 10, 
    6.   
  
  
  
  6.     breadth: 20 
    7.   
  
  
  
  7.   } 
    8.   
  
  
  
  8. }; 
    9.   
  
  
  
  9.   
    10.   
  
  
  
  10. console.log(shape); 
    11.   
  
  
  
  11.  // { name:'rectangle', 
    12.   
  
  
  
  12.  // color: 'red', 
    13.   
  
  
  
  13.  // size: { length:10, breadth: 20 } } 
    14.   
  
  
  
  14.   
    15.   
  
  
  
  15. console.log(shape.size.length) 
    16.   
  
  
  
  16. // 10 
    17.

简写属性名称

假设必须将不同的变量放在一个对象内，有一种方法是：

 
 
 
 
    
  
  
  
  
  1. let one = 1; 
    2.   
  
  
  
  2. let two = 2; 
    3.   
  
  
  
  3. let three = 3; 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. let numbers = { 
    6.   
  
  
  
  6.   one: one, 
    7.   
  
  
  
  7.   two: two, 
    8.   
  
  
  
  8.   three: three 
    9.   
  
  
  
  9. }; 
    10.   
  
  
  
  10. console.log(numbers); 
    11.   
  
  
  
  11.   
    12.   
  
  
  
  12. //{ one: 1, two: 2, three: 3 } 
    13.

使用ECMAScript 2015，可通过较短的表示法实现相同的目的：

 
 
 
 
    
  
  
  
  
  1. let one = 1; 
    2.   
  
  
  
  2. let two = 2; 
    3.   
  
  
  
  3. let three = 3; 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. let numbers = { one, two, three }; 
    6.   
  
  
  
  6.   
    7.   
  
  
  
  7. console.log(numbers); 
    8.   
  
  
  
  8. //{ one: 1, two: 2, three: 3 } 
    9.   
  
  
  
  9.   
    10.   
  
  
  
  10. console.log(numbers.one) 
    11.   
  
  
  
  11. // 1 
    12.   
  
  
  
  12.   
    13.   
  
  
  
  13. console.log(numbers.one === { one }.one); 
    14.   
  
  
  
  14. // true 
    15.

用户定义的构造函数

你也可以使用函数在JavaScript中创建对象。仔细想，其实它们本身已经是对象了，因此对象用于创建更多对象。

通常，此方法优于对象构造函数。试想必须创建数百个具有相同属性的对象，使用对象构造函数方法，必须手动将所有属性添加到所有对象，但是使用构造函数可以预定义这些属性。

 
 
 
 
    
  
  
  
  
  1. functionmovies(name, releaseYear, genre, ratings) { 
    2.   
  
  
  
  2.   this.name = name; 
    3.   
  
  
  
  3.   this.releaseYear =releaseYear; 
    4.   
  
  
  
  4.   this.genre = genre; 
    5.   
  
  
  
  5.   this.ratings =ratings; 
    6.   
  
  
  
  6.   this.watch = () => { 
    7.   
  
  
  
  7.     console.log("WatchOnline"); 
    8.   
  
  
  
  8.   }; 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10.   
    11.   
  
  
  
  11. let DPS = new movies("Dead Poets Society", 1989, ["Drama", "Teen"], { 
    12.   
  
  
  
  12.   IMDb: "8.1 /10", 
    13.   
  
  
  
  13.   Metacritic: "79%" 
    14.   
  
  
  
  14. }); 
    15.   
  
  
  
  15.   
    16.   
  
  
  
  16. console.log(DPS);movies { 
    17.   
  
  
  
  17. //     name: 'Dead Poets Society', 
    18.   
  
  
  
  18. //         releaseYear: 1989, 
    19.   
  
  
  
  19. //             genre: ['Drama','Teen'], 
    20.   
  
  
  
  20. //                 ratings: { IMDb:'8.1 / 10', Metacritic: '79%' }, 
    21.   
  
  
  
  21. //     watch: [Function] 
    22.   
  
  
  
  22. // } 
    23.   
  
  
  
  23.   
    24.   
  
  
  
  24.   
    25.   
  
  
  
  25. let rocky = new movies("Rocky", 1976, ["Drama", "Sports"], { 
    26.   
  
  
  
  26.   IMDb: "8.1 /10", 
    27.   
  
  
  
  27.   Metacritic: "70%" 
    28.   
  
  
  
  28. }); 
    29.   
  
  
  
  29.   
    30.   
  
  
  
  30. console.log(rocky); 
    31.   
  
  
  
  31.   
    32.   
  
  
  
  32. // movies { 
    33.   
  
  
  
  33. //     name: 'Rocky', 
    34.   
  
  
  
  34. //         releaseYear: 1976, 
    35.   
  
  
  
  35. //             genre: ['Drama','Sports'], 
    36.   
  
  
  
  36. //                 ratings: { IMDb:'8.1 / 10', Metacritic: '70%' }, 
    37.   
  
  
  
  37. //     watch: [Function] 
    38.   
  
  
  
  38. // } 
    39.

使用相同的构造函数，可以创建任意数量的对象。

重复的属性名称

如果两个属性使用相同的名称，则第二个属性将覆盖第一个属性。

 
 
 
 
    
  
  
  
  
  1. let Person = { 
    2.   
  
  
  
  2.   name: "NeyVatsa", 
    3.   
  
  
  
  3.   name: "Shashank" 
    4.   
  
  
  
  4. }; 
    5.   
  
  
  
  5. console.log(Person.name); 
    6.   
  
  
  
  6.   
    7.   
  
  
  
  7. // Shashank 
    8.

New关键字

对象构造函数为给定值创建一个对象封装器。如果该值不存在或未定义，它将创建并返回至一个空对象。否则的话，它将返回至一个与给定值类型一致的对象。

也可以使用new关键字创建对象。使用Javascript中的内置对象构造函数，创建一个新的空对象;或者，此关键字可以与用户定义的构造函数一起使用。首先来看一个例子：

 
 
 
 
    
  
  
  
  
  1. let movies = newObject(); 
    2.   
  
  
  
  2.   
    3.   
  
  
  
  3. console.log(movies) 
    4.   
  
  
  
  4. //{} 
    5.

下一步是向此空对象添加属性和方法，可通过简单的点标记来实现：

 
 
 
 
    
  
  
  
  
  1. let movies = newObject(); 
    2.   
  
  
  
  2.   
    3.   
  
  
  
  3. console.log(movies) 
    4.   
  
  
  
  4. //{} 
    5.   
  
  
  
  5.   
    6.   
  
  
  
  6. movies.name = "Dead Poets Society"; 
    7.   
  
  
  
  7. movies.releaseYear = 1989; 
    8.   
  
  
  
  8. movies.genre = ["Drama", "Teen"]; 
    9.   
  
  
  
  9. movies.ratings = { 
    10.   
  
  
  
  10.   IMDb: "8.1 /10", 
    11.   
  
  
  
  11.   Metacritic: "79%" 
    12.   
  
  
  
  12. }; 
    13.   
  
  
  
  13. movies.watch = () => { 
    14.   
  
  
  
  14.   console.log("WatchOnline"); 
    15.   
  
  
  
  15. }; 
    16.   
  
  
  
  16.   
    17.   
  
  
  
  17. console.log(movies); 
    18.   
  
  
  
  18. // { name: 'Dead Poets Society', 
    19.   
  
  
  
  19. //  releaseYear: 1989, 
    20.   
  
  
  
  20. //  genre: [ 'Drama', 'Teen' ], 
    21.   
  
  
  
  21. //  ratings: { IMDb: '8.1 / 10',Metacritic: '79%' }, 
    22.   
  
  
  
  22. //  watch: [Function] } 
    23.   
  
  
  
  23.   
    24.   
  
  
  
  24. movies.watch(); 
    25.   
  
  
  
  25. // Watch Online 
    26.

但我不建议这种做法，因为后台有作用域解析，可以检查构造函数是内置的还是用户定义的。

使用ES6类创建对象

此方法与通过用户定义的构造函数使用new关键字非常类似。类是面向对象编程(OOP)的主要组件，可以创建实际上是对象的许多类实例。在ES6规范的支持下，现在可以用类替换构造函数。

 
 
 
 
    
  
  
  
  
  1. classMovies { 
    2.   
  
  
  
  2.   constructor(name,releaseYear, genre, ratings) { 
    3.   
  
  
  
  3.     this.name = name; 
    4.   
  
  
  
  4.     this.releaseYear = releaseYear; 
    5.   
  
  
  
  5.     this.genre = genre; 
    6.   
  
  
  
  6.     this.ratings =ratings; 
    7.   
  
  
  
  7.   } 
    8.   
  
  
  
  8.   watch() { 
    9.   
  
  
  
  9.     console.log("WatchOnline"); 
    10.   
  
  
  
  10.   } 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12. let rocky = new Movies("Rocky", 1976, ["Drama", "Sports"], { 
    13.   
  
  
  
  13.   IMDb: "8.1 /10", 
    14.   
  
  
  
  14.   Metacritic: "70%" 
    15.   
  
  
  
  15. }); 
    16.   
  
  
  
  16. console.log(rocky); 
    17.   
  
  
  
  17. // Movies { 
    18.   
  
  
  
  18. //     name: 'Rocky', 
    19.   
  
  
  
  19. //         releaseYear: 1976, 
    20.   
  
  
  
  20. //             genre: ['Drama','Sports'], 
    21.   
  
  
  
  21. //                 ratings: { IMDb:'8.1 / 10', Metacritic: '70%' } 
    22.   
  
  
  
  22. // } 
    23.   
  
  
  
  23.   
    24.   
  
  
  
  24. rocky.watch(); 
    25.   
  
  
  
  25. //Watch Online 
    26.

上面示例中，我已经定义了构造函数中的所有参数。方法可以是类的一部分，而声明可以稍后添加到类的创建实例中，成为“对象”：

 
 
 
 
    
  
  
  
  
  1. /* 
    2.   
  
  
  
  2. above example 
    3.   
  
  
  
  3. */ 
    4.   
  
  
  
  4. rocky.buy = function() { 
    5.   
  
  
  
  5.   console.log("Buy theMovie"); 
    6.   
  
  
  
  6. }; 
    7.   
  
  
  
  7. rocky.buy(); 
    8.   
  
  
  
  8. // Buy the Movie 
    9.

而这里方法是对象的一部分，不会影响原始类。

图源：unsplash

在JavaScript这一基于原型的继承语言中，类和构造函数都模仿面向对象的继承模型。熟悉类非常有帮助，React这样的流行JavaScript库会经常使用类句法。

你掌握了吗?

文章题目：JavaScript中几乎一切都是对象：创建对象的三种方式
链接URL：http://www.shufengxianlan.com/qtweb/news9/47559.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

同城分类信息

成都做商城网站　　 　做网站　　 　普能电气　　 　广安园林绿化公司　　 　虚拟主机　　 　网络推广外包　　 　成都企业网站建设公司　　 　成都装修公司　　 　新华建筑装饰　　 　成都手机网站报价　　 　宜宾网站设计　　 　小程序开发公司　　 　H5网站制作　　 　江油网站建设　　 　百度推广公司　　 　四川艾名斯　　 　关键词优化　　 　西云服务器托管　　 　成都西信服务器托管　　 　营销型网站