Estructuras en Javascript

Anteriormente, cuando necesitaba almacenar una serie de variables relacionadas, creaba una clase.

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

Pero me pregunto si esta es una buena práctica. ¿Existen otras formas mejores de simular una estructura en Javascript?

La única diferencia entre los objetos literales y los objetos construidos son las propiedades heredadas del prototipo.

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

Podrías hacer una fábrica de estructuras.

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

Siempre uso literales de objeto

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

El problema real es que se supone que las estructuras en un lenguaje son tipos de valor, no tipos de referencia. Las respuestas propuestas sugieren el uso de objetos (que son tipos de referencia) en lugar de estructuras. Si bien esto puede cumplir su propósito, evita el punto de que un programador realmente querría los beneficios de usar tipos de valor (como un primitivo) en lugar del tipo de referencia. Los tipos de valor, por ejemplo, no deberían causar pérdidas de memoria.

Creo que crear una clase para simular estructuras similares a C, como lo has estado haciendo, es la mejor manera.

Es una excelente manera de agrupar datos relacionados y simplifica el paso de parámetros a funciones. También diría que una clase de JavaScript se parece más a una estructura de C ++ que a una clase de C ++, considerando el esfuerzo adicional necesario para simular características orientadas a objetos reales.

Descubrí que tratar de hacer que JavaScript se parezca más a otro lenguaje se vuelve complicado rápidamente, pero soy totalmente compatible con el uso de clases de JavaScript como estructuras sin funciones.

Siguiendo la respuesta de Markus , en las versiones más nuevas de JS (ES6, creo), puede crear una fábrica de 'estructuras' de manera más simple usando las funciones de flecha y el parámetro de descanso de esta manera:

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

El resultado de ejecutar esto es:

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

Puede hacer que se vea similar a la tupla con nombre de 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);

Y los resultados:

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

Utilizo objetos estilo JSON para estructuras tontas (sin funciones miembro).

Hice una pequeña biblioteca para definir la estructura si trabaja con compatibilidad con ES6.

Es un analizador JKT, puede consultar el repositorio del proyecto aquí JKT Parser

Por ejemplo, puede crear su estructura así

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 

Es más trabajo de configurar, pero si la capacidad de mantenimiento supera el esfuerzo de una sola vez, este puede ser su 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;
    }
}

Ventajas:

• no vinculado al orden de los argumentos
• fácilmente ampliable
• soporte de escritura de tipo: