檢查JS對象是否匹配值的最佳方法

Question

我需要擴展（從2到最大10）並優化一些模型導入，但是我想不出一種檢查javascript對象是否匹配大量if語句以外的值的好方法，所以我想我會在這里問，看看是否有經驗豐富的js開發人員知道實現此目標的好方法。

基本結構：

//a is the object, it contains some basic, unrelated information and
//either 2, 6 or 10 id's & id2's
//unused id's have a value of 0.
//Sorry for the faulty variables, i was in a rush and just needed to show that xid & xid2 fit together and yid & yid2 fit together, etc.
//input 1
a.1Id = x; //Primary, Desides the actual model to import
a.1Id2 = y; //Secondary, Desides version of the model, specific colours, features, etc
//input 2
a.2Id = z;
a.2Id2 = x;

（最多10個輸入，a.10Id和Id2）

現在，我需要檢查比賽。

如果1Id與2Id相同，而1Id2與2Id2相同，則僅導入一次模型。

當只有兩個模型輸入時，這很簡單。

//the import is not actually structured as var importX, 
//they are pushed to another object and then the loader loads each of them with a for..loop
if (a.1Id === a.2Id && a.1Id2 === a.2Id2){
  var import1 = a.1Id;
  var import12 = a.1Id2;
} else {
  var import1 = a.1Id;
  var import12 = a.1Id2;
  var import2 = a.2Id;
  var import22 = a.2Id2;
}

但是除此之外，您可以想象，如果使用if語句檢查有多少個相同的語句，它會變得很繁重。

因此，要總結一下，我基本上希望可以使用某種函數或算法，檢查所有xId和xId2輸入值是否與其他任何值匹配，然后僅將匹配的輸入之一發送到加載程序，從而避免多次導入同一模型。

Answer 1

還有很多問題沒有答案，因此這里將每個Id [n]與下一個Id [n + 1]進行比較。 它不能完全解決問題，但應為您指明正確的方向。

我必須更改您的對象，因為對象屬性不能以數字開頭。 我還作了一些假設，例如值實際上是字符串（因為在示例中顯示它們時，它們實際上是變量）。

var a = {
  Id1_: '1',
  Id1_2: '1a',
  Id2_: '1',
  Id2_2: '2a',
  Id3_: '3',
  Id3_2: '3a',
  Id4_: '1',
  Id4_2: '1a',
  Id5_: '2',
  Id5_2: '2a',
  Id6_: '3',
  Id6_2: '3a',
  Id7_: '2',
  Id7_2: '2a',
  Id8_: '3',
  Id8_2: '3a',
  Id9_: '1',
  Id9_2: '1a',
  Id10_: '1',
  Id10_2: '2a'
};

我要做的第一件事是來自a的Object.keys ，因為這將允許我遍歷所有鍵，而無需提前知道它們可能是什么。

var k1 = Object.keys(a);

然后，我將對象和鍵傳遞給函數：

checkMatches(k1, a);

該函數按順序檢查對象，將第一個鍵與第二個鍵進行比較，將第二個鍵與第三個鍵進行比較，依此類推-將任何與另一個鍵不匹配的鍵推入數組中。 我console.log每個比較中涉及的鍵。 這是功能。

function checkMatches(k, o){
  var results = [];
  var s = "Id", f = "_";
  var nextId = 2;
  var idCnt = 0;
  var propt = "";
  for (var i = 0; i < k.length; i++){ 
    idCnt += 1;
    if (idCnt === 3) {
      idCnt = 1;
      nextId += 1;
    }

    propt = s + nextId + f;

    if (idCnt === 2) {
      propt += "2";    
    } 

    console.log(k[i] + ": " + o[k[i]] + " vs " + propt + ": " + o[propt]);
    if (o[k[i]] !== o[propt]) {
      results.push({ id: k[i], value: o[k[i]] });
    }
  } 
  return results;
}

就像我說的那樣，它不能完全解決您的問題-主要是因為有很多細節可能會改變最終結果。

這是一個jsbin，它按概述工作。

Answer 2

在我看來，您只是想將插入的內容放入數組中，然后每次在數組中循環。 這將使您可以擴展到任意大小，而不會失去if語句的控制權。

基本上看起來像這樣：

var imported = [];

var processImport = function (obj) {
  // there are better ways, but this will work:
  var found = false;
  for (var i = 0; i < imported.length; ++i) {
    if (imported[i].id == obj.id && imported[i].id2 == obj.id2) {
      found = true;
      break;
    }
  }
  if (!found) {
    imported.push({
      id: obj.id,
      id2: obj.id2
    });
  }
}

也許您正在尋找其他東西，但是根據您提供的代碼，這可能會有所幫助。

祝好運！

 var imported = []; var processImport = function (obj) { // there are better ways, but this will work: var found = false; for (var i = 0; i < imported.length; ++i) { if (imported[i].id == obj.id && imported[i].id2 == obj.id2) { found = true; break; } } if (!found) { imported.push({ id: obj.id, id2: obj.id2 }); } } var toImport = [{ id: 1, id2: 1 }, { id: 1, id2: 2 }, { id: 2, id2: 1 }, { id: 1, id2: 1 }]; for (var j = 0; j < toImport.length; ++j) { processImport(toImport[j]); } alert(imported.length); 

Answer 3

最后結果。

//Models.
var mIds = []; //Store id's to import

function Model() {
  this.Id = 0;
  this.Id2 = 0;
}

function newModel(data) {

  var found = false;
  for (var i = 0; i < mIds.length; i++) {
    if (mIds[i].Id === data.Id && mIds[i].Id2 === data.Id2) {
      found = true;
      break;
    }
  }
  if (!found) {
    var model = new Model();
    model.Id = data.Id;
    model.Id2 = data.Id2;

    mIds.push( model );
  }


};

模型以2、6或10組輸入。

如前所述，“ a”包含除id / id2之外的其他信息，我希望使用@whipdancer的代碼來處理將id發送到newModel函數，但是我必須像這樣處理它，否則它將需要重寫我的代碼創建了“ a”，我對此並不感興趣，無論如何最多可以有10個模型，所以我想這沒關系。

if (a.count > 1) { //atleast 2 models
  var data1 = {};
  data1.Id = a.Id1;
  data1.Id2 = a.Id1_2;
  newModel(data1);
  var data2 = {};
  data2.Id = a.Id2;
  data2.Id2 = a.Id2_2;
  newModel(data2);

  //delete data1;
  //delete data2;
}
if (a.count > 5) { //atleast 6 models
  var data3 = {};
  data3.Id = a.Id3;
  data3.Id2 = a.Id3_2;
  newModel(data3);

  var data4 = {};
  data4.Id = a.Id4;
  data4.Id2 = a.Id4_2;
  newModel(data4);

  var data5 = {};
  data5.Id = a.Id5;
  data5.Id2 = a.Id5_2;
  newModel(data5);

  var data6 = {};
  data6.Id = a.Id6;
  data6.Id2 = a.Id6_2;
  newModel(data6);

}
if (a.count > 9) { //10 models
  var data7 = {};
  data7.Id = a.Id7;
  data7.Id2 = a.Id7_2;
  newModel(data7);

  var data8 = {};
  data8.Id = a.Id8;
  data8.Id2 = a.Id8_2;
  newModel(data8);

  var data9 = {};
  data9.Id = a.Id9;
  data9.Id2 = a.Id9_2;
  newModel(data9);

  var data10 = {};
  data10.Id = a.Id10;
  data10.Id2 = a.Id10_2;
  newModel(data10);

}