合理的JavaScript模糊搜索

我正在寻找一个模糊搜索JavaScript库来过滤数组。我尝试使用Fuzzyset.js和fuse.js，但是结果很糟糕（可以在链接的页面上尝试一些演示）。

在对Levenshtein距离进行了一些阅读之后，我对用户输入时所寻找的内容的近似性感到不满意。对于那些不知道的人，系统会计算要使两个字符串匹配，需要多少个插入，删除和替换。

在Levenshtein-Demerau模型中修复的一个明显缺陷是，blub和boob都被认为与bulb相似（都需要两次替换）。很明显，但是，灯泡更类似于咕噜比布布是的，我刚才提到的模型识别到，允许换位。

我想在文本补全的背景下使用它，因此，如果我有一个数组['international', 'splint', 'tinder']，并且我的查询是int，我认为International应该比splint排名更高，即使前者的得分（高=差）为10与后者的3。

因此，我正在寻找（并且如果不存在的话将创建）一个执行以下操作的库：

• 权衡不同的文本操作
• 根据每个单词在单词中出现的位置，对每个操作进行加权加权（较早的操作比较晚的操作成本更高）
• 返回按相关性排序的结果列表

有没有人遇到过这样的事情？我意识到，StackOverflow并不是要求软件推荐的地方，但是上面的隐式（不再是！）是：我是否正在以正确的方式考虑？

编辑

我找到了一篇很好的论文（pdf）。一些注释和摘录：

仿射编辑距离功能为插入或删除序列分配了相对较低的开销

Monger-Elkan距离函数（Monge＆Elkan 1996），它是Smith-Waterman距离函数（Durban et al。1998）的仿射变体，具有特定的成本参数

对于史密斯-沃特曼距离（Wikipedia），“史密斯-沃特曼算法无需查看总序列，而是比较所有可能长度的片段并优化相似性度量。” 这是n-gram方法。

大致上类似的度量标准（不是基于编辑距离模型）是Jaro度量标准（Jaro 1995； 1989； Winkler 1999）。在记录链接文献中，使用此方法的变体已获得了良好的结果，该变体基于两个字符串之间的公共字符的数量和顺序。

由于Winkler（1999）的不同，它也使用最长公共前缀的长度P

（似乎主要用于短字符串）

为了完成文本，Monger-Elkan和Jaro-Winkler方法似乎最有意义。Winkler对Jaro度量标准的添加有效地对单词的开头进行了更重的加权。而且，Monger-Elkan的仿射方面意味着完成一个单词的必要性（这只是一系列加法）不会太不利于它。

结论：

TFIDF排名在几个基于令牌的距离度量中表现最好，而Monge和Elkan提出的经过调整的仿射间隔编辑距离度量在几个字符串编辑距离度量中表现最好。令人惊讶的良好距离度量是Jaro提出并随后由Winkler扩展的快速启发式方案。这几乎和Monge-Elkan方案一样有效，但是速度要快一个数量级。结合TFIDF方法和Jaro-Winkler的一种简单方法是用基于Jaro-Winkler方案的近似令牌匹配替换TFIDF中使用的精确令牌匹配。平均而言，此组合的性能比Jaro-Winkler或TFIDF都要好，偶尔也要好得多。在性能上也接近本文所考虑的几种最佳指标的学习组合。

好问题！但是我的想法是，与其尝试修改Levenshtein-Demerau，不如尝试使用其他算法或对两种算法的结果进行合并/加权，可能会更好。

令我惊讶的是，Levenshtein-Demerau并没有特别重视与“起始前缀”的完全匹配或接近匹配-但您明显的用户期望会如此。

我搜索“比Levenshtein更好”，并且发现了以下内容：

http://www.joyofdata.de/blog/comparison-of-string-distance-algorithms/

这提到了许多“字符串距离”度量。看起来与您的需求特别相关的三个是：

1. 最长公共子字符串距离：两个字符串中必须删除的最小符号数，直到得到的子字符串相同为止。

2. q-gram距离：两个字符串的N-gram矢量之间的绝对差之和。

3. 雅卡距离： 1分钟，表示共享的N-gram与所有观察到的N-gram的商。

也许您可以使用这些度量的加权组合（或最小值），与Levenshtein一起使用-常见的子字符串，常见的N-gram或Jaccard都将非常喜欢相似的字符串-或尝试仅使用Jaccard吗？

根据列表/数据库的大小，这些算法可能会适度昂贵。对于我实施的模糊搜索，我使用了可配置数量的N-gram作为数据库中的“检索关键字”，然后运行了昂贵的字符串距离度量以将它们按首选项顺序进行排序。

我写了一些有关SQL模糊字符串搜索的注释。看到：

• http://literatejava.com/sql/fuzzy-string-search-sql/

我尝试使用像fuse.js这样的现有模糊库，也发现它们很糟糕，所以我写了一个基本上像sublime搜索一样的库。https://github.com/farzher/fuzzysort

它允许的唯一错字是移调。它非常可靠（1k星，0期），非常快，可以轻松处理您的案件：

fuzzysort.go('int', ['international', 'splint', 'tinder'])
// [{highlighted: '*int*ernational', score: 10}, {highlighted: 'spl*int*', socre: 3003}]

这是我使用过几次的技术...它给出了很好的结果。虽然并不能完成您所要求的一切。而且，如果列表很大，这可能会很昂贵。

get_bigrams = (string) ->
    s = string.toLowerCase()
    v = new Array(s.length - 1)
    for i in [0..v.length] by 1
        v[i] = s.slice(i, i + 2)
    return v

string_similarity = (str1, str2) ->
    if str1.length > 0 and str2.length > 0
        pairs1 = get_bigrams(str1)
        pairs2 = get_bigrams(str2)
        union = pairs1.length + pairs2.length
        hit_count = 0
        for x in pairs1
            for y in pairs2
                if x is y
                    hit_count++
        if hit_count > 0
            return ((2.0 * hit_count) / union)
    return 0.0

string_similarity将两个字符串传递给它们，它们之间将返回一个数字0，1.0具体取决于它们之间的相似程度。本示例使用Lo-Dash

使用示例...

query = 'jenny Jackson'
names = ['John Jackson', 'Jack Johnson', 'Jerry Smith', 'Jenny Smith']

results = []
for name in names
    relevance = string_similarity(query, name)
    obj = {name: name, relevance: relevance}
    results.push(obj)

results = _.first(_.sortBy(results, 'relevance').reverse(), 10)

console.log results

此外....有一个小提琴

确保您的控制台处于打开状态，否则您将看不到任何东西:)

这是我的模糊匹配的简短函数：

function fuzzyMatch(pattern, str) {
  pattern = '.*' + pattern.split('').join('.*') + '.*';
  const re = new RegExp(pattern);
  return re.test(str);
}

您可以看看Atom的https://github.com/atom/fuzzaldrin/ lib。

它在npm上可用，具有简单的API，对我来说还可以。

> fuzzaldrin.filter(['international', 'splint', 'tinder'], 'int');
< ["international", "splint"]

2019年11月更新。我发现保险丝有一些不错的升级。但是，我无法使用bool（即OR，AND等操作符），也无法使用API​​搜索界面来过滤结果。

我发现了nextapps-de/flexsearch：https : //github.com/nextapps-de/flexsearch，我相信它远远超过了我尝试过的许多其他javascript搜索库，并且它具有支持bool的，过滤搜索和分页功能。

您可以为搜索数据（即存储空间）输入一个javascript对象列表，并且该API的文档也相当详尽：https： //github.com/nextapps-de/flexsearch#api-overview

到目前为止，我已经为近10,000条记录建立了索引，而我的搜索几乎是立即进行的；即每次搜索的时间不明显。

这是@InternalFX提供的解决方案，但是在JS中（我使用了它是为了共享）：

function get_bigrams(string){
  var s = string.toLowerCase()
  var v = s.split('');
  for(var i=0; i<v.length; i++){ v[i] = s.slice(i, i + 2); }
  return v;
}

function string_similarity(str1, str2){
  if(str1.length>0 && str2.length>0){
    var pairs1 = get_bigrams(str1);
    var pairs2 = get_bigrams(str2);
    var union = pairs1.length + pairs2.length;
    var hits = 0;
    for(var x=0; x<pairs1.length; x++){
      for(var y=0; y<pairs2.length; y++){
        if(pairs1[x]==pairs2[y]) hits++;
    }}
    if(hits>0) return ((2.0 * hits) / union);
  }
  return 0.0
}

我通过InternalFx修复了CoffeeScript bigram解决方案的问题，并使其成为通用的n-gram解决方案（您可以自定义克的大小）。

这是TypeScript，但是您可以删除类型注释，它也可以像普通JavaScript一样正常工作。

/**
 * Compares the similarity between two strings using an n-gram comparison method. 
 * The grams default to length 2.
 * @param str1 The first string to compare.
 * @param str2 The second string to compare.
 * @param gramSize The size of the grams. Defaults to length 2.
 */
function stringSimilarity(str1: string, str2: string, gramSize: number = 2) {
  function getNGrams(s: string, len: number) {
    s = ' '.repeat(len - 1) + s.toLowerCase() + ' '.repeat(len - 1);
    let v = new Array(s.length - len + 1);
    for (let i = 0; i < v.length; i++) {
      v[i] = s.slice(i, i + len);
    }
    return v;
  }

  if (!str1?.length || !str2?.length) { return 0.0; }

  //Order the strings by length so the order they're passed in doesn't matter 
  //and so the smaller string's ngrams are always the ones in the set
  let s1 = str1.length < str2.length ? str1 : str2;
  let s2 = str1.length < str2.length ? str2 : str1;

  let pairs1 = getNGrams(s1, gramSize);
  let pairs2 = getNGrams(s2, gramSize);
  let set = new Set<string>(pairs1);

  let total = pairs2.length;
  let hits = 0;
  for (let item of pairs2) {
    if (set.delete(item)) {
      hits++;
    }
  }
  return hits / total;
}

例子：

console.log(stringSimilarity("Dog", "Dog"))
console.log(stringSimilarity("WolfmanJackIsDaBomb", "WolfmanJackIsDaBest"))
console.log(stringSimilarity("DateCreated", "CreatedDate"))
console.log(stringSimilarity("a", "b"))
console.log(stringSimilarity("CreateDt", "DateCreted"))
console.log(stringSimilarity("Phyllis", "PyllisX"))
console.log(stringSimilarity("Phyllis", "Pylhlis"))
console.log(stringSimilarity("cat", "cut"))
console.log(stringSimilarity("cat", "Cnut"))
console.log(stringSimilarity("cc", "Cccccccccccccccccccccccccccccccc"))
console.log(stringSimilarity("ab", "ababababababababababababababab"))
console.log(stringSimilarity("a whole long thing", "a"))
console.log(stringSimilarity("a", "a whole long thing"))
console.log(stringSimilarity("", "a non empty string"))
console.log(stringSimilarity(null, "a non empty string"))

在TypeScript游乐场中尝试

(function (int) {
    $("input[id=input]")
        .on("input", {
        sort: int
    }, function (e) {
        $.each(e.data.sort, function (index, value) {
          if ( value.indexOf($(e.target).val()) != -1 
              && value.charAt(0) === $(e.target).val().charAt(0) 
              && $(e.target).val().length === 3 ) {
                $("output[for=input]").val(value);
          };
          return false
        });
        return false
    });
}(["international", "splint", "tinder"]))

jsfiddle http://jsfiddle.net/guest271314/QP7z5/

查看我的Google表格加载项Flookup并使用此功能：

Flookup (lookupValue, tableArray, lookupCol, indexNum, threshold, [rank])

参数详细信息是：

1. lookupValue：您正在寻找的价值
2. tableArray：您要搜索的表
3. lookupCol：您要搜索的列
4. indexNum：要从中返回数据的列
5. threshold：相似度百分比，低于此百分比不应返回数据
6. rank：第n个最佳比赛（即，如果第一个比赛不符合您的喜好）

这确实可以满足您的要求...尽管我不确定第2点。

在官方网站上找到更多信息。