Return null if this key is undefined
185801
@Override
  public String get(String key) {
    Object value = conf.get(key);
    if(null != value) {
      return value.toString();
    }
    else {
      return null;
    }
  }
189567
function hasKey(key) {
    return data.meta[key] !== undefined
      && (self.lookup[key] === null ||
      self.lookup[key] === data.meta[key]);
  }
1346112
function(key, context) {
        var first, keys, subkey;
        if (typeof context === "undefined" || context === null) {
            context = this;
        }
        if (key.indexOf(".") > -1) {
            keys = key.split(".");
            first = keys.shift();
            subkey = keys.join(".");
            return this._attr_get(keys.join("."), context[first]);
        } else {
            return context[key];
        }
    }
184388
@Override
  public V get(Object key)
  {
    if (key == null)
      return _nullValue;

    int hash = key.hashCode() & _mask;
    int count = _size + 1;

    K []keys = _keys;

    for (; count > 0; count--) {
      K mapKey = keys[hash];

      if (mapKey == null)
        return null;

      if (key.equals(_keys[hash]))
        return _values[hash];

      hash = (hash + 1) & _mask;
    }

    return null;
  }
262837
function(key)
        {
            // get value
            var val = this.getItem(key);

            // if null, return null
            if (val === null) {
                return null;
            }

            // parse and return value
            return JSON.parse(val);
        }
880747
function lpop(key, req) {
  var val = this.getKey(key, req);
  if(val === undefined) return null;
  var element = val.lpop();
  if(val.llen() === 0) {
    this.delKey(key, req);
  }
  return element;
}
1041451
function(key){
            this._configs = this._configs || {};
            var config = this._configs[key];
            
            if (!config || !this._configs.hasOwnProperty(key)) {
                return null;
            }
            
            return config.getValue();
        }
346561
function(key) {
            var s = Storage.storage();
            if (s == null) {
                return null;
            }
            if (_.isUndefined(s[key]) == false) {
                try {
                    return JSON.parse(s[key]);
                } catch(err) {
                    logging.error("Error parsing ", s[key], err);
                    return s[key];
                }
                
            } else {
                return null;
            }
        }
1134117
private V getForNullKey() {
	for (Entry<K, V> e = table[0]; e != null; e = e.next) {
	    if (e.key == null) return e.value;
	}
	return null;
    }
939184
function(key) {
				var self = this;
				return this.done(function(s) {
					if (!key)
						return self._state;
					var out = self._state[key];
					return (typeof out === 'undefined') ? deep.Undefined : out;
				});
			}
817586
protected Object checkUndefined(Object val) {
        if (val instanceof String && ((String) val).equals("undefined")) {
            return null;
        }
        return val;
    }
242007
public V get(Object key) {
        final int index = indexOfKey(key);
        return index >= 0 ? (V)mArray[(index<<1)+1] : null;
    }
588202
function get(key, stringify) {
  var val = this._data[key] ? this._data[key].value :
    (DEFAULTS[key] !== undefined ? DEFAULTS[key] : undefined);

  if(val === undefined) return null;
  if(stringify) {
    val = this.encode(key, val, true);
  }
  return val;
}
1193772
function(key) {
      if (!cache) return null;
      var cached = cache.get(key);
      if (cached) console.log('cache hit: %s', key);
      return cached;
    }
188913
function (key) {
            var hash = hashFunction(key), ret = false;
            var bucket = null;
            if ((bucket = this.__map[hash]) != null) {
                ret = bucket.find(key) != null;
            }
            return ret;
        }
973696
function (scope, key) {
                    if (!key) {
                        key = scope;
                        scope = this;
                    }

                    if (!key) {
                        return null;
                    }

                    var path;

                    // if we have a path object
                    if (_.isArray(key)) {
                        path = key;
                        // path element
                    } else if (_.isObject(key)) {
                        path = [key];
                    } else {
                        path = Parser.parse(key, RULE_PATH);
                    }

                    var pathElement, val,
                        parameters, fnc,
                        newParameters;
                    for (var j = 0; j < path.length; j++) {
                        if (scope == null) {
                            return undefined;
                        } else {
                            pathElement = path[j];
                            if (pathElement.type == "fnc") {
                                fnc = scope[pathElement.name];
                                parameters = pathElement.parameter;
                                newParameters = [];
                                for (var i = 0; i < parameters.length; i++) {
                                    var param = parameters[i];

                                    if (_.isArray(param)) {
                                        param = this.get(param);
                                    } else if (_.isObject(param) && param.type && param.path) {
                                        param = this.get(param.path);
                                    }
                                    newParameters.push(param);
                                }
                                scope = fnc.apply(scope, newParameters);
                            } else if (pathElement.type == "var") {
                                if (scope instanceof Bindable) {
                                    if (path.length - 1 === j) {
                                        val = scope.$[pathElement.name];
                                        if (_.isUndefined(val)) {
                                            val = scope[pathElement.name];
                                        }
                                        scope = val;
                                    } else {
                                        scope = scope.get(pathElement.name);
                                    }

                                } else {
                                    scope = scope[pathElement.name];
                                }
                            }

                            if (scope && pathElement.index != null) {
                                // if it's an array
                                if (_.isArray(scope)) {
                                    scope = scope[pathElement.index];
                                    // if it's a list
                                } else if (scope.at) {
                                    scope = scope.at(pathElement.index);
                                }
                            }
                        }
                    }
                    return scope;
                }
1230412
function get(key) {
                        if (isObject(key)) {
                            var data = getWeak(key);
                            if (data === true) return uncaughtFrozenStore(this).get(key);
                            return data ? data[this._i] : undefined;
                        }
                    }