如何检查一个string是否包含JavaScript中的子string？
通常我会期望一个String.contains()方法，但似乎没有一个。 什么是合理的方法来检查这个？
这里是目前的可能性列表：
1. indexOf
var string = "foo", substring = "oo"; string.indexOf(substring) !== -1;
String.prototype.indexOf返回另一个string中string的位置。 如果找不到，则返回-1 。
2.（ES6）包括 – 去回答 ，或这个答案
var string = "foo", substring = "oo"; string.includes(substring);
3.search – 去回答
var string = "foo", expr = /oo/; string.search(expr);
4. lodash包括 – 去回答
var string = "foo", substring = "oo"; _.includes(string, substring);
5. RegExp – 去回答
var string = "foo", expr = /oo/; // no quotes here expr.test(string);
6.比赛 – 去回答
var string = "foo", expr = /oo/; string.match(expr);
性能testing（ http://jsben.ch/#/RVYk7 ）显示，如果涉及速度问题，indexOf可能是最好的select。
您可以使用以下语句轻松地将一个contains方法添加到String：
String.prototype.contains = function(it) { return this.indexOf(it) != -1; };
注意：请参阅下面的注释以获取不使用此参数的有效参数。 我的build议是：用你自己的判断。
或者：
if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }
你的代码的问题是JavaScript区分大小写。 你的方法调用
indexof()
实际上应该是
indexOf()
尝试修复它，看看是否有帮助：
if (test.indexOf("title") !=-1) { alert(elm); foundLinks++; }
var index = haystack.indexOf(needle);
更新2015年 ： string.includes已被添加到JavaScript的下一个版本，ES6 ：
"potato".includes("to"); > true
请注意，您可能需要加载es6-shim或类似的才能在旧浏览器上运行。
require('es6-shim')
您可以使用JavaScript search()方法。
语法是： string.search(regexp)
它返回匹配的位置，如果没有find匹配，则返回-1。
看看那里的例子： jsref_search
您不需要复杂的正则expression式语法。 如果你不熟悉它们，一个简单的st.search("title")就可以做到。 如果你想让你的testing不区分大小写，那么你应该做st.search(/title/i) 。
String.prototype.includes()在ES6中引入。
确定是否可以在另一个string中find一个string，根据情况返回true或false。
句法
var contained = str.includes(searchString [, position]);
参数
searchString
在此string中search的string。
position
该string中searchsearchString默认为0。
例
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
如果您正在寻找替代方法来编写丑陋的-1检查，那么您需要预先input一个〜波浪号。
if (~haystack.indexOf('needle')) alert('found');
Joe Zimmerman – 你会看到使用〜on -1将其转换为0.数字0是一个falsey值，这意味着当转换为布尔值时它将计算为false。 起初，这似乎不是一个很大的见解，但是记住像indexOf这样的函数将在查询未find时返回-1。 这意味着，而不是写这样的东西：
if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found }你现在可以在你的代码中有更less的字符，所以你可以这样写：
if (~someStr.indexOf("a")) { // Found it } else { // Not Found }
更多细节在这里
这段代码应该工作得很好：
var str="This is testing for javascript search !!!"; if(str.search("for") != -1) { //logic }
在ES5中
var s = "foo"; alert(s.indexOf("oo") > -1);
在JavaScript中编写contains方法的常用方法是：
if (!String.prototype.contains) { String.prototype.contains = function (arg) { return !!~this.indexOf(arg); }; }
按位否定运算符（ ~ ）用于将-1转换为0 （falsey），其他所有值都将不为零（truthy）。
双布尔否定运算符用于将数字转换为布尔值。
你可以使用jQuery的:containsselect器。
$("div:contains('John')")
在这里检查： 包含select器
您可以使用经过充分testing和logging的库，而不是使用网上的代码片段。 我会推荐两个选项：
第一个选项：使用Lodash ：它有一个includes方法：
_.includes('foobar', 'ob'); // → true
Lodash是npm中最受欢迎的JavaScript库依赖项，并且有许多方便的javascript实用方法。 所以对于许多项目，你会想要这个;-)
第二个选项：或者使用Underscore.string ：它有一个include方法：
_.str.include('foobar', 'ob'); // → true
这里是Underscore.string的描述，它只是增加了9kb，但给你所有的优点一个经过良好testing和logging的库已经over'n'paste代码片段：
Underscore.string是JavaScript库，使用string进行舒适的操作，Underscore.js的扩展由Prototype.js，Right.js，Underscore和漂亮的Ruby语言启发。
Underscore.string为您提供了几个有用的function：大写，清理，包含，计数，转义HTML，unescapeHTML，插入，拼接，startsWith，endsWith，titleize，trim，truncate等。
注意，Underscore.string受到Underscore.js的影响，但可以在没有它的情况下使用。
最后不得less于：使用JavaScript版本ES6提供了一个内置的includes方法：
'foobar'.includes('ob'); // → true
大多数现代浏览器已经支持它，请关注ES6兼容性表 。
使用正则expression式：
RegExp.test(string)
这只是为我工作。 它select不包含术语“已删除”的string
if (eventString.indexOf("Deleted:") == -1)
您正在寻找MDN的.indexOf 。
indexOf将返回一个索引到匹配的子string。 该索引将与子string的起始位置相关。 如果不匹配，则返回-1。 这是一个简单的演示 ：
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来获取这个数据属性。 它可能失败的原因是因为它返回一个空值。 你可以做以下的事情来获得你的课程价值…
var test = elm.getAttribute("className"); //or var test = elm.className
这样做的另一个select是：
你可以使用匹配function，就是这样的：
x = "teststring"; if (x.match("test")) { // Code }
由于这个问题很受欢迎，所以我认为我可以在代码中添加一些现代风格。
const allLinks = document.getElementsByTagName("a"); let foundLinks = 0; [].forEach.call(allLinks, (elm) => { if (elm.getAttribute("class").indexOf("title") > -1) { foundLinks += 1; console.log(elm); } }); console.log(foundLinks ? "Found " + foundLinks + " title class" : "No title class found" );
顺便说一句，正确的答案是拼错indexOf或非标准的String.contains 。 加载一个外部库（特别是如果代码是用纯JavaScript编写的），或者使用String.prototype或者使用正则expression式 ，这样做有点矫枉过正。
有一个圆滑的和更好的方式来做到这一点，它正在使用（BitWise NOT）运算符。
if(~"John".indexOf("J")) { alert("Found") } else { alert("Not Found"); }
按位不将“x”转换为 – （x + 1），如果x从indexOf方法变为-1，则它将被转换为 – （-1 + 1）= -0这是一个伪造值。
String.prototype.indexOf()或String.prototype.search()
正如其他人已经提到的，JavaScriptstring同时具有indexOf和search方法。
两者之间的关键区别在于， indexOf仅用于纯粹的子string，而search也支持正则expression式。 当然，使用indexOf的好处在于速度更快。
另请参见在JavaScript中，indexOf（）和search（）之间有什么区别？ 。
实现你自己的String.prototype.contains()方法
如果你想添加你自己的contains方法给每个string，最好的方法是@zzzzBov的方法：
if (!String.prototype.contains) { String.prototype.contains = function (arg) { return !!~this.indexOf(arg); }; }
你会这样使用它：
'Hello World'.contains('orl');
实现一个自定义实用程序库
例如，在JavaScript中将自己的自定义方法添加到标准对象通常是不被接受的，因为它可能会破坏兼容性。
如果你真的想要自己的contains方法和/或其他自定义string方法，最好创build自己的实用程序库，并将自定义string方法添加到该库：
var helper = {}; helper.string = { contains : function (haystack, needle) { return !!~haystack.indexOf(needle); }, ... };
你会这样使用它：
helper.string.contains('Hello World', 'orl');
使用第三方实用程序库
如果您不想创build自己的自定义帮助程序库，当然总是可以select使用第三方应用程序库。 正如@nachtigall所提到的，最stream行的是Lodash和Underscore.js 。
在Lodash中，你可以使用_.includes() ，你可以这样使用：
_.includes('Hello World', 'orl');
在_.str.include() ，你可以使用_.str.include() ，你可以像这样使用它：
_.str.include('Hello World', 'orl');
简单的解决方法
if (!String.prototype.contains) { String.prototype.contains= function() { return String.prototype.indexOf.apply(this, arguments) !== -1; }; }
你可以用以下方式使用
"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参考
例
var a = "Test String"; if(a.search("ring")!=-1){ //exist } else { //not found }
要在数组中使用contains方法的JavaScript代码：
<html> <head> <h2>Use of contains() method</h2> <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")+"<br>"); </script> </head> <b>[If the specified element is present in the array, it returns true otherwise returns false.]</b> </html>
在给定的代码中， contains方法确定指定元素是否存在于数组中。 如果指定的元素存在于数组中，则返回true，否则返回false。
ES6包含String.prototype.includes 。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
收集某种有效的解决scheme：
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+'');
既然有关于使用原型的投诉，并且由于使用indexOf使得你的代码不太可读，并且因为regexp是矫枉过正的：
function stringContains(inputString, stringToFind) { return (inputString.indexOf(stringToFind) != -1); }
这是我最终的妥协。
JavaScript的
var str = "My big string contain apples and oranges"; var n = str.indexOf("apples"); alert(n); //will alert 22, -1 if not found
jQuery的
<p>My big string contain apples and oranges</p> alert($("p:contains(apples)")[0] != undefined); //will alert true if found
使用内置和最简单的一个，即match()stringmatch() 。 为了实现你期待的目标：
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"); }
最简单的方法是使用indexOf 。 为了检查一个stringstring的子stringsubstr你可以使用这个方法：
string = "asdf"; substr = "as"; alert(string.indexOf(substr) == -1 ? false : true);
正如你想要的函数string.contains() ，你可以像这样自己实现它：
String.prototype.contains = function(test) { return this.indexOf(test) == -1 ? false : true; };
现在你可以使用这个更短的方法来检查一个string是否包含一个特殊的子string：
string = "asdf"; alert(string.contains("as"));
这也是一个JSFiddle 。
