Javascript：在字符串中模糊查找子字符串

我有一组字符串，我需要模糊地找出这些字符串中是否有一个包含在一个句子中。如果是这样，我需要子字符串在句子中的位置。 例如：

var input=“昨天晚上在伦敦的情况如何？”；
var集=[“英国伦敦”、“巴黎”]；
fuzzyFind（输入，设置）；//返回类似{score:xxx，found:“伦敦英国”，开始：23，结束：29}

似乎可以这样做，但除非我错过了它，否则它不会告诉我子字符串在输入字符串中的位置

---

是否存在执行此操作的现有库（它将在节点中使用）？

确保设置了

include:[“matches”]

选项

编辑：应该是

包括：[“分数”、“匹配项”]

，然后在结果中，每个结果对象将有一个“匹配项”和一个“分数”属性。匹配项是每个项目键的“索引”列表，每个匹配项都有一个开始和结束位置

另外，在我注意到fuse.js中包含这些选项之前，我所写的答案是（我的fuzzyfuzzy端口）中的partial_ratio函数的一个版本，经过修改，包含了较长字符串的最佳匹配子字符串及其开始/结束位置以及分数/比率

再看一眼，我的第一个答案并不完全是你们想要的，而且还是被否决了，我已经写好了，这也是：）

var difflib=require（'difflib'）；
var input=“昨天晚上在伦敦的情况如何？”；
var集=[“英国伦敦”、“巴黎”]；
log（topSubString（输入，设置））；
/* 
[分数、最佳匹配子字符串、开始、停止]
[0.555556，'Londom la'，23,32]，
[0.4，'是t'，4,9]]
*/
函数topSubString（输入，设置）{
结果=[]；
用于（集合中的var s）{
结果：push（部分_比率（输入，设置]）；
}
results.sort（函数（a，b）{返回b[0]-a[0]}）[0]；
返回结果；
}
功能部分比例（str1、str2、选项）{
if（str1.length 0？（块[b][1]-块[b][0]）：0；
var long\u end=long\u start+shorter.length；
var long\u substr=long.substring（long\u开始，long\u结束）；
var ssm=新的difflib.SequenceMatcher（null、shorter、long\u substr）；
var r=ssm.比率（短、长、期权）；
如果（r>99.5）{bestMatch=[r，long_substr，long_start，long_end]；break；}
其他得分。推送（[r，long_substr，long_start，long_end]）；
}
如果（！bestMatch）bestMatch=scores.sort（函数（a，b）{返回b[0]-a[0]}）[0]；
返回最佳匹配；
}

谢谢@smcd。不幸的是，它似乎没有达到我想要的效果。例如，它似乎没有返回在输入文本中找到搜索字符串的索引。

var difflib = require('difflib');

var input = "how was the whether in Londom last night?";
var set = ["london uk", "paris"];
console.log(topSubString(input, set));

/* 
[score, best matching substring, start, stop]

[ [ 0.5555555555555556, 'Londom la', 23, 32 ],
  [ 0.4, 'was t', 4, 9 ] ]
*/

function topSubString(input, set) {
    results = [];
    for (var s in set) {
        results.push(partial_ratio(input, set[s]));
    }
    results.sort(function (a, b) { return b[0] - a[0] })[0];
    return results;
}
function partial_ratio(str1, str2, options) {

    if (str1.length <= str2.length) {
        var shorter = str1
        var longer = str2
    }
    else {
        var shorter = str2
        var longer = str1
    }
    var bestMatch;
    var m = new difflib.SequenceMatcher(null, shorter, longer);
    var blocks = m.getMatchingBlocks();
    var scores = [];
    for (var b = 0; b < blocks.length; b++) {
        var long_start = (blocks[b][1] - blocks[b][0]) > 0 ? (blocks[b][1] - blocks[b][0]) : 0;
        var long_end = long_start + shorter.length;
        var long_substr = longer.substring(long_start, long_end);
        var ssm = new difflib.SequenceMatcher(null, shorter, long_substr);
        var r = ssm.ratio(shorter, long_substr, options);
        if (r > 99.5) { bestMatch = [r, long_substr, long_start, long_end]; break; }
        else scores.push([r, long_substr, long_start, long_end]);
    }
    if (!bestMatch) bestMatch = scores.sort(function(a,b){ return b[0] - a[0] })[0];
    return bestMatch;
}