blocks|key|2060548|text|对象文字和构造对象之间的唯一区别是从原型继承的属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2060549|var+o+=+{
++'a':+3,+'b':+4,
++'doStuff':+function()+{
++++alert(this.a+%2B+this.b);
++}
};
o.doStuff();+//+displays:+7|code-block|syntax|javascript|2060550|2060551|你可以创建一个结构工厂。|2060552|function+makeStruct(names)+{
++var+names+=+names.split('+');
++var+count+=+names.length;
++function+constructor()+{
++++for+(var+i+=+0;+i+<+count;+i%2B%2B)+{
++++++this[names[i]]+=+arguments[i];
++++}
++}
++return+constructor;
}

var+Item+=+makeStruct("id+speaker+country");
var+row+=+new+Item(1,+'john',+'au');
alert(row.speaker);+//+displays:+john|2060553|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Q|8|@]|9|@]|A|$]]|$1|J|3|K|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

The only difference between object literals and constructed objects are the properties inherited from the prototype.

<pre><code>var o = {
 'a': 3, 'b': 4,
 'doStuff': function() {
 alert(this.a + this.b);
 }
};
o.doStuff(); // displays: 7
</code></pre>

<hr>

You could make a struct factory.

<pre><code>function makeStruct(names) {
 var names = names.split(' ');
 var count = names.length;
 function constructor() {
 for (var i = 0; i &lt; count; i++) {
 this[names[i]] = arguments[i];
 }
 }
 return constructor;
}

var Item = makeStruct("id speaker country");
var row = new Item(1, 'john', 'au');
alert(row.speaker); // displays: john
</code></pre>

blocks|key|2060372|text|我总是使用对象字面量|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2060373|{id:+1,+speaker:"john",+country:+"au"}|code-block|syntax|javascript|2060374|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I always use object literals

<pre><code>{id: 1, speaker:"john", country: "au"}
</code></pre>

blocks|key|1846615|text|真正的问题是，语言中的结构应该是值类型，而不是引用类型。建议的答案建议使用对象(引用类型)来代替结构。虽然这可以服务于它的目的，但它回避了程序员实际上想要使用值类型(如原语)代替引用类型的好处。例如，值类型不应该导致内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1846616|编辑:有a+proposal+in+the+works可以涵盖这一目的。|offset|length|1846617|//today
var+obj+=+{fname:+"Kris",+lname:+"Kringle"};+//vanilla+object
var+gifts+=+["truck",+"doll",+"slime"];+//vanilla+array

//records+and+tuples+-+not+possible+today
var+obj+=+#{fname:+"Buddy",+lname:+"Hobbs"};
var+skills+=+#["phone+calls",+"basketball",+"gum+recycling"];|code-block|syntax|javascript|1846618|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/tc39/proposal-record-tuple^0|0|4|N|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The real problem is that structures in a language are supposed to be value types not reference types. The proposed answers suggest using objects (which are reference types) in place of structures. While this can serve its purpose, it sidesteps the point that a programmer would actual want the benefits of using value types (like a primitive) in lieu of reference type. Value types, for one, shouldn't cause memory leaks.
EDIT:
There is <a href="https://github.com/tc39/proposal-record-tuple" rel="nofollow noreferrer">a proposal in the works</a> to cover this purpose.
<pre><code>//today
var obj = {fname: &quot;Kris&quot;, lname: &quot;Kringle&quot;}; //vanilla object
var gifts = [&quot;truck&quot;, &quot;doll&quot;, &quot;slime&quot;]; //vanilla array

//records and tuples - not possible today
var obj = #{fname: &quot;Buddy&quot;, lname: &quot;Hobbs&quot;};
var skills = #[&quot;phone calls&quot;, &quot;basketball&quot;, &quot;gum recycling&quot;];

</code></pre>

blocks|key|1846663|text|遵循马库斯的结构，在较新版本的JS+(我认为是ES6)中，您可以更简单地使用Arrow+Functions和Rest+Parameter创建一个‘answer’工厂，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1846664|const+Struct+=+(...keys)+=>+((...v)+=>+keys.reduce((o,+k,+i)+=>+{o[k]+=+v[i];+return+o}+,+{}))
const+Item+=+Struct('id',+'speaker',+'country')
var+myItems+=+[
++++Item(1,+'john',+'au'),
++++Item(2,+'mary',+'us')
];

console.log(myItems);
console.log(myItems[0].id);
console.log(myItems[0].speaker);
console.log(myItems[0].country);|code-block|syntax|javascript|1846665|运行此命令的结果是：|1846666|[+{+id:+1,+speaker:+'john',+country:+'au'+},
++{+id:+2,+speaker:+'mary',+country:+'us'+}+]
1
john
au|1846667|您可以让它看起来类似于Python的namedtuple：|1846668|const+NamedStruct+=+(name,+...keys)+=>+((...v)+=>+keys.reduce((o,+k,+i)+=>+{o[k]+=+v[i];+return+o}+,+{_name:+name}))
const+Item+=+NamedStruct('Item',+'id',+'speaker',+'country')
var+myItems+=+[
++++Item(1,+'john',+'au'),
++++Item(2,+'mary',+'us')
];

console.log(myItems);
console.log(myItems[0].id);
console.log(myItems[0].speaker);
console.log(myItems[0].country);|1846669|结果是：|1846670|[+{+_name:+'Item',+id:+1,+speaker:+'john',+country:+'au'+},
++{+_name:+'Item',+id:+2,+speaker:+'mary',+country:+'us'+}+]
1
john
au|1846671|entityMap|0|LINK|mutability|MUTABLE|url|http://es6-features.org/#StatementBodies|1|http://es6-features.org/#RestParameter|2|https://stackoverflow.com/a/502384/4212710^0|12|F|0|1I|E|1|21|6|2|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]|$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1I|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1J|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|C|$]]|$1|S|3|T|5|F|7|1M|8|@]|9|@]|C|$G|H]]|$1|U|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]|14|$5|X|Y|Z|C|$10|15]]]]

Following Markus's <a href="https://stackoverflow.com/a/502384/4212710">answer</a>, in newer versions of JS (ES6 I think) you can create a 'struct' factory more simply using <a href="http://es6-features.org/#StatementBodies" rel="noreferrer">Arrow Functions</a> and <a href="http://es6-features.org/#RestParameter" rel="noreferrer">Rest Parameter</a> like so:

<pre><code>const Struct = (...keys) =&gt; ((...v) =&gt; keys.reduce((o, k, i) =&gt; {o[k] = v[i]; return o} , {}))
const Item = Struct('id', 'speaker', 'country')
var myItems = [
 Item(1, 'john', 'au'),
 Item(2, 'mary', 'us')
];

console.log(myItems);
console.log(myItems[0].id);
console.log(myItems[0].speaker);
console.log(myItems[0].country);
</code></pre>

The result of running this is:

<pre><code>[ { id: 1, speaker: 'john', country: 'au' },
 { id: 2, speaker: 'mary', country: 'us' } ]
1
john
au
</code></pre>

You can make it look similar to Python's namedtuple:

<pre><code>const NamedStruct = (name, ...keys) =&gt; ((...v) =&gt; keys.reduce((o, k, i) =&gt; {o[k] = v[i]; return o} , {_name: name}))
const Item = NamedStruct('Item', 'id', 'speaker', 'country')
var myItems = [
 Item(1, 'john', 'au'),
 Item(2, 'mary', 'us')
];

console.log(myItems);
console.log(myItems[0].id);
console.log(myItems[0].speaker);
console.log(myItems[0].country);
</code></pre>

And the results:

<pre><code>[ { _name: 'Item', id: 1, speaker: 'john', country: 'au' },
 { _name: 'Item', id: 2, speaker: 'mary', country: 'us' } ]
1
john
au
</code></pre>

blocks|key|2060451|text|我对哑巴结构(没有成员函数)使用对象JSON风格。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2060452|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I use objects JSON style for dumb structs (no member functions).

blocks|key|2060763|text|如果你使用ES6兼容性，我做了一个小的库来定义结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2060764|这是一个JKT解析器，您可以在JKT+Parser这里签出项目存储库。|offset|length|2060765|例如，你可以像这样创建你的结构|2060766|const+Person+=+jkt`
++++name:+String
++++age:+Number
`

const+someVar+=+Person({+name:+"Aditya",+age:+"26"+})

someVar.name+//+print+"Aditya"
someVar.age+//+print+26+(integer)

someVar.toJSON()+//+produce+json+object+with+defined+schema+|code-block|syntax|javascript|2060767|entityMap|0|LINK|mutability|MUTABLE|url|http://github.com/slaveofcode/jkt^0|0|F|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I made a small library to define struct if you work with ES6 compatibility.

It is a JKT parser you may checkout the project repository here <a href="http://github.com/slaveofcode/jkt" rel="nofollow noreferrer">JKT Parser</a>

For an example you may create your struct like this

<pre><code>const Person = jkt`
 name: String
 age: Number
`

const someVar = Person({ name: "Aditya", age: "26" })

someVar.name // print "Aditya"
someVar.age // print 26 (integer)

someVar.toJSON() // produce json object with defined schema 
</code></pre>

blocks|key|1846928|text|这是一个似乎还没有得到解决的老问题。无论如何，我使用不变性来获得类似的行为。使用Typescript：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1846929|export+class+Point+{
+++public+readonly+X:+number;
+++public+readonly+Y:+number;

+++constructor(x:+number,+y:+number)
+++{
+++++++this.X+=+x;
+++++++this.Y+=+y;
+++}

+++public+static+SetX(value:+number)+:+Point+{
+++++++return+new+Point(value,+this.Y);
+++}

+++public+static+SetY(value:+number)+:+Point+{
+++++++return+new+Point(this.X,+value);
+++}
}|code-block|syntax|javascript|1846930|这为您提供了复杂值类型的一个关键好处，即您不能通过引用对象来意外地修改它。|1846931|当然，缺点是，如果您确实想要修改成员，则必须创建一个新实例，因此需要使用静态SetX和SetY函数。|offset|length|style|CODE|1846932|这是很多语法上的糖，但我认为对于特殊情况是值得的，比如Point，如果值被意外更改，可能会被大量使用并导致许多错误。|1846933|entityMap^0|0|0|0|12|4|17|4|0|R|5|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@$K|11|L|12|M|N]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

This is an old problem that it doesn't seem has been addressed yet. For what it's worth, I use immutability to get similar behavior. Using Typescript:
<pre><code>export class Point {
 public readonly X: number;
 public readonly Y: number;

 constructor(x: number, y: number)
 {
 this.X = x;
 this.Y = y;
 }

 public static SetX(value: number) : Point {
 return new Point(value, this.Y);
 }

 public static SetY(value: number) : Point {
 return new Point(this.X, value);
 }
}
</code></pre>
This gets you a key benefit of a complex value type, namely that you can't accidentally modify the object via a reference to it.
The drawback of course is that if you DO want to modify a member you have to make a new instance, hence the static <code>SetX</code> and <code>SetY</code> functions.
It's a lot of syntactic sugar but I think it's worth it for special cases, like <code>Point</code>, that could potentially get used A LOT and lead to A LOT of bugs if values are changed accidentally.

Previously, when I needed to store a number of related variables, I'd create a class.

<pre><code>function Item(id, speaker, country) {
 this.id = id;
 this.speaker = spkr;
 this.country = country;
}
var myItems = [
 new Item(1, 'john', 'au'),
 new Item(2, 'mary', 'us')
];
</code></pre>

But I'm wondering if this is a good practice. Are there any other, better ways to simulate a struct in Javascript?

Structs in Javascript

以前，当我需要存储大量相关变量时，我会创建一个类。function Item(id, speaker, country) {    this.id = id;    this.speaker = spkr;    this.country = country;}var myItems = [    new Item(1, 'john', 'au'),    new Item(2, 'mary', 

问Javascript中的结构
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript中的结构EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript中的结构
EN