Question

非常直接。在javascript中，我需要检查字符串是否包含数组中保存的任何子字符串。

Answer 1

没有任何内置可以为你做的，你必须为它编写一个函数。

如果您知道字符串不包含正则表达式中特殊的任何字符，那么您可以作弊，如下所示：

if (new RegExp(substrings.join("|")).test(string)) {
    // At least one match
}

...它创建了一个正则表达式，它是您正在寻找的子串的一系列替换（例如，one|two）并测试是否存在任何匹配其中，但如果任何一个子串包含任何特殊的正则表达式（*，[等），你必须首先逃避它们，你最好只做反而是无聊的循环。

Gratuitous live example

<强>更新：

在对该问题的评论中，Martin询问ECMAScript5中的新Array#map函数。 map并没有那么多帮助，但some是：

if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    // There's at least one
}

Live example（仅适用于现代浏览器）

请注意，它确实意味着一些开销，而且你只能在符合ECMAScript5的实现上使用它（例如，不是IE7或更早版本;也许甚至不是IE8），但是如果你真的进入那种风格的话编程......（你可以使用ECMAScript5垫片，this one或其他几个垫片。）

Answer 2

var yourstring = 'tasty food'; // the string to check against


var substrings = ['foo','bar'],
    length = substrings.length;
while(length--) {
   if (yourstring.indexOf(substrings[length])!=-1) {
       // one of the substrings is in yourstring
   }
}

Answer 3

function containsAny(str, substrings) {
    for (var i = 0; i != substrings.length; i++) {
       var substring = substrings[i];
       if (str.indexOf(substring) != - 1) {
         return substring;
       }
    }
    return null; 
}

var result = containsAny("defg", ["ab", "cd", "ef"]);
console.log("String was found in substring " + result);

Answer 4

一线解决方案

substringsArray.some(substring=>yourBigString.includes(substring))

如果substring true\false

，则返回exists\does'nt exist

需要ES6支持

Answer 5

对于谷歌人来说，

应该是坚实的答案。

const substrings = ['connect', 'ready'];
const str = 'disconnect';
if (substrings.some(v => str === v)) {
   // Will only return when the `str` is included in the `substrings`
}

Answer 6

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = 0, len = arr.length; i < len; ++i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

编辑：如果测试的顺序无关紧要，您可以使用它（只有一个循环变量）：

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = arr.length - 1; i >= 0; --i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

Answer 7

使用搜索字符串或搜索字符串数组搜索标记或关键字数组的Javascript函数。（使用 ES5 某些数组方法和 ES6 箭头函数）

// returns true for 1 or more matches, where 'a' is an array and 'b' is a search string or an array of multiple search strings
function contains(a, b) {
    // array matches
    if (Array.isArray(b)) {
        return b.some(x => a.indexOf(x) > -1);
    }
    // string match
    return a.indexOf(b) > -1;
}

使用示例：

var a = ["a","b","c","d","e"];
var b = ["a","b"];
if ( contains(a, b) ) {
    // 1 or more matches found
}

Answer 8

如果数组不大，您可以使用indexOf()循环并分别针对每个子字符串检查字符串。或者，您可以构造一个带有子串作为替代的正则表达式，这可能会也可能不会更有效。

Answer 9

这是（IMO）到目前为止的最佳解决方案。这是一种现代的（ES6）解决方案，可以：

高效（一行！）
避免循环
与其他答案中使用的some()函数不同，该函数不仅返回布尔值（真/假）
相反，它要么返回子字符串（如果在数组中找到了），要么返回未定义的
更进一步，您可以选择是否需要部分子字符串匹配（以下示例）

享受！

const arrayOfStrings = ['abc', 'def', 'xyz'];
const str = 'abc';
const found = arrayOfStrings.find(v => (str === v));

在这种情况下，found将被设置为'abc'。这将对完全字符串匹配有效。

相反，您使用：

const found = arrayOfStrings.find(v => str.includes(v));

在这种情况下，found将再次设置为'abc'。这不允许部分匹配，因此，如果str设置为'ab'，则found将是未定义的。

而且，如果您希望部分匹配有效，只需将其翻转即可：

const found = arrayOfStrings.find(v => v.includes(str));

相反。因此，如果将str设置为'ab'，则found将设置为'abc'。

轻松自如！

Answer 10

要获得全面支持（@ricca的verions除外）。

wordsArray = ['hello', 'to', 'nice', 'day']
yourString = 'Hello. Today is a nice day'.toLowerCase()
result = wordsArray.every(w => yourString.includes(w))
console.log('result:', result)

Answer 11

substringsArray.every(substring=>yourBigString.indexOf(substring) === -1)

获得全面支持；）

Answer 12

convert_to_array = function (sentence) {
     return sentence.trim().split(" ");
};

let ages = convert_to_array ("I'm a programmer in javascript writing script");

function confirmEnding(string) {
let target = "ipt";
    return  (string.substr(-target.length) === target) ? true : false;
}

function mySearchResult() {
return ages.filter(confirmEnding);
}

mySearchResult();

您可以像这样检查并使用过滤器返回匹配单词的数组

Answer 13

并非我建议你去扩展/修改String的原型，但这就是我所做的：

String.prototype.includes()

＆＃13;

String.prototype.includes = function (includes) {
    console.warn("String.prototype.includes() has been modified.");
    return function (searchString, position) {
        if (searchString instanceof Array) {
            for (var i = 0; i < searchString.length; i++) {
                if (includes.call(this, searchString[i], position)) {
                    return true;
                }
            }
            return false;
        } else {
            return includes.call(this, searchString, position);
        }
    }
}(String.prototype.includes);

console.log('"Hello, World!".includes("foo");',          "Hello, World!".includes("foo")           ); // false
console.log('"Hello, World!".includes(",");',            "Hello, World!".includes(",")             ); // true
console.log('"Hello, World!".includes(["foo", ","])',    "Hello, World!".includes(["foo", ","])    ); // true
console.log('"Hello, World!".includes(["foo", ","], 6)', "Hello, World!".includes(["foo", ","], 6) ); // false

＆＃13;

Answer 14

从T.J. Crowder的解决方案，我创建了一个原型来处理此问题：

Array.prototype.check = function (s) {
  return this.some((v) => {
    return s.indexOf(v) >= 0;
  });
};

Answer 15

最佳答案在这里：这也是区分大小写的

    var specsFilter = [.....];
    var yourString = "......";

    //if found a match
    if (specsFilter.some((element) => { return new RegExp(element, "ig").test(yourString) })) {
        // do something
    }

Answer 16

如果您要使用由完整的“单词”组成的一长串子字符串，这些单词之间用空格或任何其他公共字符分隔，则搜索可能会更聪明。

首先将您的字符串分成X组，然后是X + 1，然后是X + 2，...，直到Y。X和Y应该是子字符串中单词的数目，单词的数目最少和最多。例如，如果X为1，Y为4，则“ Alpha Beta Gamma Delta”变为：

“ Alpha”，“ Beta”，“ Gamma”，“ Delta”

“ Alpha Beta”，“ Beta Gamma”，“ Gamma Delta”

“ Alpha Beta Gamma”“ Beta Gamma Delta”

“ Alpha Beta Gamma Delta”

如果X为2，Y为3，那么您将省略第一行和最后一行。

现在，如果将其插入到Set（或Map）中，则可以快速搜索此列表，比通过字符串比较要快得多。

缺点是您无法搜索“ ta Gamm”之类的子字符串。当然，您可以通过按字符而不是按单词进行拆分来实现这一点，但随后您通常需要构建一个庞大的Set，而花费的时间/内存却超过了收益。

Answer 17

您可以像这样检查：

<!DOCTYPE html>
<html>
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
      <script>
         $(document).ready(function(){
         var list = ["bad", "words", "include"] 
         var sentence = $("#comments_text").val()

         $.each(list, function( index, value ) {
           if (sentence.indexOf(value) > -1) {
                console.log(value)
            }
         });
         });
      </script>
   </head>
   <body>
      <input id="comments_text" value="This is a bad, with include test"> 
   </body>
</html>

Answer 18

以T.J Crowder的回答为基础

使用转义的RegExp来测试至少一个子串的“至少一次”出现。

Int

Answer 19

这已经太晚了，但我遇到了这个问题。在我自己的项目中，我使用以下内容来检查字符串是否在数组中：

["a","b"].includes('a')     // true
["a","b"].includes('b')     // true
["a","b"].includes('c')     // false

这样您就可以获取预定义的数组并检查它是否包含字符串：

var parameters = ['a','b']
parameters.includes('a')    // true

Answer 20

使用underscore.js或lodash.js，您可以对字符串数组执行以下操作：

var contact = 'Billy';
var filters = ['Bill', 'Sarah'];

_.every(filters, function(filter) { return (contact.indexOf(filter) >= 0); });

// true

在单个字符串上：

if (env.BRANCH_NAME == 'branch name') {
env.DEPLOY_TO_LAST = input message: 'User input required',
        parameters: [choice(name: 'Deploy to LAST', choices: 'no\nyes')]
if (env.DEPLOY_TO_LAST == 'yes'){
    stage('LAST') {
        node('') {
            sh 'echo "stage Last"'
            unstash(name: 'Saved')
        }
    }
}
else {
    stage('FIRST') {
        node('') {
            sh 'echo "stage FIRST"'
            unstash(name: 'Saved')
        }
    }
    stage('SECOND') {
        node('') {
            sh 'echo "stage SECOND"'
            unstash(name: 'Saved')
        }
    }
    stage('THIRD') {
        node('') {
            sh 'echo "stage THIRD"'
            unstash(name: 'Saved')
        }
    }
}

Answer 21

let obj = [{name : 'amit'},{name : 'arti'},{name : 'sumit'}];
let input = 'it';

使用过滤器：

obj.filter((n)=> n.name.trim().toLowerCase().includes(input.trim().toLowerCase()))

如何检查字符串是否包含JavaScript中子串数组中的文本？

21 个答案: