JavaEar 专注于收集分享传播有价值的技术资料


  1. If you don't like the !!~, etc. tricks, you can simply add +1 to the result of .indexOf(). This way if a string is not found, -1 + 1 = 0 will be falsy, 0.. + 1 = 1.. will be truthy:

    if ("StackOverflow".indexOf("Stack") + 1 )
        alert('does not contain');
  2. 参考答案2
  3. You can easily add a contains method to String with this statement:

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

    Note: see the comments below for a valid argument for not using this. My advice: use your own judgement.


    if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }
  4. 参考答案3
  5. This piece of code should work well:

    var str="This is testing for javascript search !!!";
    if("for") != -1) {
  6. 参考答案4
  7. In ES5

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

    In ES6 there are three new methods: includes(), startsWith(), endsWith().

    var msg = "Hello world!";
    console.log(msg.startsWith("Hello"));       // true
    console.log(msg.endsWith("!"));             // true
    console.log(msg.includes("o"));             // true
    console.log(msg.startsWith("o", 4));        // true
    console.log(msg.endsWith("o", 8));          // true
    console.log(msg.includes("o", 8));          // false

  8. 参考答案5
  9. A common way to write a contains method in JavaScript is:

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

    The bitwise negation operator (~) is used to turn -1 into 0 (falsey), and all other values will be non-zero (truthy).

    The double boolean negation operators are used to cast the number into a boolean.

  10. 参考答案6
  11. This is a function to check if a substring is existing in a string or not:

    function isStringMatch(str, str_to_match) {
        return (str.indexOf(str_to_match) > -1);
  12. 参考答案7
  13. I know that best way is str.indexOf(s) !== -1;

    I suggest another way(str.replace(s1, "") !== str):

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

  14. 参考答案8
  15. In ES6, we have something calls includes which does exactly what you want: So you can simply do this:


    Also in ES5, if you widely use it, you can simply add it like this:

    String.prototype.includes = String.prototype.includes || function(str) {
      return this.indexOf(str) > -1;
  16. 参考答案9
  17. You can use jQuery's :contains selector.


    Check it here: contains-selector

  18. 参考答案10
  19. Instead of using code snippets found here and there on the web, you can also use a well-tested and documented library. Two Options I would recommend:

    1st option: Use Lodash: It has an includes method:

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

    Lodash is the most popular javascript library dependency for npm and has loads of handy javascript utility methods. So for many projects you would want this anyway ;-)

    2nd option: Or use Underscore.string: It has an include method:

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

    Here is the description of Underscore.string, it just adds 9kb but gives you all the advantages a well-tested and documented library has over copy'n'paste code snippets:

    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.

    Note well, Underscore.string is influenced by Underscore.js but can be used without it.

    Last not Least: With JavaScript version ES6 comes an built-in includes method:

    // → true

    Most modern browsers already support it, have an eye on the ES6 compatibility table.

  20. 参考答案11
  21. 参考答案12
  22. Try this:

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

    Here is an example: jsfiddle

  23. 参考答案13
  24. One more function, search:

    var str = "Stack Overflow";
    var n ="Overflow");
    if (n != -1)
        alert('String exists')
  25. 参考答案14
  26. You can use indexOf which returns the position of the string. If not found, it will return -1. So if the method returns -1 string doesn't exist

    var string = "This is a test string",
    substring = "test";
    if(string.indexOf(substring) >= 0)
      //substring exist
      //substring does not exist
  27. 参考答案15
  28. With ECMAScript 2015, we can use includes()

    let s = "foo";
  29. 参考答案16
  30. This just worked for me. It selects for strings that do not contain the term "Deleted:"

    if (eventString.indexOf("Deleted:") == -1)
  31. 参考答案17
  32. You were looking for .indexOfMDN.

    indexOf is going to return an index to the matched substring. The index will correlate to where the substring starts. If there is no match, a -1 is returned. Here is a simple demo of that concept:

    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)

  33. 参考答案18
  34. You need to call indexOf with a capital "O" as mentioned. It should also be noted, that in JavaScript class is a reserved word, you need to use className to get this data attribute. The reason it's probably failing is because it's returning a null value. You can do the following to get your class value...

    var test = elm.getAttribute("className");
    var test = elm.className
  35. 参考答案19
  36. Another option of doing this is:

    You can use the match function, that is, something like:

    x = "teststring";
    if (x.match("test")) {
         // Code
  37. 参考答案20
  38. You can also do something like this

    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."
  39. 参考答案21
  40. Simple answer, works 100%

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

    some examples

    "hello".contains("he") // true
    "hello world".contains("lo w")//true
    "hello world".contains("lo wa")//false
    "hello world".contains(" ")//true
    "hello world".contains("  ")//false
  41. 参考答案22
  42. Very simple:

    var a = "foo", b= "oo";
    if (a.indexOf(substring) !== -1) {
        // has
  43. 参考答案23
  44. The problem with your code is that JavaScript is case sensitive. Your method call


    should actually be


    Try fixing it and see if that helps:

    if (test.indexOf("title") !=-1) {
  45. 参考答案24
  46. var index = haystack.indexOf(needle);
  47. 参考答案25
  48. 参考答案26
  49. Since the question is pretty popular, I thought I could add a little modern flavor to the code.

    // const           : creates an immutable constant
    const allLinks   = document.getElementsByTagName("a");
    // []  : gives access to the reduce method on a HTMLCollection
    // () => {}        : ES6 arrow function
    const foundLinks = [], (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`);

    BTW, the correct answer is misspelling indexOf or the non-standard String.contains. Loading an external library (especially if the code is written in pure JavaScript) or messing with String.prototype or using a regular expression is a little overkill.

  50. 参考答案27
  51. There is a sleek and better way to do this and it is using the (BitWise NOT) operator.

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

    The Bitwise Not converts "x" into -(x + 1) so, if the x turns out -1 from indexOf method.then it will be converted into -( -1 + 1) = -0 which is a falsy value .

  52. 参考答案28
  53. String.prototype.indexOf() or!

    As others have already mentioned, JavaScript strings have both an indexOf and search method.

    The key difference between both, is that indexOf is for plain substrings only, whereas search also supports regular expressions. Of course, an upside of using indexOf is that it's faster.

    See also In JavaScript, what is the difference between indexOf() and search()?.

    Implementing your own String.prototype.contains() method

    If you want to add your own contains method to every string, the best way to do it would be @zzzzBov's approach:

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

    You would use it like this:

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

    Implementing a custom utility library

    It is generally frowned upon to add your own custom methods to standard objects in JavaScript, for example, because it might break forward compatibility.

    If you really want your own contains method and/or other custom string methods, it's better to create your own utility library and add your custom string methods to that library:

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

    You would use it like this:

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

    Using a third-party utility library

    If you don't want to create your own custom helper library, there is - of course - always the option of using a third-party utility library. As mentioned by @nachtigall, the most popular ones are Lodash and Underscore.js.

    In Lodash, you could use _.includes(), which you use like this:

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

    In Underscore.js, you could use _.str.include(), which you use like this :

    _.str.include('Hello World', 'orl');
  54. 参考答案29
  55. You could use the JavaScript search() method.

    Syntax is:

    It returns the position of the match, or -1 if no match is found.

    See examples there: jsref_search

    You don't need a complicated regular expression syntax. If you are not familiar with them a simple"title") will do. If you want your test to be case insensitive, then you should do

  56. 参考答案30
  57. Simple workaround

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

    you can use in the following way

    "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 reference

  58. 参考答案31
  59. Example

    var a  = "Test String";
    } else {
         //not found 
  60. 参考答案32
  61. There are multiple ways to do this. The most frequently used would be the indexOf() method. indexOf() returns the position of the string passed to it as argument and -1 if the string doesn't contain the passed string.

    let str = "A cat and a dog";
    str.indexOf("cat"); // returns 2
    str.indexOf("panda"); // returns -1
  62. 参考答案33
  63. Yet another answer...

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

    Depending on what usually mean, there is at least one way not already presented on all previous answer.

    This could be usefull on very specific cases, but:

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

    If searchstr is present at least once, even at end of mystring, then typeof(split(...)[1]) is string (an empty string). If not present, then typeof(split(...)[1]) become undefined.


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

    But using this method could only be usefull only if arraysplt's elements will be usefull lather in the script.

    ... so this shorted method seem completely useless (I think)...

    But, if your goal is to split a string, using indexOf to ensure presence of separator is useless.

  64. 参考答案34
  65. 参考答案35
  66. JavaScript code to use the contains method in an array:

            <h2>Use of contains() method</h2>
                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>");
        <b>[If the specified element is present in the array, it returns true otherwise
        returns false.]</b>

    In the given code the contains method determines whether the specified element is present in the array or not. If the specified element is present in the array, it returns true, otherwise it returns false.

  67. 参考答案36
  68. 参考答案37
  69. String.prototype.includes() was introduced in ES6.

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


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



    A string to be searched for within this string.


    The position in this string at which to begin searching for searchString defaults to 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  


    This may require ES6 shim in older browsers.

  70. 参考答案38
  71. To collect some kind of valid solutions:

    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 = != -1;
    document.write(containResult3+', ');
    //using `split()`
    var containResult4 = stringVariable.split(findString)[0] != stringVariable;

  72. 参考答案39
  73. Since there is a complaint about using the prototype, and since using indexOf makes your code less readable, and since regexp is overkill:

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

    That is the compromise I ended up going for.

  74. 参考答案40
  75. JavaScript

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


      <p>My big string contain apples and oranges</p>
      alert($("p:contains(apples)")[0] != undefined); //will alert true if found
  76. 参考答案41
  77. Use the inbuilt and simplest one i.e match() on the string. To achieve what you are looking forward do this:

    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");
  78. 参考答案42
  79. The easyest way is indeed using indexOf. To just check a string string for a substring substr you can use this method:

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

    As you wanted the function string.contains(), you can implement it yourself like this:

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

    Now you can use this ecen shorter method to check if a string contains a special substring:

    string = "asdf";

    Here is a JSFiddle as well.

  80. 参考答案43
  81. If you were looking for an alternative to write the ugly -1 check, you prepend a ~ tilde instead.

    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:

    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:

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

    More details here

  82. 参考答案44
  83. Here is a list of current possibilities:

    1. indexOf

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

    String.prototype.indexOf returns the position of the string in the other string. If not found, it will return -1.

    2. (ES6) includes - go to answer, or this answer

    var string = "foo",
        substring = "oo";

    3. search - go to answer

    var string = "foo",
        expr = /oo/;;

    4. lodash includes - go to answer

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

    5. RegExp - go to answer

    var string = "foo",
        expr = /oo/;  // no quotes here

    6. Match - go to answer

    var string = "foo",
        expr = /oo/;

    Performance tests ( are showing that indexOf might be the best choice, if it comes to a point where speed matters.

  84. 参考答案45
  85. var string = "foo",
        substring = "oo";
    console.log(string.indexOf(substring) !== -1);

  86. 参考答案46
  87. Using Indexof that can be identified easily, Example:

    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

    The result is in comment after the line

  88. 参考答案47
  89. result = 'GBP|1800';
    //if pipe delimeter is there it returns true else false.
        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);
        console.log('not found:' +result);