strings.Split() / Join() / Replace()

import "strings"

// Splits a string by the separator.
parts := strings.Split(s, sep)

// Splits into at most n substrings (n=-1 means no limit).
parts := strings.SplitN(s, sep, n)

// Joins a slice of strings with the separator.
joined := strings.Join(parts, sep)

// Replaces the first n occurrences of old with new (n=-1 replaces all).
result := strings.Replace(s, old, new, n)

// Replaces all occurrences (equivalent to strings.Replace(s, old, new, -1)).
result := strings.ReplaceAll(s, old, new)

sample_strings_split_join_replace.go

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Split: splits a string by a delimiter.
    csv := "Ayanami Rei,Ikari Shinji,Soryu Asuka,Katsuragi Misato"
    names := strings.Split(csv, ",")
    fmt.Println("Split:", names)
    fmt.Printf("Count: %d\n", len(names))

    // SplitN: splits into at most N substrings.
    parts := strings.SplitN(csv, ",", 2) // split into at most 2 parts
    fmt.Println("SplitN(2):", parts) // ["Ayanami Rei" "Ikari Shinji,Soryu Asuka,Katsuragi Misato"]

    fmt.Println()

    // Fields: splits on whitespace.
    text := "  Go  Language  Programming  "
    words := strings.Fields(text) // leading, trailing, and consecutive spaces are ignored.
    fmt.Println("Fields:", words)
    fmt.Printf("Word count: %d\n", len(words))

    fmt.Println()

    // Join: joins a slice into a single string.
    langs := []string{"Go", "Python", "Rust"}
    joined := strings.Join(langs, " / ")
    fmt.Println("Join:", joined)

    fmt.Println()

    // Replace: replaces substrings.
    s := "NERV NERV NERV"
    fmt.Println("Replace(1):", strings.Replace(s, "NERV", "SEELE", 1))
    fmt.Println("Replace(-1):", strings.Replace(s, "NERV", "SEELE", -1))
    fmt.Println("ReplaceAll:", strings.ReplaceAll(s, "NERV", "GEHIRN"))

    fmt.Println()

    // Practical example: simple CSV parsing.
    csvLine := "1,Nagisa Kaworu,Tokyo,15"
    fields := strings.Split(csvLine, ",")
    fmt.Printf("ID=%s Name=%s City=%s Age=%s\n", fields[0], fields[1], fields[2], fields[3])

    // Path construction (efficiently joined with strings.Builder).
    pathParts := []string{"home", "user", "documents", "file.txt"}
    path := "/" + strings.Join(pathParts, "/")
    fmt.Println("Path:", path)
}

This produces the following output:

go run strings_split_join_replace.go
Split: [Ayanami Rei Ikari Shinji Soryu Asuka Katsuragi Misato]
Count: 4
SplitN(2): [Ayanami Rei Ikari Shinji,Soryu Asuka,Katsuragi Misato]

Fields: [Go Language Programming]
Word count: 3

Join: Go / Python / Rust

Replace(1): SEELE NERV NERV
Replace(-1): SEELE SEELE SEELE
ReplaceAll: GEHIRN GEHIRN GEHIRN

ID=1 Name=Nagisa Kaworu City=Tokyo Age=15
Path: /home/user/documents/file.txt

strings.Split() splits a string by a delimiter, and strings.Join() does the reverse. This pair is a fundamental pattern in text processing. When you need to perform multiple replacements efficiently, strings.NewReplacer() is a faster alternative.

Calling strings.Split(s, "") splits the string byte by byte. To split a UTF-8 string (such as Japanese text) into individual characters, use a for-range loop over runes or convert the string to []rune(s).

For searching strings, see strings.Contains(). For case conversion and trimming, see strings.ToUpper() / ToLower() / TrimSpace().