搜索包含值的json对象键,然后取消设置

时间:2012-08-28 16:00:04

标签: javascript json underscore.js mlab

我正在寻找一种方法来搜索JSON对象以检查它是否包含给定值,如果它存在,则取消设置。

我的数据结构如下(评论说明):

// Search within the 'seats' array for a given 'guestID', if it exists, unset it
tables = [
   {
      "_id":{
         $oid: "one"
      },
      "seats":[
         { "guestId":"01" },
         { "guestId":"02" },
         { "guestId":"03" }
      ]
   },
   {
      "_id":{
         $oid: "two"
      },
      "seats":[
         { "guestId":"11" },
         { "guestId":"12" },
         { "guestId":"13" }
      ]
   }
]

我在这个项目中使用下划线,我尝试使用_.pluck(tables, 'seats')然后使用_.foreach但是我必须嵌套多个_.foreach语句才能访问座位数组进行搜索,我就是不确定这是不是最好的做法。是否有一种我不知道的简单方法?

此数据是从mongolab REST api返回的。这是我应该在我的初始XHR请求中做的事情,而不是获取一个大对象,然后尝试通过客户端解析它?

如果这是一个SQL请求,我只能做select tables.seats where guestId = XXX

之类的事情

1 个答案:

答案 0 :(得分:1)

每当我遇到过去的这种情况时,递归搜索功能总是非常宝贵的...这是我的一个我躺在(我通过添加删除方法扩展它)< / EM>:

function o ( target ) {
  /// if an instance of o has been created, then handle it
  if ( this instanceof o ) {
    /// O INSTANCE:
    /// an instance of o acts like a reference or pointer 
    /// to how the value it targets was reached.
    this.value = target;
    this.key = arguments[1];
    this.parent = arguments[2];
    this.toString = function(){ return 'o('+this.key+' = '+this.value+')';}
  }
  /// if no instance being created fall back to the 'scan object' code
  else {
    /// RECURSIVE CODE:
    /// the _ function is responsible for accepting the 
    /// attributeName and attributeValue search
    var _ = function ( key, value, modifier ) {
      var i, v, tar = ( modifier ? modifier.target : target ), items = [];
      /// if we are dealing with an o instance, handle slightly differently
      if ( tar instanceof o ) {
        for ( i in tar.value ) {
          /// check to see if our current key and value 
          /// match our search terms
          if ( _.test( i, (v=tar.value[i]), key, value ) ) {
            items.push(new o(v, i, tar));
          };
        };
      }
      /// if no o instance treat as a normal object or array
      else {
        for ( i in tar ) {
          if ( (v = tar[i]) ) {
            /// if we are an instance of o, recurse to actually 
            /// check the items within
            if ( v instanceof o ) {
              items = items.concat( _( key, value, {target:v} ) );
            }
            /// check to see if our current key and value match 
            /// our search terms
            else if ( _.test( i, v, key, value ) ) {
              items.push(new o(v, i, tar));
            };
          };
        };
      };
      /// if in modifier mode, don't rely on storing in scope, 
      /// return the calculated items instead
      if ( modifier ) {
        return items;
      }
      else {
        /// update what we are targeting
        target = items;
        /// return our underscore function
        return _;
      };
    };
    /// FUNCTION DECLARATIONS:
    /// a quick test to see if the key and value match (or either or)
    _.test = function ( i,v,key,value ) {
      var havekey = ( key !== null && key !== undefined ),
          haveval = ( value !== null && value !== undefined ),
          passkey = ( havekey && (i == key || key === '*') ),
          passval = ( haveval && (v == value || value === '*') );
      return ( havekey && haveval && passkey && passval ) || 
        ( havekey && !haveval && passkey ) || 
        ( haveval && !havekey && passval );
    };
    /// calculate the path needed to reach the object within the structure
    _.path = function () {
      var i = target.length, paths = [], path, cur, last;
      while ( i-- ) {
        cur = target[i]; path = [];
        do{ last = cur; if ( cur instanceof o ){ path.unshift( cur.key ); } }
          while( (cur = cur.parent) );
        paths.push(path.join('/'));
      };
      return ( paths.length == 1 ? paths[0] : paths );
    };
    /// remove the item we are targeting by stepping back 
    /// and deleting ourselves from the previous parent
    _.remove = function ( removeEntireObject ) {
      var i = target.length, paths, path, cur, last;
      while ( i-- ) {
        cur = target[i];
        /// remove the object that has the found attribute
        if ( removeEntireObject ) {
          if ( cur.parent.parent ) {
            cur.parent.parent.value[cur.parent.key] = null;
            delete cur.parent.parent.value[cur.parent.key];
          }
        }
        /// otherwise remove only the targeted attribute
        else {
          cur.parent.value[cur.key] = null;
          delete cur.parent.value[cur.key];
        }
      };
      return _;
    };
    /// a useful function for backwards navigation
    _.parent = function () {
      var i = target.length, cur, items = [], values = [];
      while ( i-- ) {
        cur = target[i];
        /// remove the object that has the found attribute
        if ( cur && cur.parent ) {
          /// store the values as we go so we can 
          /// spot and remove duplicated parents
          if ( values.indexOf(cur.parent.value) === -1 ) {
            items.push(cur.parent);
            values.push(cur.parent.value);
          }
        }
      };
      target = items;
      return _;
    }
    /// slimple debugging
    _.alert = function () {
      var i = target.length, cur;
      while ( i-- ) {
        cur = target[i];
        alert(cur);
      };
      return _;
    };
    return _;
  };
};

使用示例:

/// remove only the guestId object with a value '01'

o(tables)('*')('seats')('*')('guestId', '01').remove( true );

或:

/// remove the 'guestIds' object in the first slot for either seat

o(tables)('*')('seats')(0)('guestId', '*').parent().remove();

或:

/// remove all 'guestIds' from the first seat

o(tables)(0)('seats')('*')('guestId').parent().remove();

说明:

  • 您必须始终致电o(my_object_to_parse)
  • 传递一个参数可作为attributeName搜索。
  • 传递两个参数可用作attributeNameattributeValue搜索。
  • *充当简单的通配符,可用于处理基本数组。
  • *可用作attributeNameattributeValue
  • 每个连续的请求会进一步移动到结构中。

我暂时没有使用过这段代码,所以它可能不是100%无错误或最佳。然而,它似乎适用于您的特定用例......它还设法处理我在测试时投入的所有内容。使用.remove().parent().path().alert()之外的更多方法进行扩展应该很容易,最好添加一些错误检查。