Javascript'teki yapılar

Önceden, bir dizi ilgili değişkeni saklamam gerektiğinde, bir sınıf oluşturuyordum.

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

Ama bunun iyi bir uygulama olup olmadığını merak ediyorum. Javascript'te bir yapıyı simüle etmenin başka, daha iyi yolları var mı?

Nesne değişmezleri ile oluşturulan nesneler arasındaki tek fark, prototipten miras alınan özelliklerdir.

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

Bir yapı fabrikası yapabilirsin.

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

Ben her zaman nesne değişmezlerini kullanırım

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

Gerçek sorun, bir dildeki yapıların referans türleri değil değer türleri olmaları gerektiğidir. Önerilen yanıtlar, yapılar yerine nesnelerin (referans türleridir) kullanılmasını önermektedir. Bu amacına hizmet edebilirken, bir programcının referans türü yerine değer türlerini (ilkel gibi) kullanmanın faydalarını gerçekten isteyeceği noktasından kaçınıyor. Öncelikle değer türleri bellek sızıntılarına neden olmamalıdır.

Sanırım sizin yaptığınız gibi C benzeri yapıları simüle etmek için bir sınıf oluşturmak en iyi yoldur.

İlgili verileri gruplamanın harika bir yoludur ve parametrelerin işlevlere aktarılmasını kolaylaştırır. Ayrıca, gerçek nesne yönelimli özellikleri simüle etmek için gereken ek çabayı göz önünde bulundurarak, bir JavaScript sınıfının bir C ++ sınıfından çok bir C ++ yapısına benzediğini iddia ediyorum .

JavaScript'i başka bir dile daha çok benzetmeye çalışmanın hızla karmaşıklaştığını keşfettim, ancak JavaScript sınıflarını işlevsiz yapılar olarak kullanmayı tamamen destekliyorum.

Markus'un cevabını takiben , JS'nin daha yeni sürümlerinde (ES6) daha basit bir şekilde Arrow Fonksiyonları ve Rest Parametresini kullanarak bir 'yapı' fabrikası oluşturabilirsiniz :

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

Bunu çalıştırmanın sonucu:

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

Python'un adlandırılmış çiftine benzer görünmesini sağlayabilirsiniz:

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

Ve sonuçlar:

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

Aptal yapılar için nesneler JSON stili kullanıyorum (üye işlevi yok).

ES6 uyumluluğuyla çalışıyorsanız yapıyı tanımlamak için küçük bir kitaplık yaptım.

Bu bir JKT ayrıştırıcısıdır, buradan proje havuzunu kontrol edebilirsiniz JKT Parser

Bir örnek için yapınızı böyle oluşturabilirsiniz

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 

Kurulum için daha fazla iş var, ancak sürdürülebilirlik bir defalık çabayı yeniyorsa, o zaman bu sizin durumunuz olabilir.

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

Avantajları:

• argüman sırasına bağlı değil
• kolayca uzatılabilir
• komut dosyası desteği yazın: