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

小开

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
}
}

小开

最佳答案

没有内置的东西可以为你做这件事，你必须为它写一个函数，尽管它可以只是一个some数组方法的回调。

有两种方法:

数组some方法
正则表达式

数组`some`

数组some方法(在ES5中添加)使这非常简单:

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

使用箭头函数和较新的includes方法(都是ES2015+)会更好:

if (substrings.some(v => str.includes(v))) {
// There's at least one
}

生活例子:

const substrings = ["one", "two", "three"];
let str;


// Setup
console.log(`Substrings: ${substrings}`);


// Try it where we expect a match
str = "this has one";
if (substrings.some(v => str.includes(v))) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}


// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(v => str.includes(v))) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}

正则表达式

如果你知道字符串不包含任何正则表达式中的特殊字符，那么你可以欺骗一点，像这样:

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

.．.它为你正在寻找的子字符串(例如，one|two)创建了一个正则表达式，该正则表达式是一系列交替变化，并测试是否有匹配的子字符串，但如果任何子字符串包含正则表达式中特殊的字符(*， [等)，你必须首先转义它们，你最好只做无聊的循环。有关转义的信息，请参见这个问题的答案。

生活例子:

const substrings = ["one", "two", "three"];
let str;


// Setup
console.log(`Substrings: ${substrings}`);


// Try it where we expect a match
str = "this has one";
if (new RegExp(substrings.join("|")).test(str)) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}


// Try it where we DON'T expect a match
str = "this doesn't have any";
if (new RegExp(substrings.join("|")).test(str)) {
console.log(`Match using "${str}"`);
} else {
console.log(`No match using "${str}"`);
}

小开

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

小开

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]
}
}

< p >编辑: 如果测试的顺序不重要，您可以使用这个(只有一个循环变量):

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]
}
}

小开

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);

小开

对于用谷歌搜索的人来说，

确切的答案应该是。

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

小开

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
}

小开

单线解决方案

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

如果子字符串exists\does'nt exist，则返回true\false

需要ES6支持

小开

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

var contacts = ['Billy Bob', 'John', 'Bill', 'Sarah'];


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


contacts = _.filter(contacts, function(contact) {
return _.every(filters, function(filter) { return (contact.indexOf(filter) === -1); });
});


// ['John']

在一个字符串上:

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


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


// true

小开

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

String.prototype.includes()

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

小开

这太迟了，但我刚刚遇到了一个问题。在我自己的项目中，我使用以下方法来检查字符串是否在数组中:

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

通过这种方式，你可以获取一个预定义数组并检查它是否包含字符串:

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

小开

基于t。j。克劳德的答案

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

function buildSearch(substrings) {
return new RegExp(
substrings
.map(function (s) {return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');})
.join('{1,}|') + '{1,}'
);
}




var pattern = buildSearch(['hello','world']);


console.log(pattern.test('hello there'));
console.log(pattern.test('what a wonderful world'));
console.log(pattern.test('my name is ...'));

小开

借鉴T.J. Crowder的解决方案，我创建了一个原型来处理这个问题:

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

小开

最好的答案是: 这也是不区分大小写的

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


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

小开

如果您正在处理一长串子字符串，这些子字符串由空格或任何其他常见字符分隔的完整“单词”组成，那么您可以在搜索中使用一些聪明的方法。

首先把你的字符串分成X组，然后X+1，然后X+2，…X和Y应分别为子字符串中单词最少和最多的单词数。例如，如果X是1,Y是4，“Alpha Beta Gamma Delta”变成:

"阿尔法" "贝塔" "伽马" "德尔塔"

"阿尔法·贝塔" "贝塔·伽马" "伽马·德尔塔"

"Alpha Beta Gamma" "Beta Gamma Delta"

"Alpha Beta Gamma Delta"

如果X是2 Y是3，那么你可以省略第一行和最后一行。

现在，如果您将它插入到Set(或Map)中，就可以快速搜索这个列表，比字符串比较快得多。

缺点是你不能搜索像“ta Gamm”这样的子字符串。当然，你可以通过按字符而不是按单词进行分割来实现这一点，但这样你通常需要构建一个庞大的Set，并且这样做所花费的时间/内存超过了好处。

小开

你可以这样检查:

<!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>

小开

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

使用滤镜:

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

小开

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

全力支持;)

小开

对于完全支持(除了@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)

小开

以下是(IMO) 到目前为止的最佳解决方案。这是一个现代的(ES6)解决方案，它:

是高效的(一行!)
避免for循环
与其他答案中使用的some()函数不同，这个函数不仅返回布尔值(true/false)。
相反，它要么返回子字符串(如果它在数组中找到)，要么返回undefined
更进一步，允许您选择是否需要部分子字符串匹配(示例如下)

享受吧!

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'。

容易peasy !

小开

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();

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

小开

var str = "A for apple"
var subString = ["apple"]


console.log(str.includes(subString))

小开

我也遇到过这样的问题。我有一个URL，我想检查链接是否以图像格式或其他文件格式结束，有一个图像格式数组。以下是我所做的:

const imagesFormat = ['.jpg','.png','.svg']
const link = "https://res.cloudinary.com/***/content/file_padnar.pdf"
const isIncludes = imagesFormat.some(format => link.includes(format))
    

// false

小开

const str = 'Does this string have one or more strings from the array below?';
const arr = ['one', 'two', 'three'];


const contains = arr.some(element => {
if (str.includes(element)) {
return true;
}
return false;
});


console.log(contains); // true

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

数组some

正则表达式

数组`some`