Between, before, after

We take substrings with slice syntax. And we search strings with strings.Index. When we want to get substrings based on adjacent values, we combine these tasks.

We introduce between(), before and after funcs. To search from the end of a string with we use the strings.LastIndex func.

Input and output

Imagine that we want to parse a simple language that declares named variables. With between and after, we can quickly get the variable name.

Input = "DEFINE:A=TWO"

Between("DEFINE:", "=TWO") = "A"

Example program

Here we introduce the three methods. The first argument is the string are we searching—this is the same argument style that strings.Index uses.

Result Consider the main func. We declare a string literal that looks like some sort of data format.

And We isolate parts of the string based on its surround parts. So we can parse a string like this without any custom string code.

package main

import (
    "fmt"
    "strings"
)

func between(value string, a string, b string) string {
    // Get substring between two strings.
    posFirst := strings.Index(value, a)
    if posFirst == -1 {
        return ""
    }
    posLast := strings.Index(value, b)
    if posLast == -1 {
        return ""
    }
    posFirstAdjusted := posFirst + len(a)
    if posFirstAdjusted >= posLast {
        return ""
    }
    return value[posFirstAdjusted:posLast]
}

func before(value string, a string) string {
    // Get substring before a string.
    pos := strings.Index(value, a)
    if pos == -1 {
        return ""
    }
    return value[0:pos]
}

func after(value string, a string) string {
    // Get substring after a string.
    pos := strings.LastIndex(value, a)
    if pos == -1 {
        return ""
    }
    adjustedPos := pos + len(a)
    if adjustedPos >= len(value) {
        return ""
    }
    return value[adjustedPos:len(value)]
}

func main() {
    // Example string to parse.
    test := "DEFINE:A=TWO"

    // Test between func.
    fmt.Println(between(test, "DEFINE:", "="))
    fmt.Println(between(test, ":", "="))

    // Test before func.
    fmt.Println(before(test, ":"))
    fmt.Println(before(test, "="))

    // Test after func.
    fmt.Println(after(test, ":"))
    fmt.Println(after(test, "DEFINE:"))
    fmt.Println(after(test, "="))
}A
A
DEFINE
DEFINE:A
A=TWO
A=TWO
TWO

Performance notes

In a parser, these methods might be slower than desired. Excess string searching can occur. They can be used as a starting point, and optimizations can be added later.

In Go we can implement this kind of method in the same way as many other languages. This code is almost a line-by-line translation of a Python program. It works well in Go.