Question

民间，给定一个对象，我只需要查找并返回嵌套在以下内容中的第一个tag属性：

{
   data: { 
     cat: false,
     horse: { 
        tag: 'somestring' 
     },
     dog: false
   }       
}

note ：数据也可能是假的。

使用lodash最简单的方法是什么？使用递归函数看起来可能看起来不错......本来可能会破解一些东西，但我确定那些善良的人有更短，更容易阅读的方式

Answer 1

此迭代函数将返回第一个标记键值。

function iterate (obj, key) {
var result;

for (var property in obj) {
    if (obj.hasOwnProperty(property)) {
        // in case it is an object
        if (typeof obj[property] === "object") {
            result = iterate(obj[property], key);

            if (typeof result !== "undefined") {
                return result;
            }
        }
        else if (property === key) {
            return obj[key]; // returns the value
        }
    }   
  }
}

传递你的对象并键入函数。 iterate(obj,'tag');

Answer 2

好吧，如果你想要一种更简单的方法（不是最佳性能）并且易于操作代码，那么你可以将回调传递给JSON.parse（我们用来控制解析）并检查密钥对象的字符串化版本。

让我们创建一个简单的示例，我们会在找到第一个匹配项时将其设置为高效打破它。

这是一个简单的

＆＃13;

var obj = {
   data: { 
     cat: false,
     horse: { 
        tag: 'somestring' 
     },
     dog: false
   }       
}
function keyExist(object, key) {
    var flag = false;
    JSON.parse(JSON.stringify(object), function(k, v) {
	if(k===key) {flag=true};
    	return v;
    });
    return flag;
};

console.log('Key [tag]: ' + keyExist(obj, "tag"));
console.log('Key [dog]: ' + keyExist(obj, "dog"));
console.log('Key [rat]: ' + keyExist(obj, "rat"));

＆＃13;

现在，让我们在找到错误时抛出错误，处理并返回true，否则返回false

＆＃13;

var obj = {
   data: { 
     cat: false,
     horse: { 
        tag: 'somestring' 
     },
     dog: false
   }       
}
function keyExist(object, key) {
    try {
    	JSON.parse(JSON.stringify(object), function(k, v) {
	    if(k===key) {throw v};
            return v;
    	});
    } catch(e) {return true};
    return false;
};

console.log('Key [tag]: ' + keyExist(obj, "tag"));
console.log('Key [dog]: ' + keyExist(obj, "dog"));
console.log('Key [rat]: ' + keyExist(obj, "rat"));

＆＃13;

但是，在第二种情况下，在第一种情况的变量v和第二种情况下的变量e中都有值，如果您想要该值，则可以返回该值。 / p>

但请记住，更容易并不总是意味着更快。

Answer 3

正如您所提到的，标签将出现在＆＃34; CAT / DOG / HORSE＆＃34;中。为什么不使用简单的三元运算符

myObj.data.cat ? myObj.data.cat.tag : (myObj.data.horse ? myObj.data.horse.tag : (myObj.data.dog ? myObj.data.dog.tag : false));

Answer 4

您可以递归使用lodash的_.some()来查找嵌套属性值：

var obj = {
   data: { 
     cat: false,
     horse: { 
        tag: 'somestring' 
     },
     dog: false
   }       
};

function findProp(obj, prop) {
  var propValue; // the value that we'll return - undefined if prop wasn't found
  
  function iterate(obj) {
    // _.some can iterate arrays and objects, and will break immediately when true is returned
    return _.some(obj, function(value, key) {
      if(key === prop) { 
        propValue = value; // update the propValue
        return true; // return true to finish the loop
      }
      
      // if the prop value is an object or an array iterate it or return false
      return _.isObject(value) ? iterate(value) : false;
    });
  }
  
  iterate(obj);
  
  return propValue;
}

var result = findProp(obj, 'tag');

console.log(result);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

Answer 5

我最后放弃了聪明并快速解决了它：

//lodash
let tag = false;
_.each(data, function (thing) {
   if (_.has(thing, 'tag')) {
      tag = thing.tag;
   }
});

Answer 6

从您的角度来看，数据可以与路径data > horse > tag（或路径上的其他任何内容）两个深度的额外输入为什么不简单地使用 lodash的 {{ 1}}函数与路径??

例如

_.get（假设您可能有错误值但未定义）

或者如果您有未定义值的可能性，那么

_.get(obj, 'data.horse.cat') !== undefined

这是一个工作片段：

'tag' in (_.get(obj, 'data.horse') || {})

var obj = {
   data: { 
     cat: false,
     horse: { 
        tag: 'somestring' 
     },
     dog: false
   }       
}

console.log('tag: ' +  _.get(obj, 'data.horse.tag') )

// or if you just want to check the existance
// considering it can contain undefined value as well

console.log('tag: ' + ('tag' in _.get(obj, 'data.horse') || {}));

Javascript，找到嵌套属性（如果存在）

6 个答案: