Strukturen in Javascript

Wenn ich zuvor eine Reihe verwandter Variablen speichern musste, habe ich eine Klasse erstellt.

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

Aber ich frage mich, ob dies eine gute Praxis ist. Gibt es andere, bessere Möglichkeiten, eine Struktur in Javascript zu simulieren?

Der einzige Unterschied zwischen Objektliteralen und konstruierten Objekten sind die vom Prototyp geerbten Eigenschaften.

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

Sie könnten eine Strukturfabrik erstellen.

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

Ich benutze immer Objektliterale

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

Das eigentliche Problem ist, dass Strukturen in einer Sprache Werttypen und keine Referenztypen sein sollen. In den vorgeschlagenen Antworten wird vorgeschlagen, anstelle von Strukturen Objekte (Referenztypen) zu verwenden. Dies kann zwar seinen Zweck erfüllen, umgeht jedoch den Punkt, an dem ein Programmierer tatsächlich die Vorteile der Verwendung von Werttypen (wie ein Grundelement) anstelle des Referenztyps haben möchte. Zum einen sollten Werttypen keine Speicherlecks verursachen.

Ich denke, eine Klasse zu erstellen, um C-ähnliche Strukturen zu simulieren, wie Sie es getan haben, ist das Beste Weg.

Dies ist eine großartige Möglichkeit, verwandte Daten zu gruppieren und die Übergabe von Parametern an Funktionen zu vereinfachen. Ich würde auch argumentieren, dass eine JavaScript-Klasse eher einer C ++ - Struktur als einer C ++ - Klasse ähnelt, wenn man bedenkt, wie viel Aufwand erforderlich ist, um echte objektorientierte Features zu simulieren.

Ich habe festgestellt, dass der Versuch, JavaScript einer anderen Sprache ähnlicher zu machen, schnell kompliziert wird, aber ich unterstütze die Verwendung von JavaScript-Klassen als funktionslose Strukturen voll und ganz.

Nach Markus ' Antwort können Sie in neueren Versionen von JS (ES6, glaube ich) eine' struct'-Factory einfacher erstellen, indem Sie die Pfeilfunktionen und den Rest-Parameter wie folgt verwenden:

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

Das Ergebnis dieser Ausführung ist:

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

Sie können es ähnlich wie Pythons Namedtuple aussehen lassen:

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

Und die Ergebnisse:

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

Ich verwende Objekte im JSON-Stil für dumme Strukturen (keine Mitgliedsfunktionen).

Ich habe eine kleine Bibliothek erstellt, um struct zu definieren, wenn Sie mit ES6-Kompatibilität arbeiten.

Es ist ein JKT-Parser, den Sie hier im Projekt-Repository auschecken können auschecken können. JKT-Parser

Zum Beispiel können Sie Ihre Struktur so erstellen

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 

Das Einrichten ist mehr Arbeit, aber wenn die Wartbarkeit die einmalige Anstrengung übertrifft, kann dies Ihr Fall sein.

/**
 * @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;
    }
}

Vorteile:

• nicht an die Argumentreihenfolge gebunden
• leicht ausziehbar
• Unterstützung für Typenskripte: