Hello, fellow Gophers! Today, we are about to embark on an exciting journey into the world of Go, exploring the creation of custom array/slice methods. Coming from a JavaScript or Python background, you might miss methods like push, pop, shift, unshift, or contains. Well, fear not! In this post, we will create these methods in Go from scratch.

Let’s get this clear from the start: Go, unlike many languages, doesn’t provide built-in functions for these operations. But that’s where the charm of Go lies – in crafting solutions using its existing data structures and robust syntax. Let’s dive in!

Creating Custom Methods

Custom Push Method

First, let’s start with implementing the push method. In essence, a push operation involves adding a new element at the end of an array or slice. Go’s in-built append function is tailor-made for this operation. Here is a simple demonstration of how to create push method:

package main

import "fmt"

func push(slice []int, element int) []int {
    return append(slice, element)
}

func main() {
    nums := []int{1, 2, 3}
    nums = push(nums, 4)
    fmt.Println(nums) // Output: [1 2 3 4]
}

Go Playground

In the above code, we defined a function push that accepts a slice and an element, and returns a new slice with the added element. It’s as simple and straightforward as it gets!

Custom Pop Method

Next, let’s implement the pop method. Pop is about removing the last element from the array or slice. Unfortunately, Go doesn’t provide a built-in function for this, but we can manipulate slices to achieve this:

package main

import "fmt"

func pop(slice []int) ([]int, int) {
    if len(slice) == 0 {
        return slice, 0 // Edge case: empty slice
    }
    return slice[:len(slice)-1], slice[len(slice)-1]
}

func main() {
    nums := []int{1, 2, 3, 4}
    nums, last := pop(nums)
    fmt.Println(nums) // Output: [1 2 3]
    fmt.Println(last) // Output: 4
}

Go Playground

In the pop function, we return two values – the updated slice after removing the last element and the element that was removed. We achieve this by using slice indexing and the len function to adjust the slice boundaries also In the pop function, we’ve handled the edge case of an empty slice to prevent a runtime panic.

Custom Shift Method

The shift operation, in essence, is about removing the first element from the slice. This method is common in languages like JavaScript but is absent in Go. However, thanks to Go’s flexible slicing capabilities, implementing ‘shift’ is pretty straightforward:

package main

import "fmt"

func shift(slice []int) ([]int, int) {
    if len(slice) == 0 {
        return slice, 0 // Edge case: empty slice
    }
    return slice[1:], slice[0]
}

func main() {
    nums := []int{1, 2, 3, 4}
    nums, first := shift(nums)
    fmt.Println(nums)  // Output: [2 3 4]
    fmt.Println(first) // Output: 1
}

Go Playground

In the shift function, we return the slice excluding the first element and the removed element. We achieve this by adjusting the slice boundaries. For shift, we have included a check for an empty slice to avoid a runtime panic as well.

Custom Unshift Method

The unshift operation involves adding a new element at the start of the slice. Go doesn’t have a built-in function for this operation as well. Nonetheless, we can still use the append function in a creative way:

package main

import "fmt"

func unshift(slice []int, element int) []int {
    return append([]int{element}, slice...)
}

func main() {
    nums := []int{2, 3, 4}
    nums = unshift(nums, 1)
    fmt.Println(nums) // Output: [1 2 3 4]
}

Go Playground

In the unshift function, we created a new slice with the new element and then append the old slice to it using the ... spread operator.

Custom Contains Method

It’s often useful to check if a slice contains a certain element. Many languages have a ‘contains’ or ‘includes’ method for this, but Go does not. However, we can implement this operation with a simple loop:

package main

import "fmt"

func contains(slice []int, element int) bool {
    for _, item := range slice {
        if item == element {
            return true
        }
    }
    return false
}

func main() {
    nums := []int{1, 2, 3, 4}
    fmt.Println(contains(nums, 3)) // Output: true
    fmt.Println(contains(nums, 5)) // Output: false
}

Go Playground

The contains function loops over the slice and returns true if it finds the element, and false otherwise.

Enhancing for Performance and Complex Data Types

While our custom methods are robust against edge cases, we can further enhance their performance and support complex data types. For example, to optimize our contains function, we could leverage a map for constant-time lookups. For handling complex data types, we can use Go’s interfaces and reflect package to make our methods more flexible.

But for the sake of brevity, we’ll leave those enhancements for a future post. So if you don’t wanna miss the enhanced version of this article then subscribe our newsletter to get articles direct to your mail box.

Conclusion

And there you have it – we’ve created our own push, pop, shift, unshift, and contains methods in Go! Despite the lack of these methods in Go’s standard library, the language’s powerful features allow us to build them ourselves.

This exploration underscores a key aspect of Go: the language encourages problem-solving and offers the flexibility to create custom solutions. While our custom methods are a good start, I encourage you to keep exploring and refining to suit your specific needs.

Remember, every step you take in Go is a step towards mastering this powerful language. So keep going, and until next time, happy coding!