Source/Types/Object.js

   1 /*
   2 ---
   3
   4 name: Object
   5
   6 description: Object generic methods
   7
   8 license: MIT-style license.
   9
  10 requires: Type
  11
  12 provides: [Object, Hash]
  13
  14 ...
  15 */
  16
  17 (function(){
  18
  19 var hasOwnProperty = Object.prototype.hasOwnProperty;
  20
  21 Object.extend({
  22
  23         subset: function(object, keys){
  24                 var results = {};
  25                 for (var i = 0, l = keys.length; i < l; i++){
  26                         var k = keys[i];
  27                         if (k in object) results[k] = object[k];
  28                 }
  29                 return results;
  30         },
  31
  32         map: function(object, fn, bind){
  33                 var results = {};
  34                 var keys = Object.keys(object);
  35                 for (var i = 0; i < keys.length; i++){
  36                         var key = keys[i];
  37                         results[key] = fn.call(bind, object[key], key, object);
  38                 }
  39                 return results;
  40         },
  41
  42         filter: function(object, fn, bind){
  43                 var results = {};
  44                 var keys = Object.keys(object);
  45                 for (var i = 0; i < keys.length; i++){
  46                         var key = keys[i], value = object[key];
  47                         if (fn.call(bind, value, key, object)) results[key] = value;
  48                 }
  49                 return results;
  50         },
  51
  52         every: function(object, fn, bind){
  53                 var keys = Object.keys(object);
  54                 for (var i = 0; i < keys.length; i++){
  55                         var key = keys[i];
  56                         if (!fn.call(bind, object[key], key)) return false;
  57                 }
  58                 return true;
  59         },
  60
  61         some: function(object, fn, bind){
  62                 var keys = Object.keys(object);
  63                 for (var i = 0; i < keys.length; i++){
  64                         var key = keys[i];
  65                         if (fn.call(bind, object[key], key)) return true;
  66                 }
  67                 return false;
  68         },
  69
  70         values: function(object){
  71                 var values = [];
  72                 var keys = Object.keys(object);
  73                 for (var i = 0; i < keys.length; i++){
  74                         var k = keys[i];
  75                         values.push(object[k]);
  76                 }
  77                 return values;
  78         },
  79
  80         getLength: function(object){
  81                 return Object.keys(object).length;
  82         },
  83
  84         keyOf: function(object, value){
  85                 var keys = Object.keys(object);
  86                 for (var i = 0; i < keys.length; i++){
  87                         var key = keys[i];
  88                         if (object[key] === value) return key;
  89                 }
  90                 return null;
  91         },
  92
  93         contains: function(object, value){
  94                 return Object.keyOf(object, value) != null;
  95         },
  96
  97         toQueryString: function(object, base){
  98                 var queryString = [];
  99
 100                 Object.each(object, function(value, key){
 101                         if (base) key = base + '[' + key + ']';
 102                         var result;
 103                         switch (typeOf(value)){
 104                                 case 'object': result = Object.toQueryString(value, key); break;
 105                                 case 'array':
 106                                         var qs = {};
 107                                         value.each(function(val, i){
 108                                                 qs[i] = val;
 109                                         });
 110                                         result = Object.toQueryString(qs, key);
 111                                 break;
 112                                 default: result = key + '=' + encodeURIComponent(value);
 113                         }
 114                         if (value != null) queryString.push(result);
 115                 });
 116
 117                 return queryString.join('&');
 118         }
 119
 120 });
 121
 122 })();
 123
 124 //<1.2compat>
 125
 126 Hash.implement({
 127
 128         has: Object.prototype.hasOwnProperty,
 129
 130         keyOf: function(value){
 131                 return Object.keyOf(this, value);
 132         },
 133
 134         hasValue: function(value){
 135                 return Object.contains(this, value);
 136         },
 137
 138         extend: function(properties){
 139                 Hash.each(properties || {}, function(value, key){
 140                         Hash.set(this, key, value);
 141                 }, this);
 142                 return this;
 143         },
 144
 145         combine: function(properties){
 146                 Hash.each(properties || {}, function(value, key){
 147                         Hash.include(this, key, value);
 148                 }, this);
 149                 return this;
 150         },
 151
 152         erase: function(key){
 153                 if (this.hasOwnProperty(key)) delete this[key];
 154                 return this;
 155         },
 156
 157         get: function(key){
 158                 return (this.hasOwnProperty(key)) ? this[key] : null;
 159         },
 160
 161         set: function(key, value){
 162                 if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
 163                 return this;
 164         },
 165
 166         empty: function(){
 167                 Hash.each(this, function(value, key){
 168                         delete this[key];
 169                 }, this);
 170                 return this;
 171         },
 172
 173         include: function(key, value){
 174                 if (this[key] == null) this[key] = value;
 175                 return this;
 176         },
 177
 178         map: function(fn, bind){
 179                 return new Hash(Object.map(this, fn, bind));
 180         },
 181
 182         filter: function(fn, bind){
 183                 return new Hash(Object.filter(this, fn, bind));
 184         },
 185
 186         every: function(fn, bind){
 187                 return Object.every(this, fn, bind);
 188         },
 189
 190         some: function(fn, bind){
 191                 return Object.some(this, fn, bind);
 192         },
 193
 194         getKeys: function(){
 195                 return Object.keys(this);
 196         },
 197
 198         getValues: function(){
 199                 return Object.values(this);
 200         },
 201
 202         toQueryString: function(base){
 203                 return Object.toQueryString(this, base);
 204         }
 205
 206 });
 207
 208 Hash.extend = Object.append;
 209
 210 Hash.alias({indexOf: 'keyOf', contains: 'hasValue'});
 211
 212 //</1.2compat>