Clear out an object of all properties
@private
540556
function clearObject(object) {
  var key;

  for (key in object) {
    if (object.hasOwnProperty(key)) {
      // Ensures only writable properties are deleted.
      try {
        delete object[key];
      } catch (e) { }
    }
  }
}
258012
function omit(obj, remove) {
  var result = {};
  if (typeof remove === 'string') {
    remove = [].slice.call(arguments, 1);
  }
  for (var prop in obj) {
    if (!obj.hasOwnProperty || obj.hasOwnProperty(prop)) {
      if (remove.indexOf(prop) === -1) {
        result[prop] = obj[prop];
      }
    }
  }
  return result;
}
721994
function () {
        var obj = PropertyBase.toJSON(this);

        // remove header array if blank
        if (_.isArray(obj.header) && !obj.header.length) {
            delete obj.header;
        }

        return obj;
    }
806541
function()
	{
		// Cleans all objects where listeners have been added
		for (var i = 0; i < mxEvent.objects.length; i++)
		{
			if (mxEvent.objects[i].mxListenerList != null)
			{
				mxEvent.removeAllListeners(mxEvent.objects[i]);
			}
		}
	}
970657
function(data, options) {
            for (var property in data) {
                if (!this.__hasProperty(property.split('.')[0])) {
                    continue;
                }

                var value = data[property];

                if (_.isUndefined(value) || _.isNull(value)) {
                    this.__removePropertyValue(property, options);
                }
                else if (_.isObject(value) && _.isEmpty(value)) {
                    this.__clearPropertyValue(property, options)
                }
                else {
                    this.__setPropertyValue(property, value, options);
                }
            }
            return this;
        }
1334324
function cleanHorribleOutput(x) {
  if (x && x.$) {
    _.extend(x, x.$);
    delete(x.$);
  }

  _.each(x, function(value, prop) {
    if (_.isArray(value) || _.isObject(value)) {
      cleanHorribleOutput(value);
    }
  });

  return x;
}
200142
def _clear_dict(endpoint_props):
    '''
    
    '''
    return dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(endpoint_props)
        if prop_val is not None
    )
1264027
public function clear()
    {
        if (is_array($this->temp_properties)) {
            foreach ($this->temp_properties as $key => $value) {
                if (property_exists($this, $key)) {
                    $this->$key = $value;
                }
            }
            unset($key, $value);

            $this->temp_properties = null;
        }
    }
1361339
function(obj, fn) {
		for (var key in obj) {
			if (fn(obj[key], key)) delete obj[key];
		}

		return obj;
	}
980398
function removeObject (obj, iterate, context) {
  if (obj) {
    if (arguments.length > 1) {
      var removeKeys = []
      var rest = []
      context = context || this
      if (!isFunction(iterate)) {
        iterate = pluckProperty(iterate)
      }
      each(obj, function (item, index, rest) {
        if (iterate.call(context, item, index, rest)) {
          removeKeys.push(index)
        }
      })
      if (isArray(obj)) {
        lastEach(removeKeys, function (item, key) {
          rest.push(obj[item])
          obj.splice(item, 1)
        })
      } else {
        rest = {}
        arrayEach(removeKeys, function (key) {
          rest[key] = obj[key]
          deleteProperty(obj, key)
        })
      }
      return rest
    }
    return clearObject(obj)
  }
  return obj
}
650131
function removeDupProperties(selector) {
  // Remove duplicated properties from bottom to top ()
  for (let actIndex = selector.nodes.length - 1; actIndex >= 1; actIndex--) {
    for (let befIndex = actIndex - 1; befIndex >= 0; befIndex--) {
      if (selector.nodes[actIndex].prop === selector.nodes[befIndex].prop) {
        selector.nodes[befIndex].remove();
        actIndex--;
      }
    }
  }
}
125431
function(to_clean) {
    _.map(to_clean, function(value, key, to_clean) {
      if (value === undefined) {
        delete to_clean[key];
      }
    });
    return to_clean;
  }
626295
function cleanObject(obj) {
  if (obj instanceof Object) {
    Object.keys(obj).forEach((key) => (obj[key] == null) && delete obj[key]);
  }
  return obj;
}
992110
function(obj) {
		var fromObj;
		for (var i = 1; i < arguments.length; i++) {
			fromObj = arguments[i];
			_.forIn(fromObj, function(value, key) {
				if (value === undefined) {
					delete obj[key];
				} else {
					obj[key] = value;
				}
			});
		}

		return obj;
	}
403730
def _clear_ignore(endpoint_props):
    '''
    
    '''
    return dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(endpoint_props)
        if prop_name not in _DO_NOT_COMPARE_FIELDS and prop_val is not None
    )
492079
def clean(self):
        
        for prop in ('imported_from', 'use', 'plus', 'templates', 'register'):
            try:
                delattr(self, prop)
            except AttributeError:
                pass
        for prop in ('configuration_warnings', 'configuration_errors'):
            try:
                if getattr(self, prop, None) is not None and not getattr(self, prop):
                    delattr(self, prop)
            except AttributeError:
                pass
577429
function exclude (object, excludedProperties) {
  const strippedObject = Object.assign({}, object)

  excludedProperties.forEach(excludedProperty => {
    delete strippedObject[excludedProperty]
  })

  return strippedObject
}