Structs em Javascript

Anteriormente, quando eu precisava armazenar várias variáveis ​​relacionadas, eu criava uma classe.

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')
];

Mas estou me perguntando se essa é uma boa prática. Existe alguma outra maneira melhor de simular uma estrutura em Javascript?

A única diferença entre literais de objeto e objetos construídos são as propriedades herdadas do protótipo.

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

Você poderia fazer uma fábrica de estruturas.

function makeStruct(names) {
  var names = names.split(' ');
  var count = names.length;
  function constructor() {
    for (var i = 0; i < 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

Eu sempre uso literais de objeto

{id: 1, speaker:"john", country: "au"}

O verdadeiro problema é que as estruturas em uma linguagem devem ser tipos de valor e não tipos de referência. As respostas propostas sugerem o uso de objetos (que são tipos de referência) no lugar de estruturas. Embora isso possa servir ao seu propósito, ele contorna o ponto de que um programador realmente desejaria os benefícios de usar tipos de valor (como um primitivo) em vez do tipo de referência. Os tipos de valor, por exemplo, não devem causar vazamentos de memória.

Acho que criar uma classe para simular estruturas semelhantes a C, como você tem feito, é a melhor maneira.

É uma ótima maneira de agrupar dados relacionados e simplifica a passagem de parâmetros para funções. Eu também diria que uma classe JavaScript é mais parecida com uma estrutura C ++ do que com uma classe C ++, considerando o esforço adicional necessário para simular recursos reais orientados a objetos.

Descobri que tentar tornar o JavaScript mais parecido com outra linguagem fica complicado rápido, mas eu apoio totalmente o uso de classes JavaScript como estruturas sem função.

Seguindo a resposta de Markus , em versões mais recentes de JS (ES6 eu acho), você pode criar uma fábrica de 'estrutura' de forma mais simples usando Funções de seta e Parâmetro de descanso como:

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);

O resultado disso é:

[ { id: 1, speaker: 'john', country: 'au' },
  { id: 2, speaker: 'mary', country: 'us' } ]
1
john
au

Você pode torná-lo semelhante ao namedtuple do Python:

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);

E os resultados:

[ { _name: 'Item', id: 1, speaker: 'john', country: 'au' },
  { _name: 'Item', id: 2, speaker: 'mary', country: 'us' } ]
1
john
au

Eu uso objetos de estilo JSON para estruturas burras (sem funções de membro).

Fiz uma pequena biblioteca para definir struct se você trabalha com compatibilidade ES6.

É um analisador JKT, você pode verificar o repositório do projeto aqui. JKT Parser

Por exemplo, você pode criar sua estrutura como esta

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 

É mais trabalhoso configurar, mas se a manutenção supera o esforço único, então este pode ser o seu caso.

/**
 * @class
 */
class Reference {

    /**
     * @constructs Reference
     * @param {Object} p The properties.
     * @param {String} p.class The class name.
     * @param {String} p.field The field name.
     */
    constructor(p={}) {
        this.class = p.class;
        this.field = p.field;
    }
}

Vantagens:

• não vinculado à ordem do argumento
• facilmente extensível
• digite suporte de script: