Javascript 按任意顺序将字符串与字符串数组匹配

Javascript 按任意顺序将字符串与字符串数组匹配,javascript,arrays,match,string-matching,Javascript,Arrays,Match,String Matching,我的输入是一个字符串,它可能是一个人的名字,姓氏,组合,甚至两者的一部分,按照特定的顺序 Class { first = 'John' // just simple string last = 'Smith' // just simple string middle = 'Mark Bill' // this is often empty string, but may contain multiple, divided b

我的输入是一个字符串,它可能是一个人的名字,姓氏,组合,甚至两者的一部分,按照特定的顺序

Class {
    first = 'John'          //  just simple string
    last = 'Smith'          //  just simple string
    middle = 'Mark Bill'    //  this is often empty string, but may contain multiple, divided by spaces. ('' or 'Mark Bill')

    hasPresent(what){
        return true || false
    }
}
如果用户的输入是“John”,我们的John的
hasPresent
方法应该返回true
其他情况:

"input" => expected result

"Smith" => true
"mark" => true
"John Mark" => true
"hn mar" => true
"m" => true
" " => true

"John John" => false
"John Mark John" => false
"Jo Mark" => false
"John rk" => false
"n n n" => false
为了更好地理解,想象一下,你可以按任何顺序排列这个人的名字,只要你只使用一次。然后获取输入并将其与˙indexOf˙函数匹配。这就是为什么˙John rk˙是错误的,不管你怎么努力,你都可以按照这个特定的顺序组合一个˙John rk˙的字符串。您可以使用˙John Mark˙,但这与使用˙indexOf˙不匹配。

根据我们的名字,我们可以匹配任何匹配以下字符串的内容

"John Smith Mark Bill","John Mark Smith Bill","John Bill Smith Mark","John Mark Smith Bill","John Smith Bill Mark", "John Mark Bill Smith" etc


我认为,创建包含所有名称(名字、姓氏和分隔的中间名)的数组并匹配所有可能的组合可能是一种方法,但由于这必须在之前完成,我想知道是否有更好的方法


如果没有更好的方法,如何以尽可能低的处理能力从数组中生成所有可能的组合?

如果您有一个完整的字符串,您可以只检查
int indexOf(string str)
,如果它不是-1,您知道字符串包含单词。如果要将数组转换为这个长字符串,只需执行以下操作

for (int i = 0; i < strArray.length; i++)
{
    someStr += strArray[i];
}
for(int i=0;i
然后检查
someStr.indexOf(“约翰”)

编辑、更新


将其视为您将在上执行
indexOf


var fullname=“约翰·马克·比尔·史密斯”;
var检查=功能(输入){
返回fullname.toLowerCase().indexOf(input.toLowerCase())!=-1
}
控制台日志(检查(“史密斯”)
,勾选(“标记”)
,勾选(“约翰·马克”)
,勾选(“hn-mar”)
,勾选(“m”)
,勾选(“”)
,支票(“约翰”)
,支票(“约翰·马克·约翰”)
,勾选(“Jo标记”)
,支票(“John rk”)
,勾选(“n”)

)
您可以
concat
所有名称,对于用户输入的每个单词,检查字符串上是否存在该名称

first = 'John';
last = 'Smith';
middle = 'Mark Bill';

searchStr = first + " " + middle + " " + last;

function hasPresent(param){
  searchLower = searchStr.toLowerCase();
  searchWords = param.toLowerCase().split(" ");
  for (i = 0; i < searchWords.length; i++){
    index = searchLower.indexOf(searchWords[i])
    if (index == -1){
      return false;
    }
    searchLower = searchLower.substring(0,index) + searchLower.substring(index + searchWords[i].length, searchLower.length);
  }
  return true;
}
first='John';
last='Smith';
中间=‘马克·比尔’;
searchStr=first+“”+middle+“”+last;
函数hasPresent(参数){
searchLower=searchStr.toLowerCase();
searchWords=param.toLowerCase().split(“”);
for(i=0;i

对于您的示例,以及“Joh Smi”等示例,这将返回true,但区分大小写。如果需要,您可以调整它使其不区分大小写

这是一种美,使它。我可以用尽可能少的周期来确定任何顺序

hasPresent(what:string|number):boolean {
    if(isNumber(what)){
        return this.tel.hasPresent(what)
    }else{
        if (this.tel.hasPresent(what)) {
            return true
        }else{
            var query = what.toString().toLowerCase().split(' ')
            var possible = this.name.toLowerCase().trim().split(' ')
            if(query.length > possible.length){
                return false    //  No way this could be met
            }
            for (var i = possible.length - 1; i > 0; i--) {
                var possible2 = this.name.toLowerCase().trim().split(' ')
                if(possible[i].hasPresent(query[0])){
                    if (query.length==1){
                        return true
                    }
                    possible2.remove(possible[i])
                    for (var j = 1; j < query.length; j++){
                        var passed = false
                        for (var k = possible2.length - 1; k > 0; k--) {
                            if(possible2[k].indexOf(query[j]) == 0){
                                possible2.remove(possible2[k])
                                passed = true
                                break
                            }
                        }
                        if(!passed){
                            break
                        }
                    }
                    if(passed){
                        return true
                    }
                }
            }
            return false
        }
    }
}

这是javascript(无int;)但我明白你的意思了。。。问题是,我不知道用户是按什么顺序过滤人啊,对不起,当我回答“我的错”时,你的标签是“Java”。这并没有解决“n”作为输入字符串的问题。好的,我以前没有见过这个限制。我能适应它。对于像
h
i
Jo s
这样的情况,该值是否应返回真值?不,谢谢,它必须是连续字符串,对于John Mark,匹配为“hn ma”…您可以删除每个匹配字符串之前的所有内容,然后检查下一个字符或单词。因此,对于“hn-mar”这样的情况,它将返回true,而对于“mar-hn”,它将返回false。这对您有用吗?请检查已编辑的功能。这适用于您的示例,除了我同意@guest271314的
John rk
,在这种情况下,用户必须写出一个完整的名称,但很有趣idea@Akxe“在这种情况下,用户必须写一个完整的名称”不确定是否正确解释?如果所需输入是用户全名,
re
应返回
true
输入可以是例如“hn-ma”作为John mark。。。sorry@Akxe例如,对于John mark,输入可以是“hn ma”。
“hn ma”
应该返回
false
,对吗?对于输入中找到的与
中找到的用户名的任何部分相匹配的任意两个字符,是否要求返回
true
?@Akxe如果要求检查所有可能的组合,则首先需要创建一个或多个数组来检查所有可能的组合。当考虑注释“必须是连续字符串,即匹配”时。也许花点时间来完善实际问题,提出新问题,包括所有必需的元素?目前,在这里,实际问题似乎不清楚;至少现在和最初发布的问题不同。不确定
“John Sm”
应该如何返回
true
,而
“John rk”
应该返回
false
为什么
“John rk”
会返回
false
?就好像你会在
上做
索引一样,“Jonh Mark”
逻辑看起来不清楚,这里。不确定
“hn-mar”
如何返回
true
,而
“John-rk”
如何返回
false
?请参阅OP中的“如果用户的输入是‘John’,我们的John的hasPresent方法应该返回true”。在输入字符串的开头,
“rk”
如何否定
“John”
,如果字符串的两个部分都是全名,因为我们严格需要将整个输入匹配到人名的任何顺序,那么
johnma
计数。如果他名字的顺序是正确的,就可以不间断地在一件作品中找到correct@JuanBoca的更新答案应该符合要求,以防出现“John rk”
@JuanBoca这是我想要的。。。如果您对这个问题有更好的名称,请将其重命名,这样也会很有帮助:)@guest271314就是它,希望您将其取消
hasPresent(what:string|number):boolean {
    if(isNumber(what)){
        return this.tel.hasPresent(what)
    }else{
        if (this.tel.hasPresent(what)) {
            return true
        }else{
            var query = what.toString().toLowerCase().split(' ')
            var possible = this.name.toLowerCase().trim().split(' ')
            if(query.length > possible.length){
                return false    //  No way this could be met
            }
            for (var i = possible.length - 1; i > 0; i--) {
                var possible2 = this.name.toLowerCase().trim().split(' ')
                if(possible[i].hasPresent(query[0])){
                    if (query.length==1){
                        return true
                    }
                    possible2.remove(possible[i])
                    for (var j = 1; j < query.length; j++){
                        var passed = false
                        for (var k = possible2.length - 1; k > 0; k--) {
                            if(possible2[k].indexOf(query[j]) == 0){
                                possible2.remove(possible2[k])
                                passed = true
                                break
                            }
                        }
                        if(!passed){
                            break
                        }
                    }
                    if(passed){
                        return true
                    }
                }
            }
            return false
        }
    }
}
Array.remove(object) - removes object for array
Array|String.hasPresent(needle) - shortcut for indexOf(needle) => 0