See if data item exists by key.
354641
function _has_item(in_arg_key){
	var retval = false;
	if( typeof anchor.current_data[in_arg_key] != 'undefined' ){
	    retval = true;
	}
	return retval;
    }
456671
def key_exists(self, key, secret=False):
        '''
        
        '''
        if len(key) < 8:
            return False
        key = key.upper()
        res = self.list_keys(secret)
        for fingerprint in res.keys:
            if fingerprint.endswith(key):
                return True
        return False
824067
def _item_exists_in_bucket(self, bucket, key, checksums):
        
        try:
            obj = self.target_s3.meta.client.head_object(Bucket=bucket, Key=key)
            if obj and obj.containsKey('Metadata'):
                if obj['Metadata'] == checksums:
                    return True
        except ClientError:
            # An exception from calling `head_object` indicates that no file with the specified name could be found
            # in the specified bucket.
            return False
1276946
def key_exists(self, namespace, key):
        

        return namespace in self.__data and key in self.__data[namespace]
72117
function has(key) {
                                if (!isObject(key)) return false;
                                var data = getWeak(key);
                                if (data === true) return uncaughtFrozenStore(this).has(key);
                                return data && $has(data, this._i);
                            }
557431
public function has($key)
    {
        if (!$this->checkExtraColumns()) {
            return false;
        }

        $this->load();

        return Arr::has($this->data, $key);
    }
19773
def exists(self, key, **opts):
        """"""
        key, store = self._expand_opts(key, opts)
        data = store.get(key)
        # Note that we do not actually delete the thing here as the max_age
        # just for this call may have triggered a False.
        if not data or self._has_expired(data, opts):
            return False
        return True
371950
def key_exists(key_id, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    r = {}
    try:
        key = conn.describe_key(key_id)
        # TODO: add to context cache
        r['result'] = True
    except boto.exception.BotoServerError as e:
        if isinstance(e, boto.kms.exceptions.NotFoundException):
            r['result'] = False
            return r
        r['error'] = __utils__['boto.get_error'](e)
    return r
583197
public static boolean containsKey(Map<?, ?> data, Object what) {
        return data != null && data.containsKey(what);
    }
704073
private function checkDataSet(array $data, $key, $isNew)
    {
        $keyExists = array_key_exists($key, $data);

        if (($isNew && !($keyExists && $data[$key] !== null)) || (!$keyExists || $data[$key] === null)) {
            throw new MissingItemAttributeException($key);
        }

        return $keyExists;
    }
925982
def _has(self, key, exact=0):

        """"""

        if not exact:
            try:
                key = self.getfullkey(key)
                return 1
            except KeyError:
                return 0
        else:
            return key in self.data
225492
def has_key(self, key):
        
        if key in self._dict:
            try: 
                self[key]
                return True
            except ValueError:
                return False
            except KeyError:
                return False
        return False
1075138
def has(self, key, mtime=None):
        
        v = self.__values.get(key, None)
        if not v:
            return False
        if self.check_modified_time:
            mtime = self._get_mtime(key, mtime)
            if mtime != self.__modified_times[key]:
                del self[key]
                return False
        return True
270690
def contains(self, key):
    '''
    '''
    path = self.object_path(key)
    return os.path.exists(path) and os.path.isfile(path)
1140027
def exists(self, record_key):
        
        ''' 
            
        '''
        
        title = '%s.exists' % self.__class__.__name__
    
    # validate inputs
        input_fields = {
            'record_key': record_key
        }
        for key, value in input_fields.items():
            object_title = '%s(%s=%s)' % (title, key, str(value))
            self.fields.validate(value, '.%s' % key, object_title)
    
    # read record headers
        record_status = self.s3.read_headers(self.bucket_name, record_key)
        if record_status:
            return True
        return False
832076
def where(self, key, value):
        
        return self.filter(lambda item: data_get(item, key) == value)
684459
public function exists($key) {
		return isset($this->_data[$key]) || isset($this->registered[$key]);
	}