Assuming you want to find the substring in the property value, you can use the following code:

const arr = [
  {a:'abc', b:'efg', c:'hij'},
  {a:'abc', b:'efg', c:'hij'},
  {a:'123', b:'456', c:'789'},
];

const search = 'a';

const res = arr.filter(obj => Object.values(obj).some(val => val.includes(search)));

console.log(res);

If you want to search the property name, use Object.keys instead of Object.values.

Please note that Object.values is a feature of ES2017.

Finding the array element:

let arr = [
    { name:"string 1", value:"this", other: "that" },
    { name:"string 2", value:"this", other: "that" }
];

let obj = arr.find(o => o.name === 'string 1');

console.log(obj);

Replacing the array element:

let arr = [
    { name:"string 1", value:"this", other: "that" },
    { name:"string 2", value:"this", other: "that" }
];

let obj = arr.find((o, i) => {
    if (o.name === 'string 1') {
        arr[i] = { name: 'new string', value: 'this', other: 'that' };
        return true; // stop searching
    }
});

console.log(arr);

If you look closely you will notice that:

1. You do not check if .match matched (it returns null on no match; testing for null.length will throw an error)
2. You are checking match.length > 1... the syntax you are using will return an array with exactly one item or null
3. You are missing the return statement for .filter
4. You do not assign the return value of .filter to any variable

Here is what you need to do:

var filteredItems = items.filter(function (item) {
    return defConfigs.some(function (def) {
        return (def.key in item)
            ? item[def.key].toString().toLowerCase().match('low') !== null
            : false;
    });
});
console.log(filteredItems);

Using ES6 filter, you can:

let apis = [
  {info: {title: 'select some title'}},
  {info: {title: 'some title 2'}},
  {info: {title: 'some title 3'}}
];

let toSearch = 'select'; //Will check if title have text 'search'

let result = apis.filter(o => o.info.title.includes(toSearch));

console.log(result);

If you want to filter the exact match, you can:

let apis = [
  {info: {title: 'select some title'}},
  {info: {title: 'some title 2'}},
  {info: {title: 'some title 3'}}
];

let toSearch = 'select some title'; 

let result = apis.filter(o=> o.info.title === toSearch);

console.log(result);

Use the find() method:

myArray.find(x => x.id === '45').foo;

From MDN:

The find() method returns the first value in the array, if an element in the array satisfies the provided testing function. Otherwise undefined is returned.

If you want to find its index instead, use findIndex():

myArray.findIndex(x => x.id === '45');

From MDN:

The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise -1 is returned.

If you want to get an array of matching elements, use the filter() method instead:

myArray.filter(x => x.id === '45');

This will return an array of objects. If you want to get an array of foo properties, you can do this with the map() method:

myArray.filter(x => x.id === '45').map(x => x.foo);

Side note: methods like find() or filter(), and arrow functions are not supported by older browsers (like IE), so if you want to support these browsers, you should transpile your code using Babel (with the polyfill).

Try this

n = str.match(new RegExp('\\b(' + arr.join('|') + ')\\b', 'ig')) || []).length;

1. make a dynamic Regex with i and g flag

   new RegExp('\\b(' + arr.join('|') + ')\\b', 'ig')
   

2. define an empty array as fallback

   str.match(regex) || []
   

3. return the length of the results array or the fallback array

   str.match(new RegExp('\\b(' + arr.join('|') + ')\\b', 'ig')) || []).length;
   

Thanks for providing some example code. That helps.

Let's start with your function, which has a good signature:

const excludeItems = (arrayOfSearchItems, arrayOfObjects) => { ... }

If we describe what this function should do, we would say "it returns a new array of objects which do not contain any of the search items." This gives us a clue about how we should write our code.

Since we will be returning a filtered array of objects, we can start by using the filter method:

return arrayOfObjects.filter(obj => ...)

For each object, we want to make sure that its storage does not contain any of the search items. Another way to word this is "every item in the starage array does NOT appear in the list of search items". Now let's write that code using the every method:

.filter(obj => {
  // ensure "every" storage item matches a condition
  return obj.storage.every(storageItem => {
    // the "condition" is that it is NOT in the array search items
    return arrayOfSearchItems.includes(storageItem) === false);
  });
});

Putting it all together:

const excludeItems = (arrayOfSearchItems, arrayOfObjects) => {
    return arrayOfObjects.filter(obj => {
        return obj.storage.every(storageItem => {
            return arrayOfSearchItems.includes(storageItem) === false;
        });
    });
}

Here's a fiddle: https://jsfiddle.net/3p95xzwe/

It's as simple as iterating the array and looking for the regexp

function searchStringInArray (str, strArray) {
    for (var j=0; j<strArray.length; j++) {
        if (strArray[j].match(str)) return j;
    }
    return -1;
}

Edit - make str as an argument to function.