在javascript对象中搜索具有特定值的属性?

jaql4c8m  于 2023-05-16  发布在  Java
关注(0)|答案(7)|浏览(400)

我有一个javascript对象,我想递归地搜索它,以查找包含特定值的任何属性。
我正在使用的javascript已经被缩小了,并且不那么容易跟踪。

背景

使用Bing Maps AJAX SDK它能够添加额外的平铺层。每个平铺层都有一个tilesource对象,该对象指定平铺URL的URI格式。
我遇到了一个问题,即tilesource URI只创建一次,然后缓存。因此,我不能为每个请求动态更改URL的参数(例如,根据一天中的时间更改平铺覆盖的颜色)。
请注意,此行为与Google的Map API和WP7的Bing Maps API不同,它们都允许您为每个磁贴请求动态创建URL。
查找高速缓存的URI,并且替换两个特定参数,然后使用URI来获取图块。
由于这是javascript,我想找到缓存的URI,并将其替换为一个函数,该函数动态构建URI并返回它。
我不需要在每次运行时都这样做,只需要知道属性缓存在哪里,这样我就可以编写代码来实现它。

原始问题

如果我将URI设置为“floobieblaster”这样的值,当我设置断点时,我可以递归地搜索javascript对象“floobieblaster”并获得存储该值的属性吗?

编辑添加

我正在搜索的对象似乎有一个循环引用,因此任何递归代码都可能导致堆栈溢出。
是否有任何编辑器/调试器技巧我可以使用?

5jdjgkvh

5jdjgkvh1#

像这样简单的东西应该可以工作:

var testObj = {
    test: 'testValue',
    test1: 'testValue1',
    test2: {
        test2a: 'testValue',
        test2b: 'testValue1'
    }
}

function searchObj (obj, query) {

    for (var key in obj) {
        var value = obj[key];

        if (typeof value === 'object') {
            searchObj(value, query);
        }

        if (value === query) {
            console.log('property=' + key + ' value=' + value);
        }

    }

}

如果执行searchObj(testObj, 'testValue');,它会将以下内容记录到控制台:

property=test value=testValue
property=test2a value=testValue

显然,您可以用任何您想要的东西替换console.log,或者向searchObj函数添加一个回调参数,以使其更易于重用。

**编辑:**新增query参数,可以指定调用函数时要搜索的值。

monwx1rj

monwx1rj2#

此函数将在对象中搜索。当你需要在多维对象中进行搜索时,这是很有用的。花了几个小时,我从谷歌的AngularJS项目得到了这段代码。

/* Seach in Object */

var comparator = function(obj, text) {
if (obj && text && typeof obj === 'object' && typeof text === 'object') {
    for (var objKey in obj) {
        if (objKey.charAt(0) !== '$' && hasOwnProperty.call(obj, objKey) &&
                comparator(obj[objKey], text[objKey])) {
            return true;
        }
    }
    return false;
}
text = ('' + text).toLowerCase();
return ('' + obj).toLowerCase().indexOf(text) > -1;
};

var search = function(obj, text) {
if (typeof text == 'string' && text.charAt(0) === '!') {
    return !search(obj, text.substr(1));
}
switch (typeof obj) {
    case "boolean":
    case "number":
    case "string":
        return comparator(obj, text);
    case "object":
        switch (typeof text) {
            case "object":
                return comparator(obj, text);
            default:
                for (var objKey in obj) {
                    if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
                        return true;
                    }
                }
                break;
        }
        return false;
    case "array":
        for (var i = 0; i < obj.length; i++) {
            if (search(obj[i], text)) {
                return true;
            }
        }
        return false;
    default:
        return false;
}
};
sshcrbum

sshcrbum3#

这里有一些解决这个老问题的现代方法。您可以扩展它以满足您自己的需要。假设以下数据结构:

table = {
  row1: {
    col1: 'A',
    col2: 'B',
    col3: 'C'
  },
  row2: {
    col1: 'D',
    col2: 'A',
    col3: 'F'
  },
  row3: {
    col1: 'E',
    col2: 'G',
    col3: 'C'
  }
};

获取col3属性为C的对象的键数组:

Object.keys(table).filter(function(row) {
  return table[row].col3==='C';
});

这将返回['row1', 'row3']

获取col3属性为C的行的新对象:

Object.keys(table).reduce(function(accumulator, currentValue) {
  if (table[currentValue].col3==='C') accumulator[currentValue] = table[currentValue];
  return accumulator;
}, {});

这将返回

{
  row1: {
    col1: 'A',
    col2: 'B',
    col3: 'C'
  },
  row3: {
    col1: 'E',
    col2: 'G',
    col3: 'C'
  }
}

请注意,上面的答案是从similar question导出的。

eivnm1vs

eivnm1vs4#

这是我的解决方案,它用正则表达式测试匹配给定的字符串/值,并返回匹配的数组。它不是递归的,但是你已经从你的问题中删除了它。
这是我在下面的帖子中的回答:搜索JavaScript对象
与其他人建议的相同的原则-为给定值搜索对象,为任何搜索此解决方案的人。
功能:

Array.prototype.findValue = function(name, value){
   var array = $.map(this, function(v,i){
        var haystack = v[name];
        var needle = new RegExp(value);
        // check for string in haystack
        // return the matched item if true, or null otherwise
      return needle.test(haystack) ? v : null;
   });
  return this;
}

您的目标:

myObject = {
        name : "soccer",
        elems : [
            {name : "FC Barcelona"},
            {name : "Liverpool FC"}
        ]
    },
    {
        name : "basketball",
        elems : [
            {name : "Dallas Mavericks"}
        ]
    }

使用说明:
(This将在myObject.elems数组中搜索匹配'FC'的'name')

var matched = myObject.elems.findValue('name', 'FC');
console.log(matched);

结果-检查您的控制台:

[Object, Object, keepMatching: function, findValue: function]
0: Object
name: "FC Barcelona"
__proto__: Object
1: Object
name: "Liverpool FC"
__proto__: Object
length: 2
__proto__: Array[0]

如果你想要一个精确的匹配,你只需要将三进制语句中的正则表达式改为基本的值匹配。即

v[name] === value ? v : null
0pizxfdo

0pizxfdo5#

下面是一个基于Bryan方法的更方便的现成静态方法:

/**
* Find properties matching the value down the object tree-structure.
* Ignores prototype structure and escapes endless cyclic nesting of
* objects in one another.
*
* @param {Object} object Object possibly containing the value.
* @param {String} value Value to search for.
* @returns {Array<String>} Property paths where the value is found. 
*/
getPropertyByValue: function (object, value) {
  var valuePaths;
  var visitedObjects = [];

  function collectValuePaths(object, value, path, matchings) {

    for (var property in object) {

      if (
        visitedObjects.indexOf(object) < 0 &&
        typeof object[property] === 'object') {

        // Down one level:

        visitedObjects.push(
          object);

        path =
          path +
          property + ".";

        collectValuePaths(
          object[property],
          value,
          path,
          matchings);
      }

      if (object[property] === value) {

        // Matching found:

        matchings.push(
          path +
          property);
      }

      path = "";
    }

    return matchings;
  }

  valuePaths =
    collectValuePaths(
      object,
      value,
      "",
      []);

   return valuePaths;
}

对于对象

var testObj = {
  test: 'testValue',
  test1: 'testValue1',
  test2: {
      test2a: 'testValue',
      test2b: 'testValue1'
  }
}

将导致

["test", "test2.test2a"]
e4eetjau

e4eetjau6#

我编辑了Bryan Downing answer来打印深度对象的层次结构:

function searchObj (obj, query, prefix /*not to be set*/) {
    prefix = prefix || "---";
    var printKey;

    for (var key in obj) {
        var value = obj[key];

        if (typeof value === 'object') {
            if (searchObj(value, query, prefix + "|---")) {
                console.log(prefix + ' ' + key);
                printKey = true;
            }
        }

        if (value === query) {
            console.log(prefix + ' ' + key + ' = ' + value);

            return true;
        }
    }

    return printKey;
}

然后,运行searchObj(testObj, 'testValue');

lfapxunr

lfapxunr7#

以下是@Hardik Sondagar回答的修改版本:

const Searcher = {
    comparator: function (obj, text) {
        if (obj && text && typeof obj === 'object' && typeof text === 'object') {
            for (var objKey in obj) {
                if (objKey.charAt(0) !== '$' && hasOwnProperty.call(obj, objKey) &&
                    this.comparator(obj[objKey], text[objKey])) {
                    return true;
                }
            }
            return false;
        }
        text = ('' + text).toLowerCase();
        return ('' + obj).toLowerCase().indexOf(text) > -1;
    },
    seen: {},
    path: [],
    search: function(obj, text) {
        this.seen = {}
        this.path = []
        const found = this.searchHelper(obj, text);
        return {
            found, path: this.path.reverse()
        }
    },
    searchHelper: function (obj, text) {
        if (typeof text == 'string' && text.charAt(0) === '!') {
            return !this.searchHelper(obj, text.substr(1));
        }
        switch (typeof obj) {
            case "boolean":
            case "number":
            case "string":
                return this.comparator(obj, text);
            case "object":
                switch (typeof text) {
                    case "object":
                        return this.comparator(obj, text);
                    default:
                        for (const objKey in obj) {
                            try {
                                if (obj in this.seen) {
                                    return false;
                                }
                                this.seen[obj] = null;
                                if (objKey.charAt(0) !== '$' && (this.comparator(objKey, text) || this.searchHelper(obj[objKey], text))) {
                                    this.path.push(objKey)
                                    return true;
                                }
                            } catch (e) {
                                console.log("Exception: " + e + ", continuing...");
                            } finally {
                                delete this.seen[obj]
                            }
                        }
                        break;
                }
                return false;
            default:
                return false;
        }
    }
}

这些变化是:

  • 支持递归对象
  • 还搜索键匹配项
  • 不会在异常时失败
  • 也返回路径

试试看:

Searcher.search(window, 'ariaBusy')

在新标签页中(在Chrome上测试)

相关问题