get header value with title with default value
        try to get key from header and consider case sensitive
        e.g. header['x-log-abc'] or header['X-Log-Abc']
        :param header:
        :param key:
        :param default:
        :return:
9120
def h_v_td(header, key, default):
        
        if key not in header:
            key = key.title()

        return header.get(key, default)
770068
def getheader(self, name, default=None):
        """"""
        return self.aiohttp_response.headers.get(name, default)
1271705
def getheader(self, header, default=None):
        '''
        
        '''
        if isinstance(header, str):
            return self.headers.get(header.lower(), default)
        return self.__rawheaders.get(header, default)
1177123
def get(self, key: Any, default: Any = None) -> Any:
        
        if key in self:
            return self[key].value
        return default
1021440
public String getHeader(String name, String defaultValue) {
        return header.getValue(name, defaultValue);
    }
429822
def get_header(self, name, default=None):
        
        return self._handler.headers.get(name, default)
1095996
function (headers, headerKey, defaultValue) {
        var headerName = _.findKey(headers, function (value, key) {
            return key.toLowerCase() === headerKey.toLowerCase();
        });

        if (!headerName) {
            headers[headerKey] = defaultValue;
        }
    }
1248729
public static String getSingleValuedHeader(
            Map<String, List<String>> headers, String key) {
        List<String> values = headers.get(key);

        if (values == null) {
            return null;
        }

        if (values.size() > 1) {
            throw new IllegalArgumentException("Header with key [\"" + key
                    + "\"] isn't single valued !");
        }

        return values.get(0);
    }
216230
function(_headers,_key,_default){
            var _value = _headers[_key]||
                         _headers[_key.toLowerCase()];
            if (!_value){
                _value = _default;
                _headers[_key] = _value;
            }
            return _value;
        }
1108912
def getheader(self, name, default=None):
        
        return self.response.headers.get(name, default)
275187
def get(self, key, default=None):
        

        #function arguments override defaults
        if default is None:
            default = self.DEFAULTS.get(key, None)
        vtype = type(default)

        #we now have a valid key and type
        if default is None:
            logger.warn("Unknown key: %s, must specify default value" % key)
            return None

        if vtype not in self.VALID_KEY_TYPES:
            logger.warn("Invalid key type: %s" % vtype)
            return None

        #for gconf refer to the full key path
        key = self._fix_key(key)

        if key not in self._notifications:
            self._client.notify_add(key, self._key_changed, None)
            self._notifications.append(key)

        value = self._client.get(key)
        if value is None:
            self.set(key, default)
            return default

        value = self._get_value(value, default)
        if value is not None:
            return value

        logger.warn("Unknown gconf key: %s" % key)
        return None
587140
def get(self, key, default=None):
        
        try:
            return self[key]
        except KeyError:
            return default or self._default
1032282
def canonicalize_header(key):
    
    bits = key.split('-')
    for idx, b in enumerate(bits):
        bits[idx] = b.capitalize()
    return '-'.join(bits)
1040537
def get_key(cls, k, default=None):
        
        k = cls.__name__ + "__" + k
        if k in session:
            return session[k]
        else:
            return default
1366646
def get(self, key, default=None):
        
        if key in self.__cli:
            return self.__cli[key]
        if key in self.__config:
            return self.__config.get(key)
        if key in self.__defaults:
            return self.__defaults.get(key)
        return default
42916
def get_safe(self, section, key, default=None):
        
        try:
            return self.get(section, key)
        except (configparser.NoSectionError, configparser.NoOptionError):
            return default
865637
def get_attr(self, key, name, default=None):
        
        try:
            obj = h5py.File.__getitem__(self.hdf5, key)
        except KeyError:
            if self.parent != ():
                return self.parent.get_attr(key, name, default)
            else:
                raise
        try:
            return obj.attrs[name]
        except KeyError:
            if default is None:
                raise
            return default