How can I check if one string contains another substring in JavaScript?

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.

The problem with your code is that JavaScript is case sensitive. Your method call

indexof()

should actually be

indexOf()

Try fixing it and see if that helps:

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

You could use the JavaScript search() method.

Syntax is: string.search(regexp)

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 st.search("title") will do. If you want your test to be case insensitive, then you should do st.search(/title/i).

var index = haystack.indexOf(needle);

A contains method has been added to Strings in JavaScript 1.8.6:

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

Of course, we will have to wait decades for mainstream support :P

(source)

This piece of code should work well:

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

You can use jQuery's :contains selector.

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

Check it here: http://api.jquery.com/contains-selector/

String.contains() introduced in JavaScript 1.8.6

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

Syntax

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

Parameters

searchString

A string to be searched for within this string.

position

The position in this string at which to begin searching for searchString defaults to 0.

Example

var str = "To be, or not to be, that is the question.";

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

Note

It is only supported in Firefox from version 18 onwards.

A common way to write a contains method in JS 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.

This just worked for me. It selects for strings that do not contain the term "Deleted:"

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

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");
//or
var test = elm.className

If you were looking for an alternative to write the ugly -1 check, you prepend a ~ tilde instead.

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

More details here

Another option of doing this is:

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

x = "teststring";

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

You were looking for .indexOf^MDN.

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

Use a regular expression:

RegExp.test(string)

Since the question is pretty popular, I thought I could add a little modern flavor to the code.

var allLinks = content.document.getElementsByTagName("a")
,   il       = allLinks.length
,   i        = 0
,   test
,   alrt;

while (i < il) {
    elm  = allLinks[i++];
    test = elm.getAttribute("class");

    if (test.indexOf("title") > -1)
        console.log(elm), foundLinks++;
}
alrt = foundLinks ? "Found " + foundLinks + " title class" : "No title class found";
console.log(alrt);

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.

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.

Instead of using code snippets found here and there on the web, you can also use a well-tested and documented library like Underscore.string for this. It has an include method that does what you want:

_.str.include("foobar", "ob")
=> true

Here is the description of the library, 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.

JavaScript code to use the contains method in an array:

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

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.

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

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";
alert(string.contains("as"));

Here is a JSFiddle as well.

Try this:

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'!");

Here is an example: http://jsfiddle.net/oliverni/cb8xw/

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

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('contains');
else 
    alert('does not contain');

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

ES6 contains String.prototype.contains.

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

One more Function search

var str = "stack Overflow";
var n = str.search("Overflow");
if(n != -1)
alert('String exists')