Concat strings as many as args.

@param param[]

@return string
334441
public static function concat()
    {
        $args = func_get_arg();
        $string = '';

        foreach ($args as $arg) {
            $string .= $arg;
        }

        return $string;
    }
1189977
public function mergeArgsAndParams(array $args, array $params = null)
    {

        if ($params) {
            foreach ($args as &$arg) {
                if (is_array($arg)) {
                    foreach ($params as &$param) {
                        if (is_array($param)) {
                            $arg = $param;
                            unset($param);
                            break;
                        }
                    }
                }
            }
        }

        if (is_array($params)) {
            return array_merge($args, $params);
        }

        return $args;
    }
815201
public static String arrayAsString(final String[] arg, String separator) {

        StringBuffer result = new StringBuffer();
        for (int i = 0; i < arg.length; i++) {
            result.append(arg[i]);
            if ((i + 1) < arg.length) {
                result.append(separator);
            }
        }
        return result.toString();
    }
983272
function _combineObject(params, arr) {
  const ret = {};
  _.each(arr, (arg, i) => {
    ret[params[i]] = arg;
  });
  return ret;
}
912966
private String parameterToString(Object param) {
        if (param == null) {
            return "";
        } else if (param instanceof Date) {
            return formatDate((Date) param);
        } else if (param instanceof Collection) {
            StringBuilder b = new StringBuilder();
            for (Object o : (Collection) param) {
                if (b.length() > 0) {
                    b.append(",");
                }
                b.append(String.valueOf(o));
            }
            return b.toString();
        } else {
            return String.valueOf(param);
        }
    }
1027407
public static String concatenate(EvaluationContext ctx, Object... args) {
        StringBuilder sb = new StringBuilder();
        for (Object arg : args) {
            sb.append(Conversions.toString(arg, ctx));
        }
        return sb.toString();
    }
1323881
function mergeParams(params, addition) {
        return (
            // if it's uncontested, then just return the addition.
            (!params) ? addition
            // if the existing value is an array, then concat it.
            : ($.isArray(params)) ? params.concat(addition)
            // if the existing value is not an array, and either are not objects, arrayify it.
            : (!$.isPlainObject(params) || !$.isPlainObject(addition)) ? [params].concat(addition)
            // else merge them as objects, which is a little more complex
            : mergeObjects(params, addition)
        );
    }
1217250
function(arrOrObj1, arrOrObj2 /* , ... */) {
      // I tried to implement this with call() but I kept
      // getting arrays in my values. We still get the
      // benefit of concat() and its built-in support for
      // treating arrays and scalar values differently. -Tom
      var result = [];
      var i;
      for (i = 0; (i < arguments.length); i++) {
        result = result.concat(arguments[i]);
      }
      return result;
    }
77392
def concat(args):
    
    import pdb
    pdb.set_trace()
    t = [matlabarray(a) for a in args]
    return np.concatenate(t)
951396
function encodeParams(params) {
    var queryString;
    if (params && Object.keys(params)) {
        queryString = [].slice.call(arguments).reduce(function (a, b) {
            return a.concat(b instanceof Array ? b : [b]);
        }, []).filter(function (c) {
            return "object" === typeof c;
        }).reduce(function (p, c) {
            !(c instanceof Array) ? p = p.concat(Object.keys(c).map(function (key) {
                return [key, c[key]];
            })) : p.push(c);
            return p;
        }, []).reduce(function (p, c) {
            c.length === 2 ? p.push(c) : p = p.concat(c);
            return p;
        }, []).reduce(function (p, c) {
            c[1] instanceof Array ? c[1].forEach(function (v) {
                p.push([c[0], v]);
            }) : p.push(c);
            return p;
        }, []).map(function (c) {
            c[1] = encodeURIComponent(c[1]);
            return c.join("=");
        }).join("&");
    }
    return queryString;
}
358834
public Map<String, String> getParamMap(String params) {
    Map<String, String> result = new HashMap<String, String>();
    String[] paramlist = params.split("&");
    for (int i = 0; i < paramlist.length; i++) {
      String[] parts = paramlist[i].split("=");
      if (parts.length == 2)
        result.put(parts[0], parts[1]);
    }
    return result;
  }
1370640
public static String join(String[] array, String delimiter) {
        if (empty(array)) { return ""; }
        StringBuilder sb = new StringBuilder();
        join(sb, array, delimiter);
        return sb.toString();
    }
663241
public static function flattenArrayToString($params = array())
    {
        $string = '';
        if (!empty($params)) {
            ob_start();
            print_r($params);
            $string = @ob_get_clean();
            @ob_end_clean();
        }

        return $string;
    }
986311
private static String concat(final String... aPathsVarargs) {
        final String path;

        Objects.requireNonNull(aPathsVarargs);

        if (aPathsVarargs.length == 0) {
            path = "";
        } else {
            final StringBuffer pathBuf = new StringBuffer();

            Character lastChar = null;

            for (final String aPathsVararg : aPathsVarargs) {
                if (aPathsVararg != null) {
                    final int length;

                    if (lastChar != null && !mySeparator.equals(lastChar)) {
                        pathBuf.append(mySeparator);
                    }

                    pathBuf.append(aPathsVararg);
                    length = aPathsVararg.length();
                    lastChar = aPathsVararg.charAt(length - 1);
                }
            }

            path = pathBuf.toString();
        }

        return path;
    }
594372
private static String convertArgs(String[] args)
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < args.length; i++)
        {
            result.append(args[i]);
            if (i < args.length - 1)
            {
                result.append(' ');
            }
        }
        return result.toString().toUpperCase();
    }
141175
@SuppressWarnings("unchecked")
  public <E extends T> T[] concat(T[] oldArray, E newElement) {
    T[] arr = (T[]) Array.newInstance(type, oldArray.length + 1);
    System.arraycopy(oldArray, 0, arr, 0, oldArray.length);
    arr[oldArray.length] = newElement;
    return  arr;
  }
118402
public static String join(String[] strings, String sep) {
        return join(Arrays.asList(strings), sep);
    }