Javascript 对象值中的JS搜索
我有一组类似这样的同质物体Javascript 对象值中的JS搜索,javascript,json,search,Javascript,Json,Search,我有一组类似这样的同质物体 [ { "foo" : "bar", "bar" : "sit" }, { "foo" : "lorem", "bar" : "ipsum" }, { "foo" : "dolor", "bar" : "amet" } ] 我想用关键字搜索这些对象的值（而不是键），并返回一个包含任何值中的关键字的对象数组 例如，使用关键字r，我会得到所有的对象（对象1中的“baR”，对象2中的“loRem”和对
[
{
"foo" : "bar",
"bar" : "sit"
},
{
"foo" : "lorem",
"bar" : "ipsum"
},
{
"foo" : "dolor",
"bar" : "amet"
}
]
rloafoovar搜索（主题、对象）{
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"]
var匹配=[]；
var regexp=新的regexp（主题为“g”）；
对于（var i=0；ivar 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]);
}
}
}
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 '));
函数字符串{
变量l=0，r=s。长度-1；
而（ll&s[r]=''）r-=1；
返回s.子串（l，r+1）；
}
函数比较对象（o1，o2）{
var k=''；
对于（o1中的k），如果（o1[k]！=o2[k]）返回false；
对于（o2中的k），如果（o1[k]！=o2[k]）返回false；
返回true；
}
功能项存在（草堆、针）{
对于（var i=0；i，search
函数将返回包含搜索查询的值的所有对象
功能搜索（arr，s）{
var匹配=[]，i，键；
对于（i=arr.length；i--；）
用于（输入arr[i]）
if（arr[i].hasOwnProperty（key）和&arr[i][key].indexOf（s）>-1）
matches.push（arr[i]）；//以下是100%纯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>
var mySet=[
{
“foo”：“bar”，
“酒吧”：“坐下”
},
{
“foo”：“lorem”，
“bar”：“ipsum”
},
{
“foo”：“dolor”，
“bar”：“amet”
}
];
功能查询对象（指针，设置）{
var results=新数组（）；
对于（索引=0；索引-1）{
结果：推送（设置[索引]）；
}
}
}
如果（结果长度）{
返回JSON.stringify（结果）；
}否则{
返回“不匹配！”；
}
}
当然，使用JQuery遍历对象的方法还有很多，但这是基本概念
干杯
*编辑：很抱歉，我没有仔细阅读您的问题，并修改了代码以根据您的请求返回一个对象数组。您可以使用此javascript库，即DeviantJS（），使用它可以在JSON结构上使用XPath筛选匹配项。要将其放入JS代码中：
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" }
]
*/
这是一把小提琴；
DefiantJS使用方法“search”扩展全局对象，并返回一个包含匹配项的数组（如果未找到匹配项，则返回空数组）。您可以在此处使用XPath计算器尝试lib和XPath查询：
作为一名Javascripter Lv.1，我刚刚学会了使用以下命令在对象中搜索字符串：
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;
}
我知道它远不完美，但它很有用
请随时发表评论，以改进这一点。下面是针对特定属性共享的
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];
}
//用法如下
result=$localStorage.searchContent(cabNo,appDataObj.getAll(),function() { dummy.cabDriverName; })
所有其他旧的答案都使用for-in循环，现代JavaScript有Object.keys
。将其与一些、include和filter相结合，会更好一些
var a=[{
名称：“xyz”，
等级：'x'
}, {
名字：“雅雅”，
等级：'x'
}, {
名称：“x”，
弗雷德：“d”
}, {
名称：‘a’，
成绩：“b”
}];
函数过滤器（arr，搜索键）{
返回阵列过滤器（功能（obj）{
返回Object.key（obj）.some（函数（key）{
返回obj[key]。包括（searchKey）；
})
});
}
log（“查找“x”，filterIt（a，“x”））；
log（“查找‘a’”，filterIt（a，“a”）；
console.log（“find'z'”，filterIt（a，“z”）；
这是一个建议，它使用给定的键或对象的所有属性来搜索值
函数过滤器（数组、值、键）{
返回数组.filter（键
？a=>a[键]==值
：a=>Object.keys（a）.some（k=>a[k]==value）
);
}
变量a=[{name:'xyz'，grade:'x'}，{name:'yaya'，grade:'x'}，{name:'x'，frade:'d'}，{name:'a'，grade:'b'}]；
log（过滤器（a，'x'））；
log（过滤器（a，'x，'name'）；
。作为控制台包装{max height:100%！important；top:0；}
只是使用ES6
的另一个变体，这就是我使用的
// 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);
});
虽然有点晚，但更紧凑的版本可能如下所示：
/**
* @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;
}
它可以处理falsy、undefined、null等虚假值，以及定义.toString（）
方法的所有数据类型，如数字、布尔值等。这是一个非常酷的解决方案，可以完美地工作
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))
已编辑
const数组=[{“title”：“tile hgfgffh”}，{“title”：“Wise cool”}，{“title”：“titlr DEytfd ftgftggtf gtftftftft”}，{“title”：“This is the title”}，{“title”：“tile his cool”}，{“title”：“tile hfyf”}，{“title”：“tile ehey”}；
//array.filter在数组中循环，并创建一个新数组，该数组作为eachIndex（item）函数中给出的“true”布尔值返回
var item=array.filter（（item）=>eachIndex（item））；
//var item=array.filter（）；
函数eachIndex（e）{
log（“循环每个索引元素”，e）
返回e.title.toLowerCase（）.includes（“this.toLowerCase（））
}
log（“新创建的数组，通过eachIndex返回\“true\”值”，item）
我找到了一种可以在嵌套对象中搜索的方法，比如everythin
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))
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);
}
})
);
};
search(searchText) {
let arrayOfMatchedObjects = arrayOfAllObjects.filter(object => {
return JSON.stringify(object)
.toString()
.toLowerCase()
.includes(searchText);
});
return arrayOfMatchedObjects;
}
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" }]
return _filter((item) => item.name.includes("fo"),tempObjectHolder);
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)