One line solution

substringsArray.some(substring=>yourBigString.includes(substring))

Returns true/false if substring exists/doesn't exist

Needs ES6 support

You can use some() function: to check if a string contains any element of an array.

e.g.

var fruitsArr = ['banana', 'monkey banana', 'apple', 'kiwi', 'orange'];
var myString = "I have an apple and a watermelon.";
var stringIncludesFruit = fruitsArr.some(fruit => myString.includes(fruit));

This function is pretty new. some() method accepts a callback where you define the condition you want to verify and it returns a boolean. Check the documentation at the link above.

ES6 automates looping through arrays with Array.prototype.some().

Try:

substrings.some(function(v) { return str.indexOf(v) >= 0; })

Or, to prototype this to String yourself (not recommend):

String.prototype.indexOfAny = function(arr) {
    return arr.some(function(v) { return str.indexOf(v) >= 0; });
}

Consider using regular expression:

var str = "Here is the string",
    chars = ['z','g'];

// constructs the following regexp: /[zg]/
if (new RegExp("[" + chars.join('') + "]").test(str)) {
      alert("Contains!");
}

There appears to be multiple questions here since the title and post body differ. Do you want to know if the array has an element or do you want to get the element itself? If you want to get an element, which one(s) do you want--the first occurrence, the last occurrence or an array of all occurrences?

This post is intended as a resource for future visitors who might not necessarily want to find (i.e. return the first element from the start of the array that matches a predicate) as the top answer shows. To elaborate on that answer, there's a gotcha with indiscriminately replacing some with find in a boolean context--the element returned may be falsey as in

if ([5, 6, 0].find(e => e < 3)) { // fix: use `some` instead of `find`
  console.log("you might expect this to run");
}
else {
  console.log("but this actually runs " +
    "because the found element happens to be falsey");
}

Note that e => e.includes("#") can be substituted with any predicate, so it's largely incidental to the question.

The same problem can occur when using indexOf in a condition and failing to account for the fact that 0 (the element was found at the first position in the array) is falsey.

Does any element match the predicate?

const array = ["123", "456", "#123"];
console.log(array.some(e => e.includes("#"))); // true
console.log(array.some(e => e.includes("foobar"))); // false

MDN: Array.prototype.some()

Does every element match the predicate?

const array = ["123", "456", "#123"];
console.log(array.every(e => e.includes("#"))); // false
console.log(array.every(e => /\d/.test(e))); // true

MDN: Array.prototype.every()

What is the first element that matches the predicate?

const array = ["123", "456", "#123", "456#"];
console.log(array.find(e => e.includes("#"))); // "#123"
console.log(array.find(e => e.includes("foobar"))); // undefined

MDN: Array.prototype.find()

What is the index of the first element that matches the predicate?

const array = ["123", "456", "#123", "456#"];
console.log(array.findIndex(e => e.includes("#"))); // 2
console.log(array.findIndex(e => e.includes("foobar"))); // -1

MDN: Array.prototype.findIndex()

What are all the elements that match the predicate?

const array = ["123", "456", "#123", "456#"];
console.log(array.filter(e => e.includes("#"))); // ["#123", "456#"]
console.log(array.filter(e => e.includes("foobar"))); // []

MDN: Array.prototype.filter()

What is the last element that matches the predicate?

const array = ["123", "456", "#123", "456#"];
console.log(array.findLast(e => e.includes("#"))); // "456#"
console.log(array.findLast(e => e.includes("foobar"))); // undefined

MDN: Array.prototype.findLast()

What is the index of the last element that matches the predicate?

const array = ["123", "456", "#123", "456#"];
console.log(array.findLastIndex(e => e.includes("#"))); // 3
console.log(array.findLastIndex(e => e.includes("foobar"))); // -1

MDN: Array.prototype.findLastIndex()

What are the indices of all of the elements that match the predicate?

const filterIndices = (a, pred) => a.reduce((acc, e, i) => {
  pred(e, i, a) && acc.push(i);
  return acc;
}, []);

const array = ["123", "456", "#123", "456#"];
console.log(filterIndices(array, e => e.includes("#"))); // [2, 3]
console.log(filterIndices(array, e => e.includes("foobar"))); // []

MDN: Array.prototype.reduce()

As long as it is not the best solution for long strings for which using some clever regex is definitely better, it works for short ones without whitespaces.

function checkIfWordContainsLetters(word, letters){
  word = word.toLowerCase().split('');

  for(var i = 0; i < letters.length; i++) {
    var index = word.indexOf( letters[i].toLowerCase() );
    if( index  !== -1 ) {
      // if word contains that letter, remove it
      word.splice( index , 1 );
      // if words length is 0, return true
      if( !word.length ) return true;
    }
  }
  return false;

}
checkIfWordContainsLetters("google", ["a","o","o","g","g","l","e","x"]); // returns true
checkIfWordContainsLetters("google", ["a","o","g","g","l","e","x"]); // returns false

You can use the indexOfmethod and "extend" the Array class with the method contains like this:

Array.prototype.contains = function(element){
    return this.indexOf(element) > -1;
};

with the following results:

["A", "B", "C"].contains("A") equals true

["A", "B", "C"].contains("D") equals false