在javascript中创建无冗余的搜索字符串数组

给定一个用字符串填充的数组。我需要以下行为：

foo = []
foo = add_search_string(foo, 'a')

foo应等于['a']

foo = add_search_string(foo, 'a')

foo应该等于['a']，因为'a'已经是搜索字符串

foo = add_search_string(foo, 'ab')

---

foo应该等于['ab']，因为'a'是'ab'的子字符串，因此可以删除

foo = add_search_string(foo, 'a')

foo应等于['ab']，原因与上述相同

foo = add_search_string(foo, 'c')

foo应等于['ab'，'c']

我的函数如下所示：

function add_search_string(search_strings, new_search_string) {
    var keep = true;
    var new_search_strings = []
    $.each(search_strings, function(i, search_string) {
        if (new_search_string == search_string) {
            keep = false;
        } else if (search_string.indexOf(new_search_string) >= 0) {
            keep = false;
        }
    });

    if (keep) {
        $.each(search_strings, function(i, search_string) {
            if (new_search_string.indexOf(search_string) == -1) {
                new_search_strings.push(search_string);
            }
        });
        new_search_strings.push(new_search_string);
        search_strings = new_search_strings;
    }
    return search_strings;
}

function add_search_string(search_strings, new_search_string) {
   var replaced = false;
   for (var i = search_strings.length -1; i >= 0; i--) {
      if (search_strings[i].indexOf(new_search_string) != -1) {
          // string found, so just return
          return search_strings;
      }
      if (new_search_string.indexOf(search_strings[i]) != -1){
          // existing string is a substring of new search string
          // if it already matched another element just remove the current one
          // otherwise replace the current one
          if (replaced)
              search_strings.splice(i,1);
          else
              search_strings[i] = new_search_string;
          replaced = true;
      }
   }
   // if not found add it
   if (!replaced)
      search_strings.push(new_search_string);
   return search_strings;
}

---

有“更好”的方法吗？

没有快速的内置方法。如果你想测试真正的子字符串，而不仅仅是“从开始”，这是一个二次问题，这意味着函数将花费n^2倍于键长度n的时间。如果钥匙不太长，应该可以用

没有一种快速的内置方法可以做到这一点。如果你想测试真正的子字符串，而不仅仅是“从开始”，这是一个二次问题，这意味着函数将花费n^2倍于键长度n的时间。如果钥匙不太长，应该可以用

如果想要不断更新同一个数组，我可能会这样做：

function add_search_string(search_strings, new_search_string) {
    var keep = true;
    var new_search_strings = []
    $.each(search_strings, function(i, search_string) {
        if (new_search_string == search_string) {
            keep = false;
        } else if (search_string.indexOf(new_search_string) >= 0) {
            keep = false;
        }
    });

    if (keep) {
        $.each(search_strings, function(i, search_string) {
            if (new_search_string.indexOf(search_string) == -1) {
                new_search_strings.push(search_string);
            }
        });
        new_search_strings.push(new_search_string);
        search_strings = new_search_strings;
    }
    return search_strings;
}

function add_search_string(search_strings, new_search_string) {
   var replaced = false;
   for (var i = search_strings.length -1; i >= 0; i--) {
      if (search_strings[i].indexOf(new_search_string) != -1) {
          // string found, so just return
          return search_strings;
      }
      if (new_search_string.indexOf(search_strings[i]) != -1){
          // existing string is a substring of new search string
          // if it already matched another element just remove the current one
          // otherwise replace the current one
          if (replaced)
              search_strings.splice(i,1);
          else
              search_strings[i] = new_search_string;
          replaced = true;
      }
   }
   // if not found add it
   if (!replaced)
      search_strings.push(new_search_string);
   return search_strings;
}

尽管此函数返回数组，但它也会更新传入的数组，这样在调用函数时就不必重新分配数组，您只需说：

add_search_string(foo, 'a');

---

如果打算继续更新相同的数组，我可能会这样做：

function add_search_string(search_strings, new_search_string) {
    var keep = true;
    var new_search_strings = []
    $.each(search_strings, function(i, search_string) {
        if (new_search_string == search_string) {
            keep = false;
        } else if (search_string.indexOf(new_search_string) >= 0) {
            keep = false;
        }
    });

    if (keep) {
        $.each(search_strings, function(i, search_string) {
            if (new_search_string.indexOf(search_string) == -1) {
                new_search_strings.push(search_string);
            }
        });
        new_search_strings.push(new_search_string);
        search_strings = new_search_strings;
    }
    return search_strings;
}

function add_search_string(search_strings, new_search_string) {
   var replaced = false;
   for (var i = search_strings.length -1; i >= 0; i--) {
      if (search_strings[i].indexOf(new_search_string) != -1) {
          // string found, so just return
          return search_strings;
      }
      if (new_search_string.indexOf(search_strings[i]) != -1){
          // existing string is a substring of new search string
          // if it already matched another element just remove the current one
          // otherwise replace the current one
          if (replaced)
              search_strings.splice(i,1);
          else
              search_strings[i] = new_search_string;
          replaced = true;
      }
   }
   // if not found add it
   if (!replaced)
      search_strings.push(new_search_string);
   return search_strings;
}

尽管此函数返回数组，但它也会更新传入的数组，这样在调用函数时就不必重新分配数组，您只需说：

add_search_string(foo, 'a');

---

对于performant实现，您可以使用a在搜索字符串（及其子集）之间快速搜索。但是，只有在简单实现（如您的或@nnnnnn的实现）确实存在问题时，才应该这样做，因为trie会增加一个巨大的复杂性层。

对于性能实现，您可以使用a在搜索字符串（及其子集）之间快速搜索。但是，只有在简单实现（如您的或@nnnnnn的实现）确实存在问题时，您才应该这样做，因为trie会增加一个巨大的复杂性层。

由于您需要一个“contain”操作符，数组join（）可能是有效的：

var str = search_strings.join("|");

// if the new string can't be found
if str.indexOf(new_search_string)==-1 {
    // remove sub-strings of new_search_string (need to start from the top)
    for (var i=search_strings.length-1;i>=0;i--) {
        if (new_search_string.indexOf(search_strings[i])!=-1) {search_strings.splice(i,1);}
    }
    // add new
    search_strings.push(new_search_string);
}
// else new_search_string can be ignored

为了更快的处理，您还可以考虑按字符串长度排序或过滤数组，并且只通过比NexOxStrCHYString短的字符串循环。

< P>当您需要一个“包含”操作符时，数组连接（）可能是有效的：

var str = search_strings.join("|");

// if the new string can't be found
if str.indexOf(new_search_string)==-1 {
    // remove sub-strings of new_search_string (need to start from the top)
    for (var i=search_strings.length-1;i>=0;i--) {
        if (new_search_string.indexOf(search_strings[i])!=-1) {search_strings.splice(i,1);}
    }
    // add new
    search_strings.push(new_search_string);
}
// else new_search_string can be ignored

---

---

<>对于更快的处理，您还可以考虑按字符串长度排序或过滤数组，并且只循环通过比NexStryChyString短的字符串。

是<代码>“B”< /代码>用于此目的的<代码> AB“< /代码>的子串？或者更多的是关于“以开头”？“b”将是“ab”的子字符串。对于已经包含“ab”的数组，添加搜索字符串“b”也会导致['ab']，因此如果

foo=['ab']

，然后我们使用

foo=add\u search\u string（foo，'def'）

应该

foo

现在等于

abdef

或

def

？因此根据Bergi下面的评论

add\u search\u string（['a'，'b'，'abc'））

应该返回

['abc']

（组合多个匹配）？'a'是'ab'的子字符串，因此可以删除=>因为您的目的是执行and搜索？（结果必须匹配所有字符串）是否为此目的而将

“b”

作为

“ab”

的子字符串？或者更多的是关于“以开头”？“b”将是“ab”的子字符串。对于已经包含“ab”的数组，添加搜索字符串“b”也会导致['ab']，因此如果

foo=['ab']

，然后我们使用

foo=add\u search\u string（foo，'def'）

应该

foo

现在等于

abdef

或

def

？因此根据Bergi下面的评论

add\u search\u string（['a'，'b'，'abc'））

应该返回

['abc']

（组合多个匹配）？'a'是'ab'的子字符串，因此可以删除=>因为您的目的是执行and搜索？（结果必须匹配所有字符串）这正是我想要阻止的。在@nnnnnn使用的示例中，它实际上是一个N*M问题。N表示新钥匙的长度，M表示现有钥匙的数量：但他没有从另一个方向检查周围。。。新搜索字符串使旧搜索字符串过时的情况正是我想要阻止的。在@nnnnnn使用的示例中，这实际上是一个N*M问题。N表示新钥匙的长度，M表示现有钥匙的数量：但他没有从另一个方向检查周围。。。如果一个新的搜索字符串使旧的搜索字符串过时，第二个条件不能被打破，想想

add（['d'，'f'，'def'）

Good point@Bergi，我没有想到一个字符串会重叠多个元素。确切地说

add（['d'，'f'，'def'）

应该会导致

['def']]

OK，答案已更新，以考虑到这一点。（我希望如此。）如果新字符串是现有元素的子字符串，只需像我最初做的那样返回，但如果现有元素是新字符串的子字符串，则替换其中一个并删除其余的。第二个条件不能中断，请考虑

add（['d'，'f'，'def'）

Good point@Bergi，我没有想到一个字符串会重叠多个元素。确切地说，

add（['d'，'f'，'def'）

应该会导致

['def']

好的，答案会更新以允许这样做。（我希望如此。）如果新字符串是现有元素的子字符串，只需返回，正如我最初所做的那样，但是如果现有元素是新字符串的子字符串，则替换其中一个并删除其余元素。