Parameters:

        +------+--------+
        | key  | value  |
        +======+========+
        | key1 | value1 |
        +------+--------+
        | key2 | value2 |
        +------+--------+
184593
def set_url_path_with_params(context, url_path_str_format):
    
    safe_add_http_request_context_to_behave_context(context)
    table_as_json = dict(context.table)
    url_path = url_path_str_format % table_as_json
    context.http_request_context.url_path = url_path
671144
def params_sorted_by_key(params)
      case params
      when Hash
        params.map     { |k, v| [k.to_s, params_sorted_by_key(v)] }
              .sort_by { |k, v| k }
              .to_h
      when Array
        params.map { |val| params_sorted_by_key(val) }
      else
        params.to_s
      end
    end
32514
def keys_values(data, *keys):
    """"""
    values = []
    if is_mapping(data):
        for key in keys:
            if key in data:
                values.extend(ensure_list(data[key]))
    return values
570463
def optional_parameters
      definition_lambda.parameters.select { |key,_value| key == :key }.map { |_key,value| value }
    end
1267776
def link(self, key1, key2):
        
        # TODO make this have more than one key linked
        # TODO Maybe make the value a set?
        self._linked_keys[key1] = key2
        self._linked_keys[key2] = key1
385046
def _keys_via_value_nonrecur(d,v):
    '''
        
    '''
    rslt = []
    for key in d:
        if(d[key] == v):
            rslt.append(key)
    return(rslt)
66935
function keys(value) {
  var result = []
  var key

  for (key in value) {
    result.push(key)
  }

  return result
}
82285
def []=(key, value)
      new_entry = entry_to_modify(key, value)
      new_entry[:key] = key
      new_entry[:value] = value
    end
702842
def key_value(options = {}, &block)
      options ||= {}

      if options[:key]
        options[:values] ||= []
        options[:values][0] = options[:key]
      end
      if options[:value]
        options[:values] ||= []
        options[:values][1] = options[:value]
      end

      options = {
          cell_1_font_style: :bold
      }.merge(options.except(:key, :value))

      cells options, &block
    end
719226
def map_values(f, D):
    ''''''
    return { key:f(val) for key,val in D.iteritems() }
94798
public static String getConcatenatedParameters(Map<String, String> parameters, String... keys) {
        StringBuilder keyValues = new StringBuilder();
        for(String key : keys) {
            String value = parameters.get(key.toLowerCase().trim());
            if(value!=null) {
                if(keyValues.length()!=0) {
                    keyValues.append("&");
                }
                keyValues.append(key.toUpperCase());
                keyValues.append("=");
                keyValues.append(value);
            }
        }
        return keyValues.toString();
    }
205754
def []=(key, val)
      key = key.to_sym
      raise EnvironmentError, "#{key} already binded" if @map.has_key?(key)
      @map[key] = val
    end
228277
function zip(keys, values) {
  if (keys.length !== values.length) {
    throw Error(`Incorrect number of arguments, expected: ${keys.length}, arguments received: ${values.join(', ')}`)
  }

  return keys.reduce((all, key, idx) => ({...all, [key]: values[idx]}), {})
}
878805
def []=(key, value)
      return super if has_key?(key)
      alt = alternate_key(key)
      has_key?(alt) ? super(alt, value) : super
    end
730684
def _process_key_val(self, instance, key, val):
        '''
        
        '''
        if instance.check_precondition(key, val):
            combined = '{k}:{v}'.format(k=key, v=val)
            self._increment_total_stat(combined)
            self._increment_plugin_stat(
                instance.__class__.__name__,
                combined)
            instance.handle(key, val)
            self.redis_conn.delete(key)
            failkey = self._get_fail_key(key)
            if self.redis_conn.exists(failkey):
                self.redis_conn.delete(failkey)
1013218
private void addParameter(final String key, final String value,
        final Map<QueryParameter, String> newParams, final Set<QueryParameter> impl) {

        try {
            final QueryParameter ep = QueryParameter.valueOf(key.toUpperCase());
            if (!impl.contains(ep)) {
                throw new JaxRxException(400, "Parameter '" + key
                    + "' is not supported by the implementation.");
            }

            // append multiple parameters
            final String old = newParams.get(ep);
            // skip multiple key/value combinations if different to OUTPUT
            if (ep != QueryParameter.OUTPUT && ep != QueryParameter.VAR && old != null)
                return;

            // use \1 as delimiter for multiple values
            final char del = ep == QueryParameter.OUTPUT ? ',' : 0x01;
            newParams.put(ep, old == null ? value : old + del + value);
        } catch (final IllegalArgumentException ex) {
            throw new JaxRxException(400, "Parameter '" + key + "' is unknown.");
        }
    }
1135709
function combineQueryParams (qs1, qs2) {
  var combined = {};

  function mergeQueryParams (obj) {
    _.forOwn(obj, function (val, key) {
      combined[key] = val;
    });
  }

  mergeQueryParams(qs.parse(qs1 || ''));
  mergeQueryParams(qs.parse(qs2 || ''));

  return Object.keys(combined).length === 0 ? undefined : qs.stringify(combined);
}