func strings.Split

174 uses

	strings (current package)
		strings.go#L299: func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }

	cloud.google.com/go/compute/metadata
		metadata.go#L349: 	s := strings.Split(strings.TrimSpace(j), "\n")

	cloud.google.com/go/storage
		storage.go#L417: 		headerMatches := strings.Split(sanitizedHeader, ":")
		storage.go#L529: 		nameValue := strings.Split(header, ":")
		storage.go#L540: 	segments := strings.Split(path, "/")
		storage.go#L671: 		parts := strings.Split(h, ":")

	contrib.go.opencensus.io/exporter/stackdriver
		metrics_batcher.go#L160: 			for _, rng := range strings.Split(submatches[i], ",") {
		metrics_batcher.go#L161: 				rngSlice := strings.Split(rng, "-")

	crypto/tls
		common.go#L1038: 			labels := strings.Split(name, ".")

	crypto/x509
		verify.go#L927: 	for i, part := range strings.Split(host, ".") {
		verify.go#L990: 	patternParts := strings.Split(pattern, ".")
		verify.go#L991: 	hostParts := strings.Split(host, ".")

	encoding/xml
		typeinfo.go#L123: 	tokens := strings.Split(tag, ",")
		typeinfo.go#L199: 	parents := strings.Split(tag, ">")

	github.com/aws/aws-sdk-go/aws/awsutil
		path_value.go#L17: 	pathparts := strings.Split(path, "||")
		path_value.go#L29: 	components := strings.Split(path, ".")

	github.com/aws/aws-sdk-go/aws/signer/v4
		uri_path.go#L14: 		uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/")
		v4.go#L557: 		ps := strings.Split(auth, ", ")

	github.com/aws/aws-sdk-go/private/protocol
		host.go#L25: 	labels := strings.Split(host, ".")

	github.com/evanw/esbuild/internal/config
		globals.go#L916: 		parts := strings.Split(key, ".")

	github.com/evanw/esbuild/internal/js_parser
		js_parser.go#L12855: 	parts := strings.Split(span.Text, ".")

	github.com/evanw/esbuild/internal/resolver
		tsconfig_json.go#L181: 	parts := strings.Split(text, ".")

	github.com/evanw/esbuild/pkg/api
		api_impl.go#L368: 	parts := strings.Split(text, ".")
		api_impl.go#L389: 		for _, part := range strings.Split(key, ".") {
		api_impl.go#L459: 		for _, part := range strings.Split(key, ".") {

	github.com/go-git/gcfg
		set.go#L24: 	s := strings.Split(ts, ",")

	github.com/go-git/go-git/v5
		blame.go#L260: 	lines := strings.Split(contents, "\n")
		repository.go#L322: 	gitdir := strings.Split(line[len(prefix):], "\n")[0]
		repository.go#L833: 		branchName := strings.Split(string(branchRef), "refs/heads/")[1]
		worktree.go#L872: 	contentByLine := strings.Split(content, "\n")
		worktree_commit.go#L157: 	parts := strings.Split(e.Name, "/")

	github.com/go-git/go-git/v5/plumbing/format/gitignore
		dir.go#L33: 			for _, s := range strings.Split(string(data), eol) {
		pattern.go#L62: 	res.pattern = strings.Split(p, patternDirSep)

	github.com/go-git/go-git/v5/plumbing/object
		commit.go#L300: 		lines := strings.Split(signature, "\n")
		commit.go#L382: 	for _, line := range strings.Split(t, "\n") {
		file.go#L66: 	splits := strings.Split(content, "\n")
		tree.go#L133: 	pathParts := strings.Split(path, "/")

	github.com/go-git/go-git/v5/plumbing/protocol/packp
		advrefs.go#L185: 		chunks := strings.Split(symref, ":")

	github.com/go-git/go-git/v5/storage/filesystem/dotgit
		dotgit.go#L869: 		ws := strings.Split(line, " ") // hash then ref
		dotgit.go#L931: 	path = d.fs.Join(path, d.fs.Join(strings.Split(name, "/")...))
		dotgit.go#L1070: 			relpath := filepath.Join(strings.Split(slashPath, "/")[1:]...)

	github.com/go-git/go-git/v5/utils/merkletrie/index
		node.go#L31: 		parts := strings.Split(e.Name, string("/"))

	github.com/go-redis/redis/v8
		sentinel.go#L569: 				flags = strings.Split(key.(string), ",")
		sentinel.go#L655: 			parts := strings.Split(msg.Payload, " ")

	github.com/google/go-cmp/cmp
		report_reflect.go#L313: 	lines := strings.Split(strings.TrimSuffix(s, "\n"), "\n")
		report_slices.go#L125: 		ssx := strings.Split(sx, "\n")
		report_slices.go#L126: 		ssy := strings.Split(sy, "\n")

	github.com/google/licensecheck
		license.go#L225: 	for _, f := range strings.Split(s, "|") {

	github.com/google/licensecheck/old
		normalize.go#L133: 	for _, marker := range strings.Split(allListMarkers, " ") {

	github.com/jackc/pgconn
		config.go#L277: 	hosts := strings.Split(settings["host"], ",")
		config.go#L278: 	ports := strings.Split(settings["port"], ",")
		config.go#L402: 	for _, host := range strings.Split(url.Host, ",") {

	github.com/jackc/pgpassfile
		pgpass.go#L75: 	parts := strings.Split(line, ":")

	github.com/jackc/pgtype
		interval.go#L97: 	parts := strings.Split(string(src), " ")

	github.com/kevinburke/ssh_config
		parser.go#L112: 		strPatterns := strings.Split(val.val, " ")
		parser.go#L135: 		inc, err := NewInclude(strings.Split(val.val, " "), hasEquals, key.Position, comment, p.system, p.depth+1)

	github.com/lib/pq
		conn.go#L1346: 		parts := strings.Split(commandTag, " ")

	github.com/microcosm-cc/bluemonday
		sanitize.go#L568: 	rest := strings.Split(val, "data-")

	github.com/prometheus/client_golang/prometheus/promhttp
		http.go#L326: 	parts := strings.Split(a, ",")

	github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg
		autoneg.go#L87: 	parts := strings.Split(header, ",")
		autoneg.go#L96: 		mrp := strings.Split(part, ";")
		autoneg.go#L99: 		sp := strings.Split(media_range, "/")

	github.com/prometheus/common/model
		time.go#L125: 	p := strings.Split(string(b), ".")

	github.com/prometheus/procfs
		arp.go#L46: 	lines := strings.Split(string(data), "\n")
		crypto.go#L74: 		lines := strings.Split(string(block), "\n")
		crypto.go#L79: 			fields := strings.Split(line, ":")
		mdstat.go#L68: 	lines := strings.Split(string(mdStatData), "\n")
		mountinfo.go#L78: 	mountInfo := strings.Split(mountString, " ")
		mountinfo.go#L150: 	options := strings.Split(mountOptions, ",")
		mountinfo.go#L152: 		splitOption := strings.Split(opt, "=")
		mountstats.go#L348: 			for _, opt := range strings.Split(ss[1], ",") {
		mountstats.go#L349: 				split := strings.Split(opt, "=")
		net_sockstat.go#L85: 		fields := strings.Split(s.Text(), " ")
		net_softnet.go#L49: 	lines := strings.Split(string(data), "\n")
		proc.go#L134: 	return strings.Split(string(bytes.TrimRight(data, string("\x00"))), string(byte(0))), nil
		proc_environ.go#L31: 	environments = strings.Split(string(data), "\000")
		proc_psi.go#L75: 		prefix := strings.Split(l, " ")[0]
		proc_status.go#L85: 	lines := strings.Split(string(data), "\n")
		zoneinfo.go#L93: 		lines := strings.Split(string(block), "\n")
		zoneinfo.go#L180: 				protectionParts := strings.Split(line, ":")
		zoneinfo.go#L184: 				protectionStringMap := strings.Split(protectionValues, ", ")

	github.com/sergi/go-diff/diffmatchpatch
		diff.go#L1291: 	for _, token := range strings.Split(delta, "\t") {
		patch.go#L483: 	text := strings.Split(textline, "\n")

	go.opentelemetry.io/otel/api/correlation
		correlation_context_propagator.go#L71: 	contextValues := strings.Split(correlationContext, ",")
		correlation_context_propagator.go#L74: 		valueAndProps := strings.Split(contextValue, ";")
		correlation_context_propagator.go#L78: 		nameValue := strings.Split(valueAndProps[0], "=")

	go/ast
		ast.go#L135: 		cl := strings.Split(c, "\n")

	go/build
		build.go#L1623: 	for _, line := range strings.Split(text, "\n") {
		build.go#L1708: 	chunks := strings.Split(str, "${SRCDIR}")
		build.go#L1943: 	l := strings.Split(name, "_")

	go/printer
		printer.go#L658: 	lines := strings.Split(text, "\n")

	golang.org/x/crypto/ssh
		keys.go#L175: 		return marker, strings.Split(hosts, ","), pubKey, comment, rest, nil
		messages.go#L349: 	for _, tag := range strings.Split(tagStr, "|") {
		server.go#L304: 	for _, sourceAddr := range strings.Split(sourceAddrs, ",") {

	golang.org/x/crypto/ssh/knownhosts
		knownhosts.go#L251: 	for _, p := range strings.Split(pattern, ",") {
		knownhosts.go#L484: 	components := strings.Split(encoded, "|")

	golang.org/x/mod/modfile
		rule.go#L917: 		for _, line := range strings.Split(rationale, "\n") {

	golang.org/x/net/http2
		server.go#L2081: 		for _, key := range strings.Split(v, ",") {
		server.go#L2934: 	for _, f := range strings.Split(v, ",") {

	golang.org/x/net/idna
		idna10.0.0.go#L561: 		l.slice = strings.Split(l.orig, ".")

	golang.org/x/net/proxy
		per_host.go#L98: 	hosts := strings.Split(s, ",")

	golang.org/x/oauth2/google
		sdk.go#L108: 					Scopes:       strings.Split(d.Key.Scope, " "),

	golang.org/x/oauth2/jws
		jws.go#L119: 	s := strings.Split(payload, ".")
		jws.go#L168: 	parts := strings.Split(token, ".")

	golang.org/x/pkgsite/cmd/pkgsite
		main.go#L78: 	paths := strings.Split(pathList, ",")

	golang.org/x/pkgsite/devtools/cmd/css
		main.go#L155: 	parts := strings.Split(property, " ")

	golang.org/x/pkgsite/internal/config
		config.go#L595: 	for _, p := range strings.Split(s, ",") {

	golang.org/x/pkgsite/internal/fetch
		package.go#L252: 	for _, el := range strings.Split(importPath, "/") {

	golang.org/x/pkgsite/internal/frontend
		404.go#L142: 	parts := strings.Split(fullPath, "/")
		404.go#L146: 	m := strings.Split(fullPath, "/"+githubRegexp.FindString(fullPath))
		overview.go#L141: 		parts := strings.Split(destURL.Path, "/")
		section.go#L95: 	parts := strings.Split(path, "/")
		styleguide.go#L217: 	p := strings.Split(s, "-")
		urlinfo.go#L103: 		endParts := strings.Split(parts[1], "/")
		urlinfo.go#L172: 	parts := strings.Split(fullPath, "/")
		versions.go#L318: 	parts := strings.Split(v, "-")
		versions.go#L328: 	p := strings.Split(parts[1], ".")
		versions.go#L350: 			return strings.Split(v, "-")[2]

	golang.org/x/pkgsite/internal/godoc/dochtml/internal/render
		idents.go#L223: 	origIDs := strings.Split(word, ".")
		idents.go#L260: 				origIDs = strings.Split(word[:j], ".")
		render.go#L247: 	docLines := unindent(strings.Split(strings.Trim(doc, "\n"), "\n"))

	golang.org/x/pkgsite/internal/postgres
		licenses.go#L190: 	if len(strings.Split(i.FilePath, "/")) > len(strings.Split(j.FilePath, "/")) {
		search.go#L404: 	q = strings.Join(strings.Split(q, " "), " | ")
		search.go#L962: 	parts := strings.Split(packagePath, "/")
		search.go#L964: 		dashParts := strings.Split(part, "-")
		search.go#L981: 		dotParts := strings.Split(part, ".")
		search.go#L1007: 	for _, p := range strings.Split(path, "/") {
		searchdoc.go#L154: 	ws := strings.Split(s, "-")

	golang.org/x/pkgsite/internal/stdlib
		stdlib.go#L344: 	for _, d := range strings.Split(Directory(resolvedVersion), "/") {

	golang.org/x/pkgsite/internal/worker
		server.go#L355: 	parts := strings.Split(p, "/@v/")

	golang.org/x/text/cases
		map.go#L42: 	for _, s := range strings.Split(supported, " ") {

	golang.org/x/text/internal/language
		compose.go#L63: 		for _, vr := range strings.Split(variants[1:], "-") {

	golang.org/x/text/internal/language/compact
		compact.go#L56: 	tags := strings.Split(specialTagsStr, " ")
		language.go#L181: 		for _, v := range strings.Split(v, "-") {

	golang.org/x/text/language
		language.go#L385: 	return strings.Split(e.s, "-")

	google.golang.org/api/idtoken
		cache.go#L100: 	cc := strings.Split(headers.Get("cache-control"), ",")
		cache.go#L103: 			ss := strings.Split(v, "=")
		validate.go#L226: 	segments := strings.Split(idToken, ".")

	google.golang.org/api/internal/third_party/uritemplates
		uritemplates.go#L78: 	split := strings.Split(rawTemplate, "{")
		uritemplates.go#L88: 		subsplit := strings.Split(s, "}")
		uritemplates.go#L161: 	rawterms := strings.Split(expression, ",")
		uritemplates.go#L179: 	split := strings.Split(term, ":")

	google.golang.org/api/transport/grpc
		dial.go#L279: 	whitelist := strings.Split(os.Getenv("GOOGLE_CLOUD_ENABLE_DIRECT_PATH"), ",")

	google.golang.org/grpc/credentials/alts
		utils.go#L67: 			for _, line := range strings.Split(strings.TrimSuffix(string(out), "\n"), "\n") {

	google.golang.org/grpc/internal/binarylog
		env_config.go#L50: 	methods := strings.Split(s, ",")

	google.golang.org/protobuf/encoding/protojson
		well_known_types.go#L872: 	paths := strings.Split(str, ",")

	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"))

	google.golang.org/protobuf/internal/impl
		legacy_enum.go#L212: 	ss := append(strings.Split(prefix, "."), suffix)
		legacy_message.go#L188: 			for _, s := range strings.Split(tag, ",") {
		message.go#L168: 			for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
		message.go#L196: 		for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {

	gopkg.in/yaml.v2
		yaml.go#L339: 		fields := strings.Split(tag, ",")

	internal/goroot
		gc.go#L68: 	dirsEntries := strings.Split(string(allDirs), "\n")

	net/http
		cookie.go#L64: 		parts := strings.Split(textproto.TrimString(line), ";")
		fs.go#L53: 	parts := strings.Split(name, string(filepath.Separator))
		fs.go#L879: 	for _, ra := range strings.Split(s[len(b):], ",") {
		h2_bundle.go#L5636: 		for _, key := range strings.Split(v, ",") {
		h2_bundle.go#L6489: 	for _, f := range strings.Split(v, ",") {
		server.go#L1501: 	for _, f := range strings.Split(v, ",") {

	net/http/httputil
		reverseproxy.go#L390: 		for _, sf := range strings.Split(f, ",") {

	path/filepath
		path_unix.go#L34: 	return strings.Split(path, string(ListSeparator))

	runtime/debug
		mod.go#L83: 			elem := strings.Split(line[len(modLine):], "\t")
		mod.go#L90: 			elem := strings.Split(line[len(depLine):], "\t")
		mod.go#L98: 			elem := strings.Split(line[len(repLine):], "\t")

	testing
		example.go#L53: 	lines := strings.Split(output, "\n")
		match.go#L65: 	elem := strings.Split(name, "/")
		testing.go#L551: 	lines := strings.Split(s, "\n")
		testing.go#L1713: 	for _, val := range strings.Split(*cpuListStr, ",") {

	text/template
		option.go#L54: 	elems := strings.Split(opt, "=")

	text/template/parse
		node.go#L395: 	return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
		node.go#L500: 	return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period

	vendor/golang.org/x/net/http/httpproxy
		proxy.go#L216: 	for _, p := range strings.Split(c.NoProxy, ",") {

	vendor/golang.org/x/net/idna
		idna10.0.0.go#L560: 		l.slice = strings.Split(l.orig, ".")