blocks|key|5543548|text|在Javascript中，{}符号定义了一个对象，在这种情况下，您只需要获取bar属性。它类似于任何OO语言中的类；并且类似于以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5543549|var+obj+=+{
+foo+:+'Test+Foo',
+bar+:+'test+bar'+
};

alert(+obj.bar+);+//Show+the+'bar'+property+of+obj.|code-block|syntax|javascript|5543550|声明显然只是返回自身，所以您所显示的语法是合法的。然而，它是相当无用的，因为你不能再对你刚刚定义的对象做任何事情了。|5543551|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In Javascript the {} notation defines an object, you just get the bar property in this case. It is similar to a class in any OO language; and similar to the following code:

<pre><code>var obj = {
 foo : 'Test Foo',
 bar : 'test bar' 
};

alert( obj.bar ); //Show the 'bar' property of obj.
</code></pre>

The declaration just returns itself obviously, so the syntax you showed is legal. However it is fairly useless, as you cant do anything with the object you just defined anymore.

blocks|key|176704|text|你有一个对象|type|unstyled|depth|inlineStyleRanges|entityRanges|data|176705|有两个属性:+foo，bar。|176706|foo值为"test+foo“|176707|条值为"test+bar“|176708|但是让我看看酒吧的价值。|176709|{foo：“测试foo"，bar：”测试吧“}.bar|176710|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

you have an object 

with 2 properties : foo , bar.

foo value is "test foo"

bar value is "test bar"

but show me the value of bar.

{foo:"test foo", bar:"test bar"}.bar

blocks|key|1195651|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1195652|{foo:"test+foo",+bar:"test+bar"}创建一个包含两个字段的新对象：foo，并且bar|ordered-list-item|offset|length|style|CODE|1195653|alert(obj.bar)输出这个新创建的对象的bar字段的值|1195654|1195655|entityMap^0|0|0|W|1B|3|1H|3|0|0|E|P|3|0|0^^$0|@$1|2|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|N|7|@$D|O|E|P|F|G]|$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|8|@]|9|$]]|$1|H|3|I|4|C|6|U|7|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|8|@]|9|$]]|$1|J|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|10|7|@]|8|@]|9|$]]]|L|$]]

<ol>
<li><code>{foo:"test foo", bar:"test bar"}</code> creates a new object with two fields: <code>foo</code> and <code>bar</code></li>
<li><code>alert(obj.bar)</code> outputs a value of <code>bar</code> field of this newly created object</li>
</ol>

blocks|key|5543687|text|在您的示例中，使用对象作为其参数来调用函数alert。该参数使用两个属性foo和bar动态构造一个对象，然后访问bar属性，该属性返回一个字符串供alert函数显示。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5543688|entityMap^0|L|5|10|3|14|3|1K|3|21|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

In your example the function <code>alert</code> is called with an object as it's parameter. The parameter constructs an object on the fly with two properties, <code>foo</code> and <code>bar</code>, then accesses the <code>bar</code> property, which returns a string for the <code>alert</code> function to display.

blocks|key|5543713|text|这里有两段代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5543714|{foo:"test+foo",+bar:"test+bar"}|code-block|syntax|javascript|5543715|这是一个对象文字:它定义了一个具有两个属性foo和bar的对象，每个属性都有一个字符串作为它的值。|offset|length|style|CODE|5543716|.bar|5543717|这是成员运算符:它从名称为bar的对象中获取成员。|5543718|我无法想象这种编码风格的用例...|5543719|entityMap^0|0|0|L|3|P|3|0|0|D|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

You have two bits of code there:

<pre><code>{foo:"test foo", bar:"test bar"}
</code></pre>

This is an object literal: it defines an object with two properties <code>foo</code> and <code>bar</code>, each of which has a string as its value.

<pre><code>.bar
</code></pre>

This is the member operator: it gets a member from the object whose name is <code>bar</code>.

I can't imagine a use-case for this style of coding...

blocks|key|5543734|text|JS创建对象并立即显示属性栏：)可能会有帮助：http://json.org/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5543735|entityMap|0|LINK|mutability|MUTABLE|url|http://json.org/^0|N|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

JS creates the object and immediately displays the property bar:)
may be helpful: <a href="http://json.org/" rel="nofollow">http://json.org/</a>

blocks|key|1195716|text|语法{foo:"test+foo",+bar:"test+bar"}被称为Javascript+Object+Notation+(JSON)，它允许使用更简洁的语法来构造javascript对象，然后：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1195717|var+obj+=+function()+{+this.foo+=+"test+foo";+this.bar+=+"test+bar";+};
var+instance+=+new+obj();|code-block|syntax|javascript|1195718|因此，在上面的示例中，您将创建一个具有两个字段的javascript对象，然后立即访问bar字段。|1195719|entityMap^0|2|W|0|0|17|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

The syntax <code>{foo:"test foo", bar:"test bar"}</code> is called Javascript Object Notation (JSON), and it allows a javascript object to be constructed using with a much terser syntax then:

<pre><code>var obj = function() { this.foo = "test foo"; this.bar = "test bar"; };
var instance = new obj();
</code></pre>

So in the above example, you are creating a javascript object with two fields, and then immediately accessing the <code>bar</code> field.

blocks|key|5543823|text|{foo:"test+foo",+bar:"test+bar"}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5543824|这将创建一个具有两个属性foo和bar的新对象。如果您习惯了Java或C#或C%2B%2B或类似的语言，就像在说|unstyled|offset|length|style|CODE|5543825|class+FooAndBarObject+{
++public+string+foo;
++public+string+bar;

++public+FooAndBarObject(string+foo,+string+bar)+{
++++this.foo+=+foo;
++++this.bar+=+bar;
++}
}

new+FooAndBarObject("test+foo",+"test+bar");|5543826|因此，编写{foo:"test+foo",+bar:"test+bar"}.bar将返回bar属性的值，恰好是"test+bar"。|5543827|alert是一个显示传递给它的值的函数，因此它将向用户显示test+bar。|5543828|entityMap^0|0|C|3|G|3|0|0|5|10|18|3|1J|A|0|0|5|T|8|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]|$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|Z|8|@$G|10|H|11|I|J]|$G|12|H|13|I|J]|$G|14|H|15|I|J]]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@$G|17|H|18|I|J]|$G|19|H|1A|I|J]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|1B|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>{foo:"test foo", bar:"test bar"}
</code></pre>

This creates a new object with two properties, <code>foo</code> and <code>bar</code>. If you're used to Java or C# or C++ or a language like that, it's like saying

<pre><code>class FooAndBarObject {
 public string foo;
 public string bar;

 public FooAndBarObject(string foo, string bar) {
 this.foo = foo;
 this.bar = bar;
 }
}

new FooAndBarObject("test foo", "test bar");
</code></pre>

So, then writing <code>{foo:"test foo", bar:"test bar"}.bar</code> returns the value of the <code>bar</code> property, which happens to be <code>"test bar"</code>.

<code>alert</code> is a function that displays the value passed to it, so it will display <code>test bar</code> to the user.

blocks|key|175301|text|javascript中的对象文字是某种关联数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175302|是成对的：|175303|++var+a++=+{+
+++++key1:+'value1',
+++++key2:+'value2',
+++++"key+#3":+'value3'
++++}|code-block|syntax|javascript|175304|值中可以包含任何类型的数据，如果值中包含特殊字符、空格或保留字，则Key应为字符串。|175305|可以通过点访问a的值(如在OOP中)：|offset|length|style|CODE|175306|+a.key1+==+'value1';|175307|但是如果键包含上面描述的特殊字符，你可以像关联数组一样访问值意味着a；|175308|a["key+#3"]+==+'value3'|175309|然而，|175310|a["key1"]+;|175311|也是正确的|175312|javascript中的每个声明/赋值都返回对象本身或分别赋值，因此：|175313|var+a;
(a={+
++++key1:+'value1',
++++key2:+'value2',
++++"key+#3":+'value3',
++++key4:+function(){
+++++++//`this`+refers+to+`a`+variable+-+if+function+will+be+called+directly+from+`a`++=>+a.key4()+;+
++++++alert(this["key+#3");}
++++++++}).key1++//+gets+'value1'|175314|或|175315|({+key1:'value1'+})['key1'];//+gets+'value1'+too|175316|entityMap^0|0|0|0|0|7|1|0|0|X|1|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@$M|1H|N|1I|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1K|8|@$M|1L|N|1M|O|P]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1P|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1R|8|@]|9|@]|A|$]]|$1|14|3|15|5|F|7|1S|8|@]|9|@]|A|$G|H]]|$1|16|3|17|5|6|7|1T|8|@]|9|@]|A|$]]|$1|18|3|19|5|F|7|1U|8|@]|9|@]|A|$G|H]]|$1|1A|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|1B|$]]

Object literal in javascript is some kind of associative array.

Are pairs:

<pre><code> var a = { 
 key1: 'value1',
 key2: 'value2',
 "key #3": 'value3'
 }
</code></pre>

Can contain any kind of data in values,
Key should be a strings if they contain special characters, spaces or reserved words.

Access to values of <code>a</code> can be by dot ( as in OOP):

<pre><code> a.key1 == 'value1';
</code></pre>

But if key contain special characters described above you can access to value means <code>a</code> like as associative array;

<pre><code>a["key #3"] == 'value3'
</code></pre>

However, 

<pre><code>a["key1"] ;
</code></pre>

also is correct

Every declaration/assignment in javascript returns the object itself or assign respectively, so:

<pre><code>var a;
(a={ 
 key1: 'value1',
 key2: 'value2',
 "key #3": 'value3',
 key4: function(){
 //`this` refers to `a` variable - if function will be called directly from `a` =&gt; a.key4() ; 
 alert(this["key #3");}
 }).key1 // gets 'value1'
</code></pre>

or

<pre><code>({ key1:'value1' })['key1'];// gets 'value1' too
</code></pre>

Can someone please explain this bit of piece of code?
Thanks.

<pre><code> alert({foo:"test foo", bar:"test bar"}.bar); // "test bar"
</code></pre>

Accessing JavaScript objects

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有人能解释一下这段代码吗？谢谢。 alert({foo:"test foo", bar:"test bar"}.bar); // "test bar"

问访问JavaScript对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问访问JavaScript对象EN