When it comes to comparing strings in Go, you’re right that using the `==` operator is the way to check if two strings are identical. For checking if one string is a substring of another, the `strings` package is super handy! Mainly, you can use the `strings.Contains` function for this purpose.

Here’s a quick example:

import "strings"

func main() {
    str1 := "Hello, world!"
    str2 := "world"

    // Check if str1 is equal to str2
    if str1 == str2 {
        // Do something if they're identical
    }
    
    // Check if str2 is a substring of str1
    if strings.Contains(str1, str2) {
        // Do something if str2 is found within str1
    }
}
    

If you want to know the position of the substring, you could use `strings.Index`, which will give you the index of the first occurrence of the substring or -1 if it’s not found:

index := strings.Index(str1, str2)
if index != -1 {
    // The substring was found, and index tells you where
}
    

As for performance concerns, when dealing with large strings or doing this in loops, it can be helpful to keep in mind that some string operations might be more costly. However, Go’s `strings` package is pretty optimized. Just avoid unnecessary operations or large-scale conversions when possible.

In my own projects, I often wrap these comparisons in functions to keep my main code clean. You can create helper functions that take care of these substring checks so that your main logic stays focused. Here’s a small example:

func CheckSubstring(mainStr, subStr string) bool {
    return strings.Contains(mainStr, subStr)
}
    

This makes it easy to call from different parts of your code without repeating yourself!

Lastly, don’t hesitate to check out the Go documentation for the `strings` package. It has some pretty useful info and examples that can help you avoid headaches in string manipulation.