Javascript JS-创建智能自动完成

给定一个排序的字符串数组和用户输入，我需要返回最相关的结果

示例：数组=

['Apple'、'Banana and瓜'、'Orange']

和用户输入=

'melllon'

返回值应为

'Banana and瓜'

---

我正在寻找正确的算法来实现高效的自动完成解决方案，而不是现成的解决方案

一种可能的解决方案是：

1） 将每个值转换为一些简单的代码（使用相同的简单规则，例如，将大写字符转换为小写，如果字符与预览相同，则无法写入等等。）因此，您有了

['aple'、'banana and wall'、'orange']

2） 然后转换用户输入，

melllon

=>

mellon

3） 现在你可以简单地跑步了

返回匹配数组。筛选器（（x）=>{
x、 indexOf（匹配输入）！=-1）
)

Levenshtein distance似乎适用于此问题。您需要计算数组中每个单词之间的距离，请检查它

function findClosestString(arr, inputvalue) {
  let closestOne = "";
  let floorDistance = 0.1;

  for (let i = 0; i < arr.length; i++) {
    let dist = distance(arr[i], inputvalue);
    if (dist > floorDistance) {
        floorDistance = dist;
      closestOne = arr[i];
    }
  }

  return closestOne;
}

function distance(val1, val2) {
  let longer, shorter, longerlth, result;

  if (val1.length > val2.length) {
    longer = val1;
    shorter = val2;
  } else {
    longer = val2;
    shorter = val1;
  }

  longerlth = longer.length;

  result = ((longerlth - editDistance(longer, shorter)) / parseFloat(longerlth));

  return result;
}

function editDistance(val1, val2) {
  val1 = val1.toLowerCase();
  val2 = val2.toLowerCase();

  let costs = [];

  for(let i = 0; i <= val1.length; i++) {
    let lastVal = i;
    for(let j = 0; j <= val2.length; j++) {
        if (i === 0) {
        costs[j] = j;
      } else if (j > 0) {
        let newVal = costs[j - 1];
        if (val1.charAt(i - 1) !== val2.charAt(j - 1)) {
          newVal = Math.min(Math.min(newVal, lastVal), costs[j]) + 1;
        }
        costs[j - 1] = lastVal;
        lastVal = newVal;
      }
    }
    if (i > 0) { costs[val2.length] = lastVal }
  }

  return costs[val2.length];
}

findClosestString(['Apple','Banana and Melon','Orange'], 'Mellllon');

函数findClosestString（arr，inputvalue）{
让closestOne=“”；
让floorDistance=0.1；
for（设i=0；i地板距离）{
floorDistance=距离；
closestOne=arr[i]；
}
}
返回闭门石；
}
功能距离（val1、val2）{
让长，短，长，结果；
if（val1.length>val2.length）{
长=1；
较短=val2；
}否则{
长=2；
shorter=val1；
}
longerlth=更长的长度；
结果=（（longerlth-editDistance（更长，更短））/parseFloat（longerlth））；
返回结果；
}
函数editDistance（val1，val2）{
val1=val1.toLowerCase（）；
val2=val2.toLowerCase（）；
让成本=[]；
对于（设i=0；i0）{costs[val2.length]=lastVal}
}
退货成本[价值2.长度]；
}
findClosestString（['Apple'、'Banana and Mellon'、'Orange']、'Melllon'）；

正如在模糊搜索中详细解释的那样，如果搜索字符串的所有字母（不区分大小写的“m”、“e”、“l”、“o”、“n”）都按出现顺序出现在输入字符串中，正则表达式可能会派上用场。因此，根据生成的

/M[^e]*e[^l]*l[^o]*o[^n]*n/i

regexp，来自“甜瓜”、“梅利昂”、“梅利隆”或“nMelrNnon”的全部应返回

true

函数模糊匹配（s，p）{
p=p.split（“”）。reduce（（a，b）=>a+'[^'+b+']*'+b）；
返回RegExp（p，“i”）。测试；
}
var arr=['苹果'，'香蕉和甜瓜'，'橙子']，
inp=“MaellL；腰部”，
res=arr.filter（s=>s.split（“”）。一些（w=>fuzzyMatch（inp，w））；
控制台日志（res）

我建议您看看Super，这就是我想要的，下面是getDistance方法的一个很好的实现：