Golang strings.HasPrefix Function

The strings.HasPrefix function in Go is used to check whether a given string starts with a specified prefix. This function is part of the strings package and is particularly useful when you need to validate if a string begins with a particular substring, such as a URL scheme, file path, or other common patterns.

Syntax

func HasPrefix(s, prefix string) bool

Parameters:

• s: The string to check.
• prefix: The prefix to look for at the start of the string.

Returns:

• bool: Returns true if the string s starts with the prefix prefix, otherwise returns false.

Example Usage

Basic Example

This example demonstrates how to use strings.HasPrefix to check if a string starts with a specific prefix.

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "Hello, world!"
	prefix := "Hello"

	if strings.HasPrefix(str, prefix) {
		fmt.Printf("The string \"%s\" starts with \"%s\".\n", str, prefix)
	} else {
		fmt.Printf("The string \"%s\" does not start with \"%s\".\n", str, prefix)
	}
}

Output:

The string "Hello, world!" starts with "Hello".

Explanation:

• The strings.HasPrefix function checks whether the string "Hello, world!" starts with the prefix "Hello".
• Since the string begins with the specified prefix, the function returns true, and the output confirms this.

Case Sensitivity

The strings.HasPrefix function is case-sensitive. This means that if the case of the prefix does not exactly match the start of the string, the function will return false.

Example

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "Hello, World!"
	prefix := "hello"

	if strings.HasPrefix(str, prefix) {
		fmt.Printf("The string \"%s\" starts with \"%s\".\n", str, prefix)
	} else {
		fmt.Printf("The string \"%s\" does not start with \"%s\".\n", str, prefix)
	}
}

Output:

The string "Hello, World!" does not start with "hello".

Explanation:

• The strings.HasPrefix function is case-sensitive, so it returns false when checking if "Hello, World!" starts with "hello" (lowercase "h").
• The output confirms that the string does not start with the specified prefix due to the case mismatch.

Working with URL Schemes

A common use case for strings.HasPrefix is checking for specific URL schemes, such as http:// or https://, when validating or processing URLs.

Example

package main

import (
	"fmt"
	"strings"
)

func main() {
	url := "https://example.com"
	prefix := "https://"

	if strings.HasPrefix(url, prefix) {
		fmt.Printf("The URL \"%s\" uses the secure HTTPS protocol.\n", url)
	} else {
		fmt.Printf("The URL \"%s\" does not use the secure HTTPS protocol.\n", url)
	}
}

Output:

The URL "https://example.com" uses the secure HTTPS protocol.

Explanation:

• The strings.HasPrefix function checks whether the URL "https://example.com" starts with the prefix "https://" to determine if it uses the HTTPS protocol.
• Since the URL starts with the specified prefix, the function returns true, and the output confirms this.

Real-World Use Case: File Path Validation

Suppose you need to validate whether certain file paths start with a specific directory. You can use strings.HasPrefix to perform this validation.

Example: File Path Validation

package main

import (
	"fmt"
	"strings"
)

func validateFilePath(path, prefix string) bool {
	return strings.HasPrefix(path, prefix)
}

func main() {
	filePath := "/home/user/documents/file.txt"
	expectedPrefix := "/home/user/"

	if validateFilePath(filePath, expectedPrefix) {
		fmt.Printf("The file path \"%s\" is valid and starts with \"%s\".\n", filePath, expectedPrefix)
	} else {
		fmt.Printf("The file path \"%s\" is invalid and does not start with \"%s\".\n", filePath, expectedPrefix)
	}
}

Output:

The file path "/home/user/documents/file.txt" is valid and starts with "/home/user/".

Explanation:

• The validateFilePath function uses strings.HasPrefix to check whether the given file path starts with the expected directory prefix "/home/user/".
• The file path validation confirms that the path starts with the specified prefix.

Conclusion

The strings.HasPrefix function in Go is used for checking whether a string starts with a specified prefix. This function is particularly useful in scenarios such as validating URL schemes, file paths, or other string patterns that should begin with a specific substring. By leveraging strings.HasPrefix, you can easily determine if a string conforms to a particular pattern, making it an essential function in the Go string manipulation toolkit.