func strings.Join

197 uses

	strings (current package)
		strings.go#L421: func Join(elems []string, sep string) string {

	cloud.google.com/go/storage
		post_policy_v4.go#L374: 		err = errors.New("storage: expected metadata to begin with x-goog-meta-, got " + strings.Join(badKeys, ", "))
		storage.go#L393: 		sanitizedHeaders = append(sanitizedHeaders, fmt.Sprintf("%s:%s", header, strings.Join(values, ",")))
		storage.go#L447: 		sanitizedHeaders = append(sanitizedHeaders, fmt.Sprintf("%s:%s", header, strings.Join(values, ",")))
		storage.go#L545: 	encodedStr := strings.Join(encodedSegments, "/")
		storage.go#L571: 	signedHeaders := strings.Join(headerNames, ";")
		storage.go#L611: 		trimmedHeaders = append(trimmedHeaders, strings.Join(strings.Fields(h), " "))
		storage.go#L613: 	canonicalHeaders := strings.Join(sortHeadersByKey(trimmedHeaders), "\n")
		storage.go#L714: 		fmt.Fprintf(buf, "%s\n", strings.Join(opts.Headers, "\n"))

	contrib.go.opencensus.io/exporter/stackdriver
		metrics.go#L133: 	return fmt.Errorf("[%s]", strings.Join(errMsgs, "; "))
		metrics_batcher.go#L123: 	return fmt.Errorf("[%s]", strings.Join(errMsgs, "; "))
		stats.go#L444: 	return fmt.Sprintf("%s:%s", metric.GetType(), strings.Join(labelValues, ","))

	crypto/tls
		common.go#L1040: 			wildcardName := strings.Join(labels, ".")

	crypto/x509
		verify.go#L140: 			valid = strings.Join(c.DNSNames, ", ")

	encoding/json
		decode.go#L253: 			err.Field = strings.Join(d.errorContext.FieldStack, ".")

	encoding/xml
		typeinfo.go#L209: 			return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))

	github.com/aws/aws-sdk-go/aws
		types.go#L240: 	return strings.Join(parts, "\n")

	github.com/aws/aws-sdk-go/aws/request
		handlers.go#L315: 		ua += fmt.Sprintf(" (%s)", strings.Join(extra, "; "))

	github.com/aws/aws-sdk-go/aws/signer/v4
		stream.go#L55: 	return strings.Join([]string{
		uri_path.go#L14: 		uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/")
		v4.go#L545: 		ctx.Request.Header.Set(authorizationHeader, strings.Join(parts, ", "))
		v4.go#L630: 	ctx.signedHeaders = strings.Join(headers, ";")
		v4.go#L646: 				strings.Join(ctx.SignedHeaderVals[k], ",")
		v4.go#L650: 	ctx.canonicalHeaders = strings.Join(headerValues, "\n")
		v4.go#L662: 	ctx.canonicalString = strings.Join([]string{
		v4.go#L673: 	ctx.stringToSign = strings.Join([]string{
		v4.go#L824: 	return strings.Join([]string{

	github.com/emirpasic/gods/lists/arraylist
		arraylist.go#L193: 	str += strings.Join(values, ", ")

	github.com/emirpasic/gods/trees/binaryheap
		binaryheap.go#L111: 	str += strings.Join(values, ", ")

	github.com/evanw/esbuild/internal/fs
		filepath.go#L522: 			return fp.clean(strings.Join(elem[i:], string(fp.pathSeparator)))
		filepath.go#L540: 		return fp.clean(elem[0] + strings.Join(elem[i:], string(fp.pathSeparator)))
		filepath.go#L545: 	p := fp.clean(strings.Join(elem, string(fp.pathSeparator)))
		filepath.go#L556: 	tail := fp.clean(strings.Join(elem[1:], string(fp.pathSeparator)))

	github.com/evanw/esbuild/internal/js_lexer
		js_lexer.go#L2600: 	return strings.Join(lines, "\n")

	github.com/evanw/esbuild/internal/js_parser
		js_parser.go#L10764: 						p.warnAboutLackOfDefine(strings.Join(define.Parts, "."), r)

	github.com/go-git/gcfg/types
		int.go#L31: 	return "IntMode(" + strings.Join(modes, "|") + ")"

	github.com/go-git/go-git/v5/plumbing/format/config
		option.go#L31: 	return strings.Join(strs, ", ")
		section.go#L48: 	return strings.Join(strs, ", ")
		section.go#L59: 	return strings.Join(strs, ", ")

	github.com/go-git/go-git/v5/plumbing/object
		commit.go#L301: 		if _, err = fmt.Fprint(w, strings.Join(lines, "\n ")); err != nil {
		commit.go#L390: 	return strings.Join(output, "\n")

	github.com/go-git/go-git/v5/plumbing/protocol/packp/capability
		list.go#L195: 	return strings.Join(o, " ")

	github.com/go-git/go-git/v5/storage/filesystem/dotgit
		dotgit.go#L902: 		ref, err := d.readReferenceFile(".", strings.Join(newRelPath, "/"))

	github.com/go-redis/redis/v8
		pubsub.go#L54: 	return fmt.Sprintf("PubSub(%s)", strings.Join(channels, ", "))

	github.com/golang-migrate/migrate/v4
		util.go#L38: 	return strings.Join(strs, " and ")

	github.com/golang-migrate/migrate/v4/database
		util.go#L14: 		databaseName = strings.Join(append(additionalNames, databaseName), "\x00")

	github.com/golang/protobuf/proto
		text_decode.go#L518: 	return strings.Join(parts, ""), nil

	github.com/google/go-cmp/cmp
		compare.go#L644: 		set := strings.Join(ss, "\n\t")
		options.go#L94: 	set := strings.Join(ss, "\n\t")
		options.go#L103: 	return fmt.Sprintf("Options{%s}", strings.Join(ss, ", "))
		path.go#L105: 	return strings.TrimPrefix(strings.Join(ss, ""), ".")
		path.go#L148: 	return strings.Join(ssPre, "") + strings.Join(ssPost, "")
		report_slices.go#L236: 				s := strings.Join(ss, ", ")
		report_slices.go#L277: 				s := strings.Join(ss, ", ")
		report_text.go#L423: 		return strings.Join(ss, " and ") + " " + name
		report_text.go#L425: 		return strings.Join(ss[:n-1], ", ") + ", and " + ss[n-1] + " " + name

	github.com/google/go-cmp/cmp/cmpopts
		struct_filter.go#L51: 			panic(fmt.Sprintf("%s: %v", strings.Join(cname, "."), err))

	github.com/google/pprof/profile
		legacy_profile.go#L1130: var allocRxStr = strings.Join([]string{
		legacy_profile.go#L1191: var allocSkipRxStr = strings.Join([]string{
		legacy_profile.go#L1199: var cpuProfilerRxStr = strings.Join([]string{
		legacy_profile.go#L1207: var lockRxStr = strings.Join([]string{
		merge.go#L213: 		strings.Join(ids, "|"),
		merge.go#L214: 		strings.Join(labels, ""),
		merge.go#L215: 		strings.Join(numlabels, ""),
		merge.go#L277: 	key.lines = strings.Join(lines, "|")
		profile.go#L563: 	return strings.Join(ss, "\n") + "\n"
		profile.go#L620: 	return strings.Join(ss, "\n")
		profile.go#L643: 	return strings.Join(ss, "\n")
		profile.go#L654: 	return strings.Join(ls, " ")
		profile.go#L676: 	return strings.Join(ls, " ")
		prune.go#L32: 		return regexp.MustCompile(strings.Join(quotedNames, "|"))

	github.com/google/safehtml/template
		escape.go#L716: 		ret.linkRel = " " + strings.Join(strings.Fields(strings.TrimSpace(strings.ToLower(string(s[:i])))), " ") + " "

	github.com/hashicorp/go-multierror
		format.go#L26: 		len(es), strings.Join(points, "\n\t"))

	github.com/jackc/pgconn
		config.go#L418: 		settings["host"] = strings.Join(hosts, ",")
		config.go#L421: 		settings["port"] = strings.Join(ports, ",")

	github.com/jackc/pgtype
		numeric.go#L425: 	digits := strings.Join(parts, "")

	github.com/jackc/pgx/v4
		conn.go#L91: 	return strings.Join(parts, ".")

	github.com/jmespath/go-jmespath
		functions.go#L775: 	return strings.Join(arrayStr, sep), nil

	github.com/kevinburke/ssh_config
		config.go#L621: 	line := fmt.Sprintf("%sInclude%s%s", strings.Repeat(" ", int(inc.leadingSpace)), equals, strings.Join(inc.directives, " "))

	github.com/lib/pq
		url.go#L75: 	return strings.Join(kvs, " "), nil

	github.com/Masterminds/squirrel
		delete.go#L61: 		sql.WriteString(strings.Join(d.OrderBys, ", "))
		expr.go#L205: 	sql = strings.Join(exprs, " AND ")
		expr.go#L253: 	sql = strings.Join(exprs, " AND ")
		expr.go#L332: 	sql = strings.Join(exprs, " AND ")
		expr.go#L385: 		sql = fmt.Sprintf("(%s)", strings.Join(sqlParts, sep))
		insert.go#L82: 		sql.WriteString(strings.Join(d.Options, " "))
		insert.go#L92: 		sql.WriteString(strings.Join(d.Columns, ","))
		insert.go#L140: 		valuesStrings[r] = fmt.Sprintf("(%s)", strings.Join(valueStrings, ","))
		insert.go#L143: 	io.WriteString(w, strings.Join(valuesStrings, ","))
		select.go#L88: 		sql.WriteString(strings.Join(d.Options, " "))
		select.go#L125: 		sql.WriteString(strings.Join(d.GroupBys, ", "))
		update.go#L97: 	sql.WriteString(strings.Join(setSqls, ", "))
		update.go#L109: 		sql.WriteString(strings.Join(d.OrderBys, ", "))

	github.com/prometheus/client_golang/prometheus
		desc.go#L182: 		strings.Join(lpStrings, ","),
		metric.go#L108: 		return strings.Join([]string{namespace, subsystem, name}, "_")
		metric.go#L110: 		return strings.Join([]string{namespace, name}, "_")
		metric.go#L112: 		return strings.Join([]string{subsystem, name}, "_")

	github.com/prometheus/common/model
		labels.go#L153: 	return strings.Join(labelStrings, ", ")
		labelset.go#L139: 	return fmt.Sprintf("{%s}", strings.Join(lstrs, ", "))
		metric.go#L74: 		return fmt.Sprintf("%s{%s}", metricName, strings.Join(labelStrings, ", "))
		value.go#L233: 	return fmt.Sprintf("%s =>\n%s", ss.Metric, strings.Join(vals, "\n"))
		value.go#L363: 	return strings.Join(entries, "\n")
		value.go#L415: 	return strings.Join(strs, "\n")

	github.com/prometheus/procfs
		net_dev.go#L202: 	total.Name = strings.Join(names, ", ")

	github.com/russross/blackfriday/v2
		html.go#L299: 	attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))
		html.go#L334: 		w.Write([]byte(strings.Join(attrs, " ")))

	github.com/sergi/go-diff/diffmatchpatch
		diff.go#L455: 		aDiff.Text = strings.Join(text, "")

	github.com/yuin/goldmark-emoji
		emoji.go#L315: 		fmt.Fprintf(w, r.TwemojiTemplate, util.EscapeHTML(util.StringToReadOnlyBytes(node.Value.Name)), strings.Join(values, "-"), s)

	github.com/yuin/goldmark/ast
		inline.go#L76: 	return strings.Join(buf, ", ")
		inline.go#L531: 	m["RawText"] = strings.Join(t, "")

	github.com/yuin/goldmark/parser
		parser.go#L378: 	return fmt.Sprintf("Context{Store:%#v, Refs:%s}", p.store, strings.Join(refs, ","))

	go.opencensus.io/plugin/ochttp
		span_annotating_client_trace.go#L112: 		trace.StringAttribute("httptrace.dns_done.addrs", strings.Join(addrs, " , ")),

	go.opencensus.io/stats/view
		worker_commands.go#L76: 		cmd.err <- errors.New(strings.Join(errstr, "\n"))

	go.opencensus.io/zpages
		tracez.go#L281: 		return "Attributes:{" + strings.Join(s, ", ") + "}"

	go.opentelemetry.io/otel/api/trace
		b3_propagator.go#L122: 		supplier.Set(b3ContextHeader, strings.Join(header, "-"))

	go/ast
		ast.go#L159: 	return strings.Join(lines, "\n")

	go/build
		build.go#L751: 		return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))
		build.go#L1144: 	cmd := exec.Command("go", "list", "-e", "-compiler="+ctxt.Compiler, "-tags="+strings.Join(ctxt.BuildTags, ","), "-installsuffix="+ctxt.InstallSuffix, "-f={{.Dir}}\n{{.ImportPath}}\n{{.Root}}\n{{.Goroot}}\n{{if .Error}}{{.Error}}{{end}}\n", "--", path)
		build.go#L1717: 	res := strings.Join(chunks, srcdir)

	golang.org/x/crypto/ssh
		keys.go#L1462: 	return strings.Join(hexarray, ":")
		server.go#L388: 	return "[" + strings.Join(errs, ", ") + "]"

	golang.org/x/crypto/ssh/knownhosts
		knownhosts.go#L461: 	return strings.Join(trimmed, ",") + " " + serialize(key)
		knownhosts.go#L501: 	return strings.Join([]string{"",

	golang.org/x/mod/modfile
		rule.go#L166: 						Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
		rule.go#L177: 						Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
		rule.go#L576: 	return strings.Join(lines, "\n")
		rule.go#L586: 	return strings.Join(errStrs, "\n")

	golang.org/x/net/http2
		server.go#L2075: 		rp.header.Set("Cookie", strings.Join(cookies, "; "))
		transport.go#L982: 		return strings.Join(keys, ","), nil

	golang.org/x/net/idna
		idna10.0.0.go#L527: 		return strings.Join(l.slice, ".")

	golang.org/x/oauth2
		oauth2.go#L161: 		v.Set("scope", strings.Join(c.Scopes, " "))
		oauth2.go#L196: 		v.Set("scope", strings.Join(c.Scopes, " "))

	golang.org/x/oauth2/google
		google.go#L178: 		v.Set("scopes", strings.Join(cs.scopes, ","))

	golang.org/x/oauth2/jwt
		jwt.go#L109: 		Scope:         strings.Join(js.conf.Scopes, " "),

	golang.org/x/pkgsite/cmd/internal/cmdconfig
		cmdconfig.go#L90: 		log.Infof(ctx, "read experiments %s", strings.Join(s, ", "))

	golang.org/x/pkgsite/internal/database
		copy.go#L61: 		cols := strings.Join(columns, ", ")
		database.go#L389: 	fmt.Fprintf(&b, "(%s) VALUES", strings.Join(columns, ", "))
		database.go#L402: 		fmt.Fprintf(&b, "(%s)", strings.Join(placeholders, ", "))
		database.go#L415: 		fmt.Fprintf(&b, " RETURNING %s", strings.Join(returningColumns, ", "))
		database.go#L426: 		strings.Join(conflictColumns, ", "),
		database.go#L427: 		strings.Join(sets, ", "))
		database.go#L497: 		strings.Join(sets, ", "),    // 2
		database.go#L498: 		strings.Join(unnests, ", "), // 3
		logging.go#L74: 	argString := strings.Join(argStrings, ", ")

	golang.org/x/pkgsite/internal/fetch
		load.go#L198: 	return strings.Join(names, " ")

	golang.org/x/pkgsite/internal/frontend
		goldmark.go#L192: 	str = strings.Join(strings.FieldsFunc(str, f), "-")
		overview.go#L146: 		destURL.Path = strings.Join(parts, "/")
		section.go#L104: 		prefix2 := strings.Join(parts[:len(acctParts)+1], "/")
		section.go#L131: 		return strings.Join(parts, "/"), parts
		section.go#L133: 	return strings.Join(parts[:n+1], "/") + "/", parts[:n+1]
		server.go#L520: 		return strings.Join(s, ", ")
		styleguide.go#L222: 	return strings.Join(o, "")
		urlinfo.go#L117: 		suffix := strings.Join(endParts[1:], "/")
		versions.go#L320: 		mid := strings.Join(parts[1:len(parts)-1], "-")
		versions.go#L332: 		suffix = strings.Join(p[0:len(p)-1], ".")

	golang.org/x/pkgsite/internal/godoc/dochtml/internal/render
		synopsis.go#L215: 	return strings.Join(ss, ", ")

	golang.org/x/pkgsite/internal/log
		log.go#L128: 		extra = " (" + strings.Join(extras, ", ") + ")"
		log.go#L135: 	return strings.Join(experiment.FromContext(ctx).Active(), ", ")

	golang.org/x/pkgsite/internal/middleware
		secureheaders.go#L53: 					strings.Join(scriptHashes, " ")),
		secureheaders.go#L56: 				w.Header().Set("Content-Security-Policy", strings.Join(csp, "; "))

	golang.org/x/pkgsite/internal/postgres
		insert_module.go#L797: 		return fmt.Errorf("cannot insert module %q: %s", m.Version, strings.Join(errReasons, ", "))
		search.go#L404: 	q = strings.Join(strings.Split(q, " "), " | ")
		search.go#L466: 			(p.path, m.version, m.module_path) IN (%s)`, strings.Join(keys, ","))
		search.go#L681: 	pathTokens := strings.Join(GeneratePathTokens(args.PackagePath), " ")
		search.go#L971: 			p := strings.Join(parts[i:j], "/")
		search.go#L1048: 		q := fmt.Sprintf(`DELETE FROM search_documents WHERE package_path IN ('%s')`, strings.Join(ppaths, `', '`))
		searchdoc.go#L70: 		return makeValidUnicode(strings.Join(ws, " "))
		version.go#L111: 	return strings.Join(vs, ", ")

	golang.org/x/pkgsite/internal/proxy
		server.go#L104: 		http.ServeContent(w, r, modulePath, time.Now(), strings.NewReader(strings.Join(vList, "\n")))

	golang.org/x/pkgsite/internal/testing/htmlcheck
		htmlcheck.go#L151: 	re := strings.Join(strings.Fields(strings.TrimSpace(regexp.QuoteMeta(want))), `\s*`)

	golang.org/x/pkgsite/internal/worker
		fetch.go#L401: 	msg := strings.Join(times, ", ")
		server.go#L507: 	return fmt.Sprintf("Scheduling modules to be fetched: %s.\n", strings.Join(versions, ", ")), nil

	google.golang.org/api/googleapi
		googleapi.go#L381: 	return strings.Join(r, ",")

	google.golang.org/grpc
		resolver_conn_wrapper.go#L219: 		Desc:     fmt.Sprintf("Resolver state updated: %+v (%v)", s, strings.Join(updates, "; ")),

	google.golang.org/grpc/internal/transport
		http_util.go#L293: 	return strings.Join(errMsgs, "; ")

	google.golang.org/protobuf/encoding/protojson
		well_known_types.go#L856: 	e.WriteString(strings.Join(paths, ","))

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L288: 			ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
		stringer.go#L313: 		return "\n\t" + strings.Join(ss, "\n\t") + "\n"
		stringer.go#L315: 	return strings.Join(ss, ", ")

	google.golang.org/protobuf/internal/encoding/tag
		tag.go#L206: 	return strings.Join(tag, ",")

	google.golang.org/protobuf/internal/encoding/text
		decode_string.go#L45: 		str:   strings.Join(ss, ""),

	google.golang.org/protobuf/internal/impl
		legacy_enum.go#L218: 	return pref.FullName(strings.Join(ss, "."))

	gopkg.in/yaml.v2
		yaml.go#L275: 	return fmt.Sprintf("yaml: unmarshal errors:\n  %s", strings.Join(e.Errors, "\n  "))

	net/http
		client.go#L788: 				ireqhdr.Set("Cookie", strings.Join(ss, "; "))
		fs.go#L58: 		fi, err := os.Stat(strings.Join(parts[:i+1], string(filepath.Separator)))
		h2_bundle.go#L5630: 		rp.header.Set("Cookie", strings.Join(cookies, "; "))
		h2_bundle.go#L7485: 		return strings.Join(keys, ","), nil
		transfer.go#L320: 			if _, err := io.WriteString(w, "Trailer: "+strings.Join(keys, ",")+"\r\n"); err != nil {

	net/http/httputil
		dump.go#L259: 		fmt.Fprintf(&b, "Transfer-Encoding: %s\r\n", strings.Join(req.TransferEncoding, ","))
		reverseproxy.go#L281: 			clientIP = strings.Join(prior, ", ") + ", " + clientIP
		reverseproxy.go#L323: 		rw.Header().Add("Trailer", strings.Join(trailerKeys, ", "))

	os/exec
		exec.go#L205: 		return strings.Join(c.Args, " ")

	path/filepath
		path_unix.go#L45: 			return Clean(strings.Join(elem[i:], string(Separator)))

	runtime/pprof
		label.go#L54: 	return "{" + strings.Join(keyVals, ", ") + "}"

	testing
		example.go#L55: 	return strings.Join(lines, "\n")

	vendor/golang.org/x/net/idna
		idna10.0.0.go#L526: 		return strings.Join(l.slice, ".")