JS search in object values

Question

I have an array of homogeneous objects like so;

[
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
]

I'd like to search these objects' values (not keys) with a keyword, and return an array of objects that contain the keyword in any of the values.

So for example, with a keyword r, I would get all the objects ("baR" in object #1, "loRem" in object #2 and "doloR" in object #3). With a keyword lo, I would get objects 2 and 3 ("LOrem" and "doLOr"), with a, I'd get objects 1 and 3, ("bAr" and "Amet"). With the keyword foo however, I would get an empty array, since "foo" is a key, and isn't found in any of the values (unlike "bar")... you get the idea.

How would I go about doing this? Thanks a lot in advance!

• Oleg Mikheev: If you're using jQuery then it's a possible duplicate of stackoverflow.com/questions/5288833/…

Answer 1

Something like this:

var objects = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
];
var results = [];
var toSearch = "lo";
for(var i=0; i<objects.length; i++) {
 for(key in objects[i]) {
 if(objects[i][key].indexOf(toSearch)!=-1) {
 results.push(objects[i]);
 }
 }
}

The results array will contain all matched objects.

If you search for 'lo', the result will be like:

[{ foo="lorem", bar="ipsum"}, { foo="dolor", bar="amet"}]

NEW VERSION - Added trim code, code to ensure no duplicates in result set.

function trimString(s) {
 var l=0, r=s.length -1;
 while(l < s.length && s[l] == ' ') l++;
 while(r > l && s[r] == ' ') r-=1;
 return s.substring(l, r+1);
}
function compareObjects(o1, o2) {
 var k = '';
 for(k in o1) if(o1[k] != o2[k]) return false;
 for(k in o2) if(o1[k] != o2[k]) return false;
 return true;
}
function itemExists(haystack, needle) {
 for(var i=0; i<haystack.length; i++) if(compareObjects(haystack[i], needle)) return true;
 return false;
}
var objects = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor blor",
 "bar" : "amet blo"
 }
];
function searchFor(toSearch) {
 var results = [];
 toSearch = trimString(toSearch); // trim it
 for(var i=0; i<objects.length; i++) {
 for(var key in objects[i]) {
 if(objects[i][key].indexOf(toSearch)!=-1) {
 if(!itemExists(results, objects[i])) results.push(objects[i]);
 }
 }
 }
 return results;
}
console.log(searchFor('lo '));

• techfoobar: Edited the for loop a little. Now if you set toSearch to 'lo', output will be: [{foo="lorem"}, { foo="dolor"}]
• techfoobar: Have updated my answer. Hope this is what you were intending to achieve.
• techfoobar: Do you mean spaces at the end? In that case, a simple trim should work? Can you provide a sample (with spaces) of toSearch value and the object values that you were trying with?
• techfoobar: So i modified my answer to add a) trimming code (to trim the search string prior to searching and) and b) more complete array object search code to ensure we don't have duplicates in the result set. Now i guess it works the way you want. Please check my updated answer. Discard the previous version and use the one below the new EDIT section in the answer.
• techfoobar: To make it case insensitive: Inside the searchFor(..) function, replace the line if(objects[i][key].indexOf(toSearch)!=-1) { with if(objects[i][key].toLowerCase().indexOf(toSearch)!=-1) { and replace the line toSearch = trimString(toSearch); with toSearch = trimString(toSearch).toLowerCase();

Answer 2

All the other old answers use a for in loop, modern JavaScript has Object.keys. Combine that with some, includes, and filter and it is a bit nicer.

var a = [{
 name: 'xyz',
 grade: 'x'
}, {
 name: 'yaya',
 grade: 'x'
}, {
 name: 'x',
 frade: 'd'
}, {
 name: 'a',
 grade: 'b'
}];
function filterIt(arr, searchKey) {
 return arr.filter(function(obj) {
 return Object.keys(obj).some(function(key) {
 return obj[key].includes(searchKey);
 })
 });
}
console.log("find 'x'", filterIt(a,"x"));
console.log("find 'a'", filterIt(a,"a"));
console.log("find 'z'", filterIt(a,"z"));

Or with ES6

function filterIt(arr, searchKey) {
 return arr.filter(obj => Object.keys(obj).some(key => obj[key].includes(searchKey)));
}

• DrWaky: With this code from @epascarello you can find an object that has a key that contains the searchKey, but if you are searching a total match you should change the test function of "some" method using "===" instead "includes": some(key => obj[key] === searchKey)
• Harsh Patel: this will not work if I pass any number as a value. like [{"q":1,"r":null,"c":null},{"q":2,"r":null,"c":null},{"q":3,"r":null,"c":null}]
• epascarello: Well the OP had strings which has includes. Numbers do not have that method @HarshPatel
• Luan Cardoso: Tks! I would add just the String() cast and the .uppercase() on both sides of the comparison.
• Robert Smith: I am getting "arr.filter is not a function" when using above example. Any ideas?

Answer 3

This is a succinct way with modern Javascript:

var objects = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor blor",
 "bar" : "amet blo"
 }
];
const query = "lo";
const filteredItems = objects.filter(item => `${item.foo} ${item.bar}`.includes(query));

Answer 4

This is a cool solution that works perfectly

const array = [{"title":"tile hgfgfgfh"},{"title":"Wise cool"},{"title":"titlr DEytfd ftgftgfgtgtf gtftftft"},{"title":"This is the title"},{"title":"yeah this is cool"},{"title":"tile hfyf"},{"title":"tile ehey"}];
var item = array.filter(item=>item.title.toLowerCase().includes('this'));
 alert(JSON.stringify(item))

EDITED

const array = [{"title":"tile hgfgfgfh"},{"title":"Wise cool"},{"title":"titlr DEytfd ftgftgfgtgtf gtftftft"},{"title":"This is the title"},{"title":"yeah this is cool"},{"title":"tile hfyf"},{"title":"tile ehey"}];
// array.filter loops through your array and create a new array returned as Boolean value given out "true" from eachIndex(item) function 
var item = array.filter((item)=>eachIndex(item));
//var item = array.filter();
function eachIndex(e){
console.log("Looping each index element ", e)
return e.title.toLowerCase().includes("this".toLowerCase())
}
console.log("New created array that returns \"true\" value by eachIndex ", item)

• phurst-so: Is there any chance you'd be willing to explain a little more about the itme=>item. How exactly is it working? I haven't found any great explanations so far.
• Amin NAIRI: Why using var when you could use const for the item variable?

Answer 5

This is a proposal which uses the key if given, or all properties of the object for searching a value.

function filter(array, value, key) {
 return array.filter(key
 ? a => a[key] === value
 : a => Object.keys(a).some(k => a[k] === value)
 );
}
var a = [{ name: 'xyz', grade: 'x' }, { name: 'yaya', grade: 'x' }, { name: 'x', frade: 'd' }, { name: 'a', grade: 'b' }];
console.log(filter(a, 'x'));
console.log(filter(a, 'x', 'name'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

• Aniruddhsingh Rathore: Thanks for the answer. It works perfectly but works only when the search value exactly matches to the values in the arrays of objects.
• Peter Krauss: Hi Nina, you can enhance changing a[key] === value to a[key].indexOf(value) > -1 or other used here. As you use configuration parameters, you can use indexOf as default and === as optional.

Answer 6

The search function will return all objects which contain a value which has contains the search query

function search(arr, s){
 var matches = [], i, key;
 
 for( i = arr.length; i--; )
 for( key in arr[i] )
 if( arr[i].hasOwnProperty(key) && arr[i][key].indexOf(s) > -1 )
 matches.push( arr[i] ); // <-- This can be changed to anything
 return matches;
};
// dummy data
var items = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
];
 
var result = search(items, 'lo'); // search "items" for a query value
console.log(result); // print the result

• vsync: this is quick, no regex, AND a check to make sure no there are no prototyped keys with hasOwnProperty.
• Syed Raheem Uddin: quick to search content in all key property,

Answer 7

Modern Javascript 😄

const objects = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor blor",
 "bar" : "amet blo"
 }
];
const keyword = 'o';
const results = objects.filter(object => Object.values(object).some(i => i.includes(keyword)));
console.log(results);
// results [{ foo: 'lorem', bar: 'ipsum' },{ foo: 'dolor blor', bar: 'amet blo' }]

Answer 8

search(searchText) {
 let arrayOfMatchedObjects = arrayOfAllObjects.filter(object => {
 return JSON.stringify(object)
 .toString()
 .toLowerCase()
 .includes(searchText);
 });
 return arrayOfMatchedObjects;
}

This could be very simple, easy, fast and understandable Search function for some of you just like me.

• misolo: In this solution also the keys of the object included in the result

Answer 9

var search(subject, objects) {
 var matches = [];
 var regexp = new RegExp(subject, 'g');
 for (var i = 0; i < objects.length; i++) {
 for (key in objects[i]) {
 if (objects[i][key].match(regexp)) matches.push(objects[i][key]);
 }
 }
 return matches;
};
var items = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
];
search('r', items); // ["bar", "lorem", "dolor"]

Answer 10

As a Javascripter Lv. 1 I just learned to search for strings in objects with this:

function isThere( a_string, in_this_object )
{
 if( typeof a_string != 'string' )
 {
 return false;
 }
 for( var key in in_this_object )
 {
 if( typeof in_this_object[key] == 'object' || typeof in_this_object[key] == 'array' )
 {
 if ( isThere( a_string, in_this_object[key] ) )
 {
 return true;
 }
 }
 else if( typeof in_this_object[key] == 'string' )
 {
 if( a_string == in_this_object[key] )
 {
 return true;
 }
 }
 }
 return false;
}

I know is far from perfect but it is useful.

Feel free to comment in order to improve this.

• boca: I took yours and used it to loop through a ko observable object. I had to make changes but it worked. THanks
• Goose: I edited your answer to fix a bug where it would return early if the first recursion did not match. It should keep searching the rest of the object instead of returning false early before then. If you think this is in error, feel free to explain and revert my edit.

Answer 11

Although a bit late, but a more compact version may be the following:

/**
* @param {string} quickCriteria Any string value to search for in the object properties.
* @param {any[]} objectArray The array of objects as the search domain
* @return {any[]} the search result
*/
onQuickSearchChangeHandler(quickCriteria, objectArray){
 let quickResult = objectArray.filter(obj => Object.values(obj).some(val => val?val.toString().toLowerCase().includes(quickCriteria):false));
 return quickResult;
}

It can handle falsy values like false, undefined, null and all the data types that define .toString() method like number, boolean etc.

Answer 12

You can use this javascript lib, DefiantJS (http://defiantjs.com), with which you can filter matches using XPath on JSON structures. To put it in JS code:

 var data = [
 { "foo": "bar", "bar": "sit" },
 { "foo": "lorem", "bar": "ipsum" },
 { "foo": "dolor", "bar": "amet" }
 ],
 res1 = JSON.search( data, '//*[contains(name(), 'r')]/..' ),
 res2 = JSON.search( data, '//*[contains(., 'lo')]' );
/*
res1 = [
 { "foo": "bar", "bar": "sit" },
 { "foo": "lorem", "bar": "ipsum" },
 { "foo": "dolor", "bar": "amet" }
]
*/
/*
res2 = [
 { "foo": "lorem", "bar": "ipsum" },
 { "foo": "dolor", "bar": "amet" }
]
*/

Here is a working fiddle;
http://jsfiddle.net/hbi99/2kHDZ/

DefiantJS extends the global object with the method "search" and returns an array with matches (empty array if no matches were found). You can try out the lib and XPath queries using the XPath Evaluator here:

http://www.defiantjs.com/#xpath_evaluator

Answer 13

I needed to perform a search on a large object and return the addresses of the matches, not just the matched values themselves.

This function searches an object for a string (or alternatively, uses a callback function to perform custom logic) and keeps track of where the value was found within the object. It also avoids circular references.

//Search function
var locateInObject = function(obj, key, find, result, currentLocation){
 if(obj === null) return;
 result = result||{done:[],found:{}};
 if(typeof obj == 'object'){
 result.done.push(obj);
 }
 currentLocation = currentLocation||key;
 var keys = Object.keys(obj);
 for(var k=0; k<keys.length; ++k){
 var done = false;
 for(var d=0; d<result.done.length; ++d){
 if(result.done[d] === obj[keys[k]]){
 done = true;
 break;
 }
 }
 if(!done){
 var location = currentLocation+'.'+keys[k];
 if(typeof obj[keys[k]] == 'object'){
 locateInObject(obj[keys[k]], keys[k], find, result, location)
 }else if((typeof find == 'string' && obj[keys[k]].toString().indexOf(find) > -1) || (typeof find == 'function' && find(obj[keys[k]], keys[k]))){
 result.found[location] = obj[keys[k]];
 }
 }
 }
 return result.found;
}
//Test data
var test = {
 key1: {
 keyA: 123,
 keyB: "string"
 },
 key2: {
 keyC: [
 {
 keyI: "string123",
 keyII: 2.3
 },
 "string"
 ],
 keyD: null
 },
 key3: [
 1,
 2,
 123,
 "testString"
 ],
 key4: "123string"
}
//Add a circular reference
test.key5 = test;
//Tests
console.log(locateInObject(test, 'test', 'string'))
console.log(locateInObject(test, 'test', '123'))
console.log(locateInObject(test, 'test', function(val, key){ return key.match(/key\d/) && val.indexOf('string') > -1}))

Answer 14

Came across this problem today and using a modified version of the provided code by epascarello in this thread did the trick, because that version had trouble when the object contained some values others than strings (like a number of booleans for example).

console.log('find: ', findIn(arrayOfObjects, searchKey));
const findIn = (arr, searchKey) => {
 return arr.filter(obj => 
 Object.keys(obj).some(key => {
 if (typeof obj[key] === 'string') {
 return obj[key].includes(searchKey);
 }
 })
 );
};

• recabos710: yes you did handle it but the problem stands what if the array has another array with object or something similar

Answer 15

Here is the answer in 100% PURE JavaScript:

<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 <title></title>
 <script type="text/javascript">
 var mySet = [{
 "foo": "bar",
 "bar": "sit"
 },
 {
 "foo": "lorem",
 "bar": "ipsum"
 },
 {
 "foo": "dolor",
 "bar": "amet"
 }
 ];
 function queryObject(needle, set) {
 var results = new Array();
 for (index = 0; index < set.length; index++) {
 for (key in set[index]) {
 if (set[index][key].indexOf(needle) > -1) {
 results.push(set[index]);
 }
 }
 }
 if (results.length) {
 return JSON.stringify(results);
 } else {
 return "No match!";
 }
 }
 </script>
</head>
<body>
 <form>
 <input type="text" id="prompt" onFocus="this.value='';" value="Type your query HERE" size="20" onKeyDown="document.getElementById('submit').disabled = false;">
 <input id="submit" type="button" value="Find in Object" onClick="var prompt=document.getElementById('prompt'); if(prompt.value){document.getElementById('output').innerHTML = queryObject(prompt.value, mySet);}else{prompt.value='Type your query HERE';}"
 disabled="disabled">
 <div id="output"></div>
 </form>
</body>
</html>

There are, of course, more fancy ways to traverse your object using JQuery, but this is the basic concept.

Cheers!

*EDIT: Sorry, I didn't read your question carefully enough, and modified the code to return an array of objects as you requested.

• lincolnberryiii: If you wanted to make the function more generically dynamic, you would remove the variable set declaration and pass it to the function as an argument instead; i.e: function queryObject(needle, set)
• lincolnberryiii: Sorry, I didn't read your question carefully enough, and modified the code to return an array of objects as you requested.

Answer 16

I wanted something a little different to the several good answers already here so I thought I'd post my solution. Features:

• Recursively searches
• Handles cyclic references by only processing each object once
• Allows regex for more dynamic matching on strings
• Can find multiple results

function find(needle, haystack, seen = new Set()) {
 if (typeof haystack === 'object' && !!haystack) {
 return Object.entries(haystack)
 .map(([key, value]) => {
 if (typeof value === 'object') {
 if (seen.has(value)) {
 return undefined;
 }
 seen.add(value);
 return find(needle, value, seen)
 .map(result => `${key}.${result}`);
 }
 if (value === needle) {
 return key;
 }
 if (needle instanceof RegExp && typeof value === 'string') {
 if (needle.test(value)) {
 return `${key}: '${value}'`;
 }
 }
 })
 .filter(value => !!value)
 .flat();
 }
 return [];
}

Example use:

find(/foo/, {
 foo: {
 foo: 'bar',
 bar: 'foo',
 foobar: [
 { foo: 'foo' },
 { bar: 'foobar' }
 ]
 }
})

Result:

["foo.bar: 'foo'", "foo.foobar.0.foo: 'foo'", "foo.foobar.1.bar: 'foobar'"]

• Omiod: Thank you, I had to search inside the huge window object, and it worked flawlessy

Answer 17

MAKE SIMPLE

const objects = [
 {
 "foo" : "bar",
 "bar" : "sit",
 "date":"2020年12月20日"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum",
 "date":"2018年07月02日"
 },
 {
 "foo" : "dolor",
 "bar" : "amet",
 "date":"2003年10月08日"
 },
 {
 "foo" : "lolor",
 "bar" : "amet",
 "date":"2003年10月08日"
 }
 ];
 
 
 
 const filter = objects.filter(item => {
 const obj = Object.values(item)
 return obj.join("").indexOf('2003') !== -1
 })
 
 console.log(filter)

Answer 18

Just another variation using ES6, this is what I use.

// searched keywords 
const searchedWord = "My searched exp";
// array of objects
let posts = [
 {
 text_field: "lorem ipsum doleri imet",
 _id: "89789UFJHDKJEH98JDKFD98"
 }, 
 {
 text_field: "ipsum doleri imet",
 _id: "JH738H3JKJKHJK93IOHLKL"
 }
];
// search results will be pushed here
let matches = [];
// regular exp for searching
let regexp = new RegExp(searchedWord, 'g');
// looping through posts to find the word
posts.forEach((post) => {
 if (post["text_field"].match(regexp)) matches.push(post);
});

Answer 19

Below shared for specific given property

searchContent:function(s, arr,propertyName){
 var matches = [];
 var propertyNameString=this.propertyNameToStr(propertyName);
 for (var i = arr.length; i--; ){
 if((""+Object.getOwnPropertyDescriptor(arr[i], propertyNameString).value).indexOf(s) > -1)
 matches.push(arr[i]);
 }
 return matches;
 },
 propertyNameToStr: function (propertyFunction) {
 return /\.([^\.;]+);?\s*\}$/.exec(propertyFunction.toString())[1];
 }

//usage as below

result=$localStorage.searchContent(cabNo,appDataObj.getAll(),function() { dummy.cabDriverName; })

Answer 20

I've found a way that you can search in nested object like everything search , for example list of student that have nested lesson object:

var students=[{name:"ali",family:"romandeh",age:18,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]},
 {name:"hadi",family:"porkar",age:48,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]},
 {name:"majid",family:"porkar",age:30,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]}
 ];
 
 function searchInChild(objects, toSearch){
 var _finded=false;
 for(var i=0; i<objects.length; i++) {
 for(key in objects[i]) {
 if(objects[i][key]!=null && typeof(objects[i][key] )!="boolean" && typeof(objects[i][key] )!="number"){
 if (typeof objects[i][key] == 'object') {
 _finded= searchInChild(objects[i][key],toSearch);
 }
 else if(objects[i][key].indexOf(toSearch)!=-1) {
 _finded=true;
 }
 }
 }
 }
 return _finded;
 }
 function findNested(objects, toSearch) {
 var _results=[];
 for(var i=0; i<objects.length; i++) {
 for(key in objects[i]) {
 if(objects[i][key]!=null && typeof(objects[i][key] )!="boolean" && typeof(objects[i][key] )!="number"){
 if (typeof objects[i][key] == 'object') {
 if(searchInChild(objects[i][key],toSearch)){
 _results.push(objects[i]);
 }
 }
 else if(objects[i][key].indexOf(toSearch)!=-1) {
 _results.push(objects[i]);
 }
 }
 }
 }
 return _results;
 }
 $('.quickSearch').on('click',function(){
 var _inputSeach=$('#evertingSearch').val();
 if(_inputSeach!=''){
 var _finded=findNested(students,_inputSeach);
 $('.count').html(_finded.length);}
 
 });

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<html>
<head>
</head>
<body>
<span>
<pre><code>
 var students=[{name:"ali",family:"romandeh",age:18,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]},
 {name:"hadi",family:"porkar",age:48,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]},
 {name:"majid",family:"rezaeiye",age:30,curse:[
 {lesson1:"arabic"},
 {lesson2:"english"},
 {lesson3:"history"}
 ]}
 ];
</code></pre>
<span>
<input id="evertingSearch" placeholder="Search on students" />
<input type="button" class="quickSearch" value="search" />
<lable>count:</lable><span class="count"></span>
</body>
</html>

Answer 21

I have created this easy to use library that does exactly what you are looking for: ss-search

import { search } from "ss-search"
const data = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
]
const searchKeys = ["foor", "bar"] 
const searchText = "dolor"
const results = search(data, keys, searchText)
// results: [{ "foo": "dolor", "bar": "amet" }]

Answer 22

You can use the _filter method of lodash:

return _filter((item) => item.name.includes("fo"),tempObjectHolder);

Answer 23

For ES6 syntax that takes care of null or undefined values, this may help

const data = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor",
 "bar" : "amet"
 }
]
function search(term, data){
if(term){
 const search = term.toString().toLowerCase()
 const result = data.filter((el) => {
 const a = Object.values(el);
 const r = a.filter((el) => el?.toString().toLowerCase().includes(search))
 if (r.length) {
 return el
 }
 })
 return result;
 }
}

Answer 24

You can use modern JS with specific key

const filter = (array, value, key) => {
 return array.filter(
 key
 ? (a) => a[key].toLowerCase().includes(value.toLowerCase())
 : (a) =>
 Object.keys(a).some((k) =>
 a[k].toLowerCase().includes(value.toLowerCase())
 )
 )
 }
const data = [
 {
 "foo" : "bar",
 "bar" : "sit"
 },
 {
 "foo" : "lorem",
 "bar" : "ipsum"
 },
 {
 "foo" : "dolor blor",
 "bar" : "amet blo"
 }
];
filter(data, 'o', 'foo')
// results [{ foo: 'lorem', bar: 'ipsum' },{ foo: 'dolor blor', bar: 'amet blo' }]

Answer 25

as simple as that

const find = (objs, search) => objs.filter(
 obj => Object.values(obj).some(
 val => val.includes(search)
 )
);