Question

我想在Object中搜索一个值。例如：我正在寻找“男孩”。在Object中有一个值“boy1”但Object.contains不返回true。只有当我真正搜索“boy1”时才会这样。

是否可以使用通配符或是否还有其他功能？

services:
  wsse.security.authentication.provider:
    class: YourBundle\Security\Authentication\Provider\WsseProvider
    arguments: ["", "%kernel.cache_dir%/security/nonces"]

  wsse.security.authentication.listener:
    class: YourBundle\Security\Firewall\WsseListener
    arguments: ["@security.token_storage",   "@security.authentication.manager"]

Answer 1

我自己找到了答案：

Object.each(arrayWithObjects, function(object, index) {                                                                                                                                      
   Object.each(object, function(value, key) {                                                                                                                                   
       if(value.indexOf(searchTerm) > -1) {                                                                                                                                  
           foundContacts.push(object);                                                                                                                                  
       }                                                                                                                                                                     
   });                                                                                                                                                                           
});

Answer 2

我会考虑在lodash / underscore中使用类似Array的内容来扩展where。

var a = [{
    name: 'bob',
    age: 31,
    colour: 'red'
}, {
    name: 'john',
    age: 38,
    colour: 'blue',
    job: 'chef'
}];

Array.implement({
    where: function(match){
        return Array.filter(this, function(el, index){
            var allMatch = false, k;
            for (k in match){
                if (el.hasOwnProperty(k)){
                    allMatch = (typeof match[k] === 'function') ?
                        match[k].call(el, el[k], k, index) : 
                        el[k] == match[k];
                }
                else {
                    // missing key we needed
                    allMatch = false;
                }
            }
            return allMatch;
        });
    }
});

// call from native, match by string / value.
var r = Array.where(a, { name: 'bob' });
console.log('native, value match string', r);
r = Array.where(a, { age: 31 });
console.log('native, value match number', r);

// call from prototype, match by function callback
r = a.where({ 
    name: function startsWith(value, key){
        return value.indexOf('joh') === 0;
    }
});

console.log('proto, single fn', r);

// multiple matches combos
r = a.where({ 
    job: function hasAJob(job){
        return !!job.length;
    },
    age: function(age){
        return age > 35;
    },
    colour: 'red'
});

console.log('multiple matches combos', r);

这提供了一种足够灵活的方法来迭代你的对象集合。

行动中：http://jsfiddle.net/c8gaxkny/

看看我很久以前做过的这个有趣的事情 - 允许你使用类似CSS的表达式来查找数组中的对象：

http://epitome-mvc.github.io/Epitome/#epitomecollection/find

代码位于https://github.com/epitome-mvc/Epitome/blob/master/src/epitome-collection.js#L220

Answer 3

您可以使用var foundContacts = arrayWithObjects.filter(...和Object.some()来执行此操作：

<强> Object.some（）：
如果对象中至少有一个值满足提供的测试函数，则返回true。

var foundContacts = arrayWithObjects.filter(function(object){                                                                                                                                      
   return Object.some(object, function(value, key) {                                                                                                                                   
       return value.indexOf(searchTerm) > -1;                                                                                                                             
   });                                                                                                                                                                           
});

这样就可以映射初始数组，而不必迭代对象的所有键，因为Object.some会在找到匹配项时提前返回。

MooTools - 带有通配符的Object.contains

3 个答案: