Question

我写了这个算法，它操纵了两个数组。 letter是主要版本，fake是副本。

基本上我使用循环来运行letter和fake，如果它们具有相同的'd'值，tmp数组将被推送letter[i]值。但只有一次！我不希望tmp在其'd'值中包含双胞胎值。

我的算法正在运行，但它似乎永远不会进入我的“else”内部以在“tmp”内推送空{d : ""}。

另外，我正在使用localeCompare()这是一个字符串方法，用于检查两个字符串是否等于，但如果我使用的话：===我得到相同的结果，所以我不确定它有用，是吗？

问题

我没有预期的结果......我的算法永远不会在第二次推进时进入else。所以加倍，保留在最终的tmp数组中。

// 'd' letter values : a, b, b, c, d, d

var letter = [
{a : 'one', d : 'a'}, 
{a : 'two', d : 'b'}, 
{a : 'three', d : 'b'}, 
{a : 'four', d : 'c'},
{a : 'five', d : 'd'},
{a : 'six', d : 'd'}];

// 'd' fake values : a, b, b, c, d, d

var fake = [
{d : 'a'}, 
{d : 'b'}, 
{d : 'b'}, 
{d : 'c'}, 
{d : 'd'}, 
{d : 'd'}];

/* tmp output i would like : 
{a : 'one', d : a}, 
{a : 'two', d : b}, 
{a : 'three', d : ""}, 
{a : 'four', d : c}, 
{a : 'five', d : d}, 
{a : 'six', d : ""} 
*/

function sortMyArrays(letter, fake)
{

var tmp = [];

var k = 0;
var i = 0;
var l = 0;
var size = letter.length;

do
{
    if(l !== 0)
    {
        k = l;
    }

    if(letter[k].d !== undefined)
    {   
        var lettString = letter[k].d;
        var fakeString = fake[i].d;
     
        // localeCompare() === 0 if strings are equals
        if(lettString.localeCompare(fakeString) === 0)
        {
            do
            {
                    if(i >= k)
                    {
                        // Always enter in this if
                        if(k === i)
                        {
                            tmp.push({a : letter[i].a , d : letter[i].d});
                      
                            l += 1;
                        }
                        // Never enter in the else...
                        else
                        {
                            tmp.push({a : letter[i].a , d : ""});
                     
                            l += 1; 
                        }
                    }
                    i += 1;
            }
            while(letter[k].d === fake[i].d);
         
        }
    }
}
while(k < size);

console.log("Result into tmp array is : ", tmp);

}

Answer 1

我还没有真正弄清楚你在寻找这个算法，但我实现了你想要的输出。

function sortMyArrays(letter, fake) {

  var tmp = [];

  var index = 0;
  var usedDValues = [];
  var size = letter.length;

  do {
    if (letter[index].d !== undefined) {
      var lettString = letter[index].d;
      var fakeString = fake[index].d;

      // localeCompare() === 0 if strings are equals
      if (lettString === fakeString) {
        // if usedDValues.indexOf(lettString) returns -1, that d value has not been used yet.
        if (usedDValues.indexOf(lettString) === -1) {
          tmp.push({
            a: letter[index].a,
            d: letter[index].d
          });
        } else {
          tmp.push({
            a: letter[index].a,
            d: ""
          });
        }

        usedDValues.push(lettString);
      }
    }

    index += 1;
  }
  while (index < size);

  console.log("Result into tmp array is : ", tmp);
}

我在这里做的主要改变是改变你独特的'd'比较。使用包含所有以前使用的'd'值的数组，您只需检查该数组是否已使用它。这不是记忆明智的最干净的方法，但它易于阅读。您还可以检查d数组中之前的temp值，看看您是否已使用该d值。

坚持===超过localeCompare进行字符串相等检查。 localCompare旨在为您提供按字母顺序排在第一位的字符串的顺序。

JS逻辑算法不起作用

问题

1 个答案: