提问



通常我会期待String.contains()方法,但似乎并不是一个。


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

最佳参考


以下列出了当前的可能性:


1。 (ES6)includes -go回答


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


2。 ES5及更早indexOf


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


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


第3。 search -go回答


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


4。 lodash包括 -go回答


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


5。 RegExp -go回答


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


6。匹配 -go回答


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





性能测试显示indexOf可能是最好的选择,如果涉及到速度问题的那一点。[110]

其它参考1


您可以使用以下语句轻松地将contains方法添加到String:


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


注意:请参阅以下注释,了解不使用此参数的有效参数。我的建议:用你自己的判断。


或者:


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

其它参考2


您的代码存在的问题是JavaScript区分大小写。你的方法调用


indexof()


应该是


indexOf()


尝试修复它,看看是否有帮助:


if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}

其它参考3


ES6中有string.includes:[111]


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


请注意,您可能需要加载es6-shim或类似内容才能使其在旧版浏览器上运行。


require('es6-shim')

其它参考4


var index = haystack.indexOf(needle);

其它参考5


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


语法是:string.search(regexp)


它返回匹配的位置,如果未找到匹配则返回-1。


参见那里的例子:jsref_search [112]


你不需要复杂的正则表达式语法。如果你不熟悉它们,一个简单的st.search("title")会这样做。如果你希望你的测试不区分大小写,那么你应该st.search(/title/i)

其它参考6


String.prototype.includes()在ES6中被引入。[113]



  确定是否可以在另一个字符串中找到一个字符串,
  适当地返回true或false。



语法



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


参数



searchString


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


position


此字符串中开始搜索searchString的位置默认为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检查,那么你可以先添加一个〜代替。


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



   Joe Zimmerman - 你会看到使用~on -1将其转换为0.数字0是一个
  falsey值,表示转换为false时将评估为false
  一个布尔值。这可能看起来不是一个很大的洞察力,但是
  记住,当查询不是时,indexOf之类的函数将返回-1
  找到。这意味着不要写类似的东西:[114]


if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

  
  您现在可以在代码中使用更少的字符,以便您可以编写它
  喜欢这个:


if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}



更多细节[115]

其它参考7


这段代码应该运行良好:


var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 

其它参考8


在JavaScript中编写contains方法的常用方法是:


if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}


按位求反运算符(~)用于将-1转换为0(假),所有其他值将为非零(真值)。


double boolean negation运算符用于将数字转换为布尔值。

其它参考9


ES5




var s = "foo";
alert(s.indexOf("oo") > -1);



您可以使用经过充分测试和记录的库,而不是使用网络上此处和此处找到的代码段。我建议的两个选项:





第一个选项:使用Lodash:它有一个includes方法:[117] [118]


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


Lodash是npm最受欢迎的javascript库依赖项,并且有大量方便的javascript实用程序方法。因此,对于许多项目,无论如何你都会想要这个;-)





第二个选项:或者使用Underscore.string:它有一个include方法:[119] [120]


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


以下是Underscore.string的描述,它只增加了9kb,但是为您提供了经过充分测试和记录的库具有复制n粘贴代码片段的所有优点:



  Underscore.string是用于舒适操作的JavaScript库
  字符串,Underscore.js的扩展,受Prototype.js的启发,
  Right.js,Underscore和漂亮的Ruby语言。

  
  Underscore.string为您提供了几个有用的功能:大写,
  clean,includes,count,escapeHTML,unescapeHTML,insert,splice,
  startsWith,endsWith,titleize,trim,truncate等。



请注意,Underscore.string受Underscore.js的影响,但可以在没有它的情况下使用。[121]





最后不是最少:使用JavaScript版本ES6内置includes方法:[122]


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


大多数现代浏览器已经支持它,请关注ES6兼容性表。[123]

其它参考10


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


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


在这里查看:contains-selector [124]

其它参考11


使用正则表达式:


RegExp.test(string) [125]

其它参考12


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


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

其它参考13


您正在寻找.indexOf MDN [126]


indexOf将返回匹配子字符串的索引。索引将与子字符串的开始位置相关联。如果没有匹配,则返回-1。以下是该概念的简单演示:[127]




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



这样做的另一个选择是:


您可以使用匹配功能,即:


x = "teststring";

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


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


x = "teststring";

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

其它参考14


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


var test = elm.getAttribute("className");
//or
var test = elm.className

其它参考15


由于这个问题非常受欢迎,我认为我可以为代码添加一些现代风格。


// 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"} title class`);


顺便说一句,正确答案是拼写错误indexOf或非标准String.contains
加载外部库(特别是如果代码是用纯JavaScript编写的)或弄乱String.prototype或使用正则表达式有点过分。[128]

其它参考16


有一种更流畅,更好的方法,它使用(BitWise NOT)运算符。


if(~"John".indexOf("J")) {
  alert("Found")
}
else {
  alert("Not Found");
}


按位不将x转换为 - (x + 1)所以,如果x从indexOf方法变为-1,那么它将转换为 - (-1 + 1)= -0这是一个假值。

其它参考17


String.prototype.indexOf()String.prototype.search()?!



正如其他人已经提到的,JavaScript字符串同时具有indexOfsearch方法。[129] [130]


两者之间的关键区别在于indexOf仅适用于普通子串,而search也支持正则表达式。当然,使用indexOf的好处是它更快。


另请参阅在JavaScript中,indexOf()和search()有什么区别?。


实施您自己的String.prototype.contains()方法



如果你想为每个字符串添加你自己的contains方法,那么最好的方法就是@zzzzBov的方法:


if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}


你会像这样使用它:


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


实施自定义实用程序库



例如,通常不赞成将自己的自定义方法添加到JavaScript中的标准对象,因为它可能会破坏兼容性。


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


var helper = {};

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


你会像这样使用它:


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


使用第三方实用程序库



如果你不想创建自己的自定义助手库,当然 - 总是可以选择使用第三方实用程序库。正如@nachtigall所提到的,最受欢迎的是Lodash和Underscore.js。[[ [134] [135]


在Lodash中,你可以使用_.includes(),你可以这样使用:


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


在Underscore.js中,你可以使用_.str.include(),你可以这样使用:


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

其它参考18


简单的解决方法


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参考[136]

其它参考19





var a  = "Test String";

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

其它参考20


在数组中使用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。

其它参考21


ES6包含String.prototype.includes


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

其它参考22


收集某种有效的解决方案:




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


这就是我最终要做的妥协。

其它参考23


的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

其它参考24


使用内置的和最简单的一个,即字符串上的match()。要实现您期待的目标,请执行以下操作:


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

其它参考25


最简单的方法确实是使用 indexOf 。要只检查字符串string的子字符串substr,您可以使用此方法:


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


现在,您可以使用此ecen更短的方法来检查字符串是否包含特殊子字符串:


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


这里也是一个JSFiddle。[138]