Cookbooks
Go
Chapter 2. Strings
Capitalizing a string

Go:
Capitalizing a string

How to:

In Go, the strings package does not provide a direct function to capitalize only the first letter of a string. Hence, we combine the strings.ToUpper() function, which converts a string to uppercase, with slicing to achieve our goal. Here’s how to do it:

package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func CapitalizeFirst(str string) string {
    if str == "" {
        return ""
    }
    // Check if the first character is already uppercase.
    if utf8.ValidString(str) && unicode.IsUpper([]rune(str)[0]) {
        return str
    }
    
    // Convert the first character to uppercase
    r, size := utf8.DecodeRuneInString(str)
    return string(unicode.ToUpper(r)) + str[size:]
}

func main() {
    example := "hello, World!"
    fmt.Println(CapitalizeFirst(example)) // Output: "Hello, World!"
}

This function checks if the string is empty or if the first character is already uppercase. It uses the unicode/utf8 package to correctly handle Unicode characters, ensuring our function works with a wide range of input beyond basic ASCII.

Deep Dive

The need to capitalize strings in Go without a built-in function could seem like a limitation, especially for programmers coming from languages where string manipulation functions are more comprehensive. This constraint encourages understanding string handling and the importance of Unicode in modern software development.

Historically, programming languages have evolved in their treatment of strings, with early languages often overlooking internationalization. Go’s approach, while requiring a bit more code for seemingly simple tasks, ensures developers are mindful of global users from the start.

There are libraries outside the standard library, like golang.org/x/text, offering more sophisticated text manipulation capabilities. However, using these should be weighed against adding external dependencies to your project. For many applications, the standard library’s strings and unicode/utf8 packages provide sufficient tools for effective and efficient string manipulation, as shown in our example. This keeps Go programs lean and maintainable, echoing the language’s philosophy of simplicity and clarity.

Concatenating strings