Returns the header field corresponding to the case-insensitive key.
 Returns the default value +args+, or the result of the block, or nil,
 if there's no header field named key.  See Hash#fetch
348112
def fetch(key, *args, &block)   #:yield: +key+
      a = @header.fetch(key.downcase, *args, &block)
      a.join(', ')
    end
429822
def get_header(self, name, default=None):
        
        return self._handler.headers.get(name, default)
9120
def h_v_td(header, key, default):
        
        if key not in header:
            key = key.title()

        return header.get(key, default)
1030576
def fetch(key, type, default = nil)
			if (real_hash.has_key?(key))
				value = real_hash[key]

				# if type is not an array, but value is, flatten it.
				if (type != Array && !type.kind_of?(Array) && value.kind_of?(Array))
					value = value[0]
				end

				real = type.from_user_input(value)
				if (real != nil)
					return real
				end
			end
			return default
		end
1095996
function (headers, headerKey, defaultValue) {
        var headerName = _.findKey(headers, function (value, key) {
            return key.toLowerCase() === headerKey.toLowerCase();
        });

        if (!headerName) {
            headers[headerKey] = defaultValue;
        }
    }
172826
def _get_forwarded(request, key):
        
        forwarded = request.headers.get('Forwarded', '')
        match = re.search(
            r'(?<={}=).+?(?=[\s,;]|$)'.format(key),
            forwarded,
            re.IGNORECASE)

        if match is not None:
            header = match.group(0)

            if header[0] == '"' and header[-1] == '"':
                return header[1:-1]

            return header

        return request.headers.get('X-Forwarded-{}'.format(key.title()), '')
1108912
def getheader(self, name, default=None):
        
        return self.response.headers.get(name, default)
51464
def get(self, key, default=None):
        
        try:
            result = self._loads(self._client.hget(self.key_prefix, key))
            assert result is not None
            return result
        except (AssertionError, KeyError):
            return default or self._default
287110
def get_from_headers(request, key):
    
    value = request.headers.get(key)
    return to_native(value)
1096346
def get(key, default=None):
    
    data = get_form() or get_query_string()
    return data.get(key, default)
941390
public String getHeader(Short key) {
        if (key != null && headerCache != null) {
            return headerCache.get(key);
        }
        return null;
    }
109418
def get_header(self, header_name, default=None):
        
        return self.headers.get(
            header_name, self.unredirected_headers.get(header_name, default))
129956
def get(self, key, default=None):
        """"""
        if key not in self.table:
            return default

        return self[key]
25395
def get_block_header_by_hash(self, block_hash: Hash32) -> BlockHeader:
        
        validate_word(block_hash, title="Block Hash")
        return self.chaindb.get_block_header_by_hash(block_hash)
904899
def _get_default_value_to_cache(self, xblock):
        
        try:
            # pylint: disable=protected-access
            return self.from_json(xblock._field_data.default(xblock, self.name))
        except KeyError:
            if self._default is UNIQUE_ID:
                return self._check_or_enforce_type(self._calculate_unique_id(xblock))
            else:
                return self.default
1177123
def get(self, key: Any, default: Any = None) -> Any:
        
        if key in self:
            return self[key].value
        return default
1278757
def default(self, block, name):
        
        return self._kvs.default(self._key(block, name))