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


通常我希望有一个String.contains()方法，但似乎没有。

什么是检查这个的合理方法?

相关讨论

以下是目前的可能性列表:

1. (ES6) includes -去回答(不支持IE)

1
2
3
var string ="foo",
    substring ="oo";
string.includes(substring);

2. ES5和更老的indexOf

1
2
3
var string ="foo",
    substring ="oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf返回字符串在另一个字符串中的位置。如果没有找到，它将返回-1。

3.search -回答我

1
2
3
var string ="foo",
    expr = /oo/;
string.search(expr);

4. lodash include -去回答

1
2
3
var string ="foo",
    substring ="oo";
_.includes(string, substring);

5. RegExp-go回答

1
2
3
var string ="foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6. 比赛来回答

1
2
3
var string ="foo",
    expr = /oo/;
string.match(expr);

性能测试显示，如果速度很重要，indexOf可能是最佳选择。

相关讨论

你可以很容易地添加一个contains方法字符串与此语句:

1
String.prototype.contains = function(it) { return this.indexOf(it) != -1; };

注意:请参阅下面的注释，以获得不使用此方法的有效参数。我的建议是:用你自己的判断。

另外:

1
if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }
相关讨论

代码的问题是JavaScript对大小写敏感。你的方法调用

1
indexof()

实际上应该

1
indexOf()

试着修复它，看看是否有帮助:

1
2
3
4
if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}
相关讨论

ES6中有一个string.includes:

1
2
"potato".includes("to");
> true

注意，您可能需要加载es6-shim或类似的代码，以便在较老的浏览器上运行。

1
require('es6-shim')
相关讨论

1
var index = haystack.indexOf(needle);

您可以使用JavaScript search()方法。

语法是:string.search(regexp)

它返回匹配项的位置，如果没有找到匹配项，则返回-1。

参见示例:jsref_search

您不需要复杂的正则表达式语法。如果您不熟悉它们，一个简单的st.search("title")就可以了。如果您希望您的测试不区分大小写，那么您应该执行st.search(/title/i)。

相关讨论

String.prototype.includes()是在ES6中介绍的。

Determines whether one string may be found within another string,
returning true or false as appropriate.

语法

1
var contained = str.includes(searchString [, position]);

参数

1
searchString

要在此字符串中搜索的字符串。

1
position

字符串中开始搜索searchString的位置默认为0。

例子

1
2
3
4
5
var str ="To be, or not to be, that is the question.";

console.log(str.includes("To be"));    // true
console.log(str.includes("question")); // true
console.log(str.includes("To be", 1)); // false

注意

这可能需要在旧浏览器中使用ES6垫片。

相关讨论

如果您正在寻找另一种方法来编写难看的-1检查，则需要在前面加上~波浪号。

1
if (~haystack.indexOf('needle')) alert('found');

Joe Zimmerman - you'll see that using ~ on -1 converts it to 0. The number 0 is a
falsey value, meaning that it will evaluate to false when converted to
a Boolean. That might not seem like a big insight at first, but
remember functions like indexOf will return -1 when the query is not
found. This means that instead of writing something similar to this:

1
2
3
4
5
if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

You can now have fewer characters in your code so you can write it
like this:

1
2
3
4
5
if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

更多细节在这里

相关讨论

这段代码应该可以很好地工作:

1
2
3
4
var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
}
相关讨论

用JavaScript编写contains方法的一种常见方法是:

1
2
3
4
5
if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

位否定运算符(~)用于将-1转换为0 (falsey)，所有其他值都是非零的(truthy)。

双布尔否定运算符用于将数字转换为布尔值。

相关讨论

您还可以使用经过良好测试和文档化的库，而不是使用web上随处可见的代码片段。我建议两种选择:

第一个选项:使用Lodash:它有一个includes方法:

1
2
_.includes('foobar', 'ob');
// → true

Lodash是npm最流行的javascript库依赖项，它有许多方便的javascript实用程序方法。因此，对于许多项目，无论如何你都会想要这个;-)

第二个选项:或使用下划线。string:它有一个include方法:

1
2
_.str.include('foobar', 'ob');
// → true

下面是对下划线的描述。字符串，它只是增加了9kb，但给你所有的优势，一个良好的测试和文件库的复制粘贴代码片段:

Underscore.string is JavaScript library for comfortable manipulation
with strings, extension for Underscore.js inspired by Prototype.js,
Right.js, Underscore and beautiful Ruby language.

Underscore.string provides you several useful functions: capitalize,
clean, includes, count, escapeHTML, unescapeHTML, insert, splice,
startsWith, endsWith, titleize, trim, truncate and so on.

注意下划线。string受Underscore.js的影响，但可以在没有它的情况下使用。

最后一点:在JavaScript版本ES6中有一个内置的includes方法:

1
2
'foobar'.includes('ob');
// → true

大多数现代浏览器已经支持它，关注ES6兼容性表。

相关讨论

您可以使用jQuery的:contains选择器。

1
$("div:contains('John')")

检查这里:容器选择器

相关讨论

另一个选择是:

您可以使用match函数，即:

1
2
3
4
5
x ="teststring";

if (x.match("test")) {
     // Code
}

match()也可以用于正则表达式:

1
2
3
4
5
x ="teststring";

if (x.match(/test/i)) {
     // Code
}
相关讨论

使用正则表达式:

RegExp.test(string)

相关讨论

您正在寻找.indexOfMDN。

indexOf将返回一个索引到匹配的子字符串。索引将与子字符串的起始位置相关联。如果没有匹配，则返回-1。下面是这个概念的一个简单演示:

1
2
3
4
5
6
var str ="Hello World"; // For example, lets search this string,
var term ="World"; // for the term"World",
var index = str.indexOf(term); // and get its index.
if (index != -1) { // If the index is not -1 then the term was matched in the string,
  alert(index); // and we can do some work based on that logic. (6 is alerted)
}

如前所述，您需要使用大写"O"调用indexOf。还应该注意，在JavaScript类中是一个保留字，您需要使用className来获取这个数据属性。它失败的原因可能是因为它返回了一个空值。您可以执行以下操作来获得您的类值…

1
2
3
var test = elm.getAttribute("className");
//or
var test = elm.className
相关讨论

这对我很有效。它选择不包含术语"已删除"的字符串:

1
if (eventString.indexOf("Deleted:") == -1)

由于这个问题非常流行，我想我可以在代码中添加一点现代风格。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// const           : creates an immutable constant
const allLinks   = document.getElementsByTagName("a");
// [].reduce.call  : gives access to the reduce method on a HTMLCollection
// () => {}        : ES6 arrow function
const foundLinks = [].reduce.call(allLinks, (sum, link) => {
     // bitwise OR : converts the boolean value to a number
     return sum + (link.classList.contains("title") | 0);
}, 0);

// template literal
console.log(`Found ${foundLinks ||"no
<hr><h3> <wyn>String.prototype.indexOf()</wyn>或<wyn>String.prototype.search()</wyn> ? ! </h3><p>正如其他人已经提到的，JavaScript字符串同时具有<wyn>indexOf</wyn>和<wyn>search</wyn>方法。</P><p>两者之间的关键区别是，<wyn>indexOf</wyn>只适用于普通子字符串，而<wyn>search</wyn>也支持正则表达式。当然，使用<wyn>indexOf</wyn>的好处是更快。</P><p>在JavaScript中，indexOf()和search()的区别是什么?</P>实现自己的<wyn>String.prototype.contains()</wyn>方法<p>如果你想给每个字符串添加你自己的<wyn>contains</wyn>方法，最好的方法是@zzzzBov的方法:</P>[cc lang="javascript"]if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

你可以这样使用它:

1
'Hello World'.contains('orl');

实现自定义实用程序库

例如，将您自己的自定义方法添加到JavaScript中的标准对象中通常是不被允许的，因为这可能会破坏向前兼容性。

如果你真的想要你自己的contains方法和/或其他自定义字符串方法，最好创建你自己的实用程序库，并添加你的自定义字符串方法到该库:

1
2
3
4
5
6
7
8
var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

你可以这样使用它:

1
helper.string.contains('Hello World', 'orl');

使用第三方实用程序库

如果您不想创建自己的自定义助手库，当然总是可以选择使用第三方实用程序库。正如@nachtigall所提到的，最流行的是Lodash和Underscore.js。

在Lodash中，可以使用_.includes()，如下所示:

1
_.includes('Hello World', 'orl');

在强调。，你可以使用_.str.include()，你可以这样使用:

1
_.str.include('Hello World', 'orl');

有一种更好的方法可以做到这一点，那就是使用(按位不)操作符。

1
2
3
4
5
6
if(~"John".indexOf("J")) {
  alert("Found")
}
else {
  alert("Not Found");
}

如果indexOf方法中的x是-1，则位元不能将"x"转换为-(x + 1)。然后它将被转换成-(-1 + 1)= -0，这是一个伪值。

相关讨论

例子

1
2
3
4
5
6
7
var a  ="Test String";

if(a.search("ring")!=-1){
     //exist
} else {
     //not found
}

ES6包含String.prototype.includes。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

相关讨论

简单的解决方法

1
2
3
4
5
if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

您可以使用以下方法

1
2
3
4
5
"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains("")//true
"hello world".contains(" ")//false

MDN参考

相关讨论

收集一些有效的解决方案:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var stringVariable ="some text";
var findString ="text";

//using `indexOf()`
var containResult1 = stringVariable.indexOf(findString) != -1;
document.write(containResult1+', ');

//using `lastIndexOf()`
var containResult2 = stringVariable.lastIndexOf(findString) != -1;
document.write(containResult2+', ');

//using `search()`
var containResult3 = stringVariable.search(findString) != -1;
document.write(containResult3+', ');
     
//using `split()`
var containResult4 = stringVariable.split(findString)[0] != stringVariable;
document.write(containResult4+'');

相关讨论

在数组中使用contains方法的JavaScript代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<html>
    <head>
        <hh2>Use of contains() method</hh2>
        <script>
            Array.prototype.contains = function (element) {
                for (var i = 0; i < this.length; i++) {
                    if (this[i] == element) {
                        return true;
                    }
                }
                return false;
            }
            arr1 = ["Rose","India","Technologies"];
            document.write("The condition is"+arr1.contains("India")+"");
        </script>
    </head>

    [If the specified element is present in the array, it returns true otherwise
    returns false.]

</html>

在给定的代码中，contains方法确定指定的元素是否存在于数组中。如果数组中存在指定的元素，则返回true，否则返回false。

相关讨论

因为使用原型有一个抱怨，因为使用indexOf会降低代码的可读性，而且regexp是多余的:

1
2
3
function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

这就是我最终寻求的妥协。

JavaScript

1
2
3
 var str ="My big string contain apples and oranges";
 var n = str.indexOf("apples");
 alert(n); //will alert 22, -1 if not found

jQuery

1
2
3
4
  <p>
My big string contain apples and oranges
</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found

在ES6中，我们有一些调用include，它做的正是您想要的:所以你可以这样做:

1
'str1'.includes('str2');

同样在ES5中，如果你广泛使用它，你可以这样简单地添加:

1
2
3
String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}

最简单的方法就是使用indexOf。要检查字符串string的子字符串substr，可以使用以下方法:

1
2
3
string ="asdf";
substr ="as";
alert(string.indexOf(substr) == -1 ? false : true);

因为你想要函数string.contains()，你可以这样实现它:

1
2
3
String.prototype.contains = function(test) {
    return this.indexOf(test) == -1 ? false : true;
};

现在您可以使用这个ecen较短的方法来检查一个字符串是否包含一个特殊的子字符串:

1
2
string ="asdf";
alert(string.contains("as"));

这还有一把小提琴。

简单的答案，100%有效

1
2
3
4
5
if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

一些例子

1
2
3
4
5
"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains("")//true
"hello world".contains(" ")//false
相关讨论

使用内置的和最简单的i。e match()在字符串上。为了达到你的期望，你可以这样做:

1
2
3
4
5
6
7
8
9
10
var stringData ="anyString Data";

var subStringToSearch ="any";

// This will give back the substring if matches and if not returns null
var doesContains = stringData.match(subStringToSearch);

if(doesContains !=null) {
    alert("Contains Substring");
}

如果您不喜欢!!~等技巧，您可以简单地将+1添加到.indexOf()的结果中。这样，如果没有找到字符串，-1 + 1 = 0将是假的，0.. + 1 = 1..将是真实的:

1
2
3
4
if ("StackOverflow".indexOf("Stack") + 1 )
    alert('contains');
else
    alert('does not contain');
相关讨论

search:

1
2
3
4
var str ="Stack Overflow";
var n = str.search("Overflow");
if (n != -1)
    alert('String exists')
相关讨论

有多种方法可以做到这一点。最常用的是indexOf()方法。indexOf()返回作为参数传递给它的字符串的位置，如果字符串不包含传递的字符串，则返回-1。

1
2
3
let str ="A cat and a dog";
str.indexOf("cat"); // returns 2
str.indexOf("panda"); // returns -1

Try this:

1
2
3
4
if ('Hello, World!'.indexOf('orl') !== -1)
    alert("The string 'Hello World' contains the substring 'orl'!");
else
    alert("The string 'Hello World' does not contain the substring 'orl'!");

举个例子:jsfiddle

相关讨论

使用ECMAScript 2015，我们可以使用includes()

1
2
let s ="foo";
console.log(s.includes("oo"));

非常简单:

1
2
3
4
var a ="foo", b="oo";
if (a.indexOf(substring) !== -1) {
    // has
}

可以使用indexOf返回字符串的位置。如果没有找到，它将返回-1。因此，如果方法返回-1字符串不存在

1
2
3
4
5
6
var string ="This is a test string",
substring ="test";
if(string.indexOf(substring) >= 0)
  //substring exist
else
  //substring does not exist

我知道最好的方法是str.indexOf(s) !== -1; http://hayageek.com/javascript-string-contains/

我建议另一种方法(str.replace(s1,"") !== str):

1
2
3
var str ="Hello World!", s1 ="ello", s2 ="elloo";
alert(str.replace(s1,"") !== str);
alert(str.replace(s2,"") !== str);

这是一个函数，检查一个字符串中是否存在子字符串:

1
2
3
function isStringMatch(str, str_to_match) {
    return (str.indexOf(str_to_match) > -1);
}
相关讨论

你也可以这样做

1
2
3
4
5
6
7
8
9
10
11
12
13
var snipers =" Vasily Zaytsev, Simo Hayha, Chris Kyle";
var me ="Josip";

function printSniperStatus (person) {
    if (aContainsB(snipers, person)) {
        console.log(person +" is a sniper.");
    } else {
        console.log(person +" is NOT a sniper.");
    }
}

// Outputs:"Josip is NOT a sniper."
printSniperStatus(me);
相关讨论

另一个答案…

Usually, I would expect a String.contains() method,...

根据通常的意思，至少有一种方法在之前的所有答案中都没有出现。

这可能在非常特殊的情况下有用，但是:

1
2
3
4
var mystring="Foo bar baz"
var searchstr="bar"
var arraysplt=mystring.split(searchstr)
var containbool=typeof(arraysplt[1])=="string";

如果searchstr至少出现一次，即使是在mystring末尾，那么typeof(split(...)[1])就是string(一个空字符串)。如果不存在，则typeof(split(...)[1])变为undefined。

或

1
typeof( mystring.split( searchstr )[1] ) =="string";

但是，只有当arraysplt的元素在脚本中起泡时，才可以使用这种方法。

…所以我认为这个简短的方法完全没用。

但是，如果您的目标是分割一个字符串，那么使用indexOf来确保分隔符的存在是无用的。

我很惊讶这里没有人提到KMP。公里是什么?KMP算法提供了最坏情况下的线性时间子串搜索，所以如果你关心最坏情况下的时间复杂度，这是一种合理的方法。链接到JavaScript KMP实现示例

1
2
3
var string ="foo",
    substring ="oo";
console.log(string.indexOf(substring) !== -1);

使用索引可以很容易地识别，例子:

1
2
3
4
5
6
var array = [2, 9, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1
array.indexOf(9, 2);  // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

结果在注释行之后

indexOf方法是最好的解决方案，因为它受到所有浏览器的支持

语法是:string.indexOf(searchvalue, start)

其中start是一个可选参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
result = 'GBP|1800';
//if pipe delimeter is there it returns true else false.
if(result.indexOf("|"))
{
    console.log('go default:' +result);
    var cur = result.substring(0, 3);//returns GBP
    console.log('go default cur:' +cur);
    var minmum_fee = result.substring(4);//gets the substring amount
    console.log('go default minmum_fee:' +minmum_fee);

}
else
{
    console.log('not found:' +result);
}