find the exact object by which the property is owned in the prototype chain
@param object
@param property
@returns {*}
778010
function findPrototypeForProperty(object,property){
    while(false==object.hasOwnProperty(property)){
        object = Object.getPrototypeOf(object);
    }
    return object;
}
919697
function(obj) {
  var cloned = {};
  for(var key in obj) {
    if(obj.hasOwnProperty(key)) {
      cloned[key] = obj[key];
    }
  }
  return cloned;
}
328599
public static function getProperty($object, string $property)
    {
        $getter = \Closure::bind(
            function ($object) use ($property) {
                return $object->{$property};
            },
            null,
            get_class($object)
        );

        return $getter($object);
    }
475869
protected final Object getProperty(final Object obj, final String property) {
        if ((obj == null) || (property == null) || (property.trim().length() == 0)) {
            return null;
        }
        final String[] getterNames = createGetterNames(property);
        for (int i = 0; i < getterNames.length; i++) {
            final String getter = getterNames[i];
            try {
                final Class cl = obj.getClass();
                final Method m = cl.getMethod(getter, new Class[] {});
                return m.invoke(obj, new Object[] {});
            } catch (final IllegalAccessException e) {
                throw new RuntimeException("Accessing " + getter + " method of property '" + property + "' failed (private? protected?)! ["
                        + obj.getClass() + "]", e);
            } catch (final InvocationTargetException e) {
                throw new RuntimeException(
                        "Exception within " + getter + " method of property '" + property + "'! [" + obj.getClass() + "]", e.getCause());
            } catch (final NoSuchMethodException e) {
                if (i == getter.length() - 1) {
                    throw new RuntimeException("No " + getter + " method found for property! '" + property + "'! [" + obj.getClass() + "]",
                            e);
                }
            }
        }
        throw new IllegalStateException("No getters defined in 'createGetterNames()'!");
    }
543771
public static Object getProperty(Scriptable obj, Symbol key)
    {
        Scriptable start = obj;
        Object result;
        do {
            result = ensureSymbolScriptable(obj).get(key, start);
            if (result != Scriptable.NOT_FOUND)
                break;
            obj = obj.getPrototype();
        } while (obj != null);
        return result;
    }
863920
function getProperty(object, propertyName) {
  const parts = propertyName.split('.');
  const length = parts.length;
  let property = object;

  for (let i = 0; i < length; i++) {
    if (property === undefined || property === null) {return property;}
    property = property[parts[i]];
  }

  return property;
}
34656
function(object) {
      var str = '';

      var first = true;

      for (var key in object) {
        if (Object.prototype.hasOwnProperty.call(object, key)) {
          var val = object[key];

          str += first ? '?' : '&';
          str += key;
          str += '=';
          str += val;

          first = false;
        }
      }

      return str;
    }
1178261
function (object) {
  let names = Object.getOwnPropertyNames(object)
  // For Function, we should not override following properties even though they
  // are "own" properties.
  if (typeof object === 'function') {
    names = names.filter((name) => {
      return !FUNCTION_PROPERTIES.includes(name)
    })
  }
  // Map properties to descriptors.
  return names.map((name) => {
    const descriptor = Object.getOwnPropertyDescriptor(object, name)
    const member = { name, enumerable: descriptor.enumerable, writable: false }
    if (descriptor.get === undefined && typeof object[name] === 'function') {
      member.type = 'method'
    } else {
      if (descriptor.set || descriptor.writable) member.writable = true
      member.type = 'get'
    }
    return member
  })
}
445443
function (property) {

    var isString;

    // optimal
    if ((isString = (typeof property === "string")) && !~property.indexOf(".")) {
      return this[property];
    }

    // avoid split if possible
    var chain    = isString ? property.split(".") : property,
    currentValue = this,
    currentProperty;

    // go through all the properties
    for (var i = 0, n = chain.length - 1; i < n; i++) {

      currentValue    = currentValue[chain[i]];

      if (!currentValue) return;
    }

    // might be a bindable object
    if(currentValue) return currentValue[chain[i]];
  }
458062
function(obj) {
    if (obj) {
      for (var prop in obj) {
        if (_hasOwn.call(obj, prop)) {
          delete obj[prop];
        }
      }
    }
    return obj;
  }
1045696
function hasProperty(obj, propName) {
        return obj != null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && propName in obj;
    }
814712
function keys(object) {
        var ks = [], prop;
        for (prop in object) {
            if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
        }
        return ks;
    }
568449
function getPropValue(property) {
  let value = property;
  if (typeof property === "object") {
    const keys = Object.keys(property);
    if (keys.includes("value")) {
      value = property.value;
    } else if (keys.includes("getterValue")) {
      value = property.getterValue;
    }
  }
  return value;
}
1204191
public Object getProperty(Object object) {
        return java.lang.reflect.Array.getLength(object);
    }
20047
function makeInstanceOf(object) {
  var args = slice.call(arguments, 1);
  Object.defineProperties(object, getDescriptors([this.prototype]));
  this.apply(object, args);
  return object;
}
873561
function getValue(object, prop) {
  if (!(object && object[prop])) {
    return null;
  }
  return _.isFunction(object[prop]) ? object[prop]() : object[prop];
}
690496
function (obj) {
        if (
            !obj
            || {}.toString.call(obj) !== '[object Object]'
            || obj.nodeType
            || obj.setInterval
        ) {
            return false
        }

        var hasOwn              = {}.hasOwnProperty;
        var hasOwnConstructor   = hasOwn.call(obj, 'constructor');
        // added test for node > v6
        var hasMethodPrototyped = ( typeof(obj.constructor) != 'undefined' ) ? hasOwn.call(obj.constructor.prototype, 'isPrototypeOf') : false;


        if (
            obj.constructor && !hasOwnConstructor && !hasMethodPrototyped
        ) {
            return false
        }

        //Own properties are enumerated firstly, so to speed up,
        //if last one is own, then all properties are own.
        var key;
        return key === undefined || hasOwn.call(obj, key)
    }