How to Remove Duplicate Values from Slice in Golang?

In Golang, a slice is a dynamically-sized array that can store a collection of elements of the same type. Sometimes, you may need to remove duplicate values from a slice to ensure that each element in the slice is unique. In this article, we'll discuss how to remove duplicate values from a slice in Golang.

Method 1: Using a Map

One way to remove duplicate values from a slice in Golang is to use a map. Maps are a built-in type in Golang that allow you to store key-value pairs. We can use a map to keep track of the unique elements in the slice and then create a new slice from those elements.

Example

Here's an example of how to use a map to remove duplicate values from a slice −

package main

import "fmt"

func removeDuplicates(slice []int) []int {
   // Create a map to store unique elements
   seen := make(map[int]bool)
   result := []int{}
   
   // Loop through the slice, adding elements to the map if they haven't been seen before
   for _, val := range slice {
      if _, ok := seen[val]; !ok {
         seen[val] = true
         result = append(result, val)
      }
   }  
   return result
}

func main() {
   // Example usage
   nums := []int{1, 2, 2, 3, 4, 4, 5}
   unique := removeDuplicates(nums)
   fmt.Println(unique) // Output: [1 2 3 4 5]
}

Output

[1 2 3 4 5]

In this example, we create a new map called "seen" to store unique elements. We then loop through the input slice and add elements to the map if they haven't been seen before. If an element has been seen before, we skip it. Finally, we return a new slice that contains only the unique elements.

Here's how you can use this function to remove duplicates from a slice −

input := []int{1, 2, 2, 3, 3, 3, 4, 5, 5}
output := removeDuplicates(input)
fmt.Println(output) // Output: [1 2 3 4 5]

Method 2: Using a Nested Loop

Another way to remove duplicate values from a slice in Golang is to use a nested loop. This method is less efficient than using a map, but it's simpler to understand and implement.

Example

Here's an example of how to use a nested loop to remove duplicate values from a slice −

package main

import "fmt"

func removeDuplicates(slice []int) []int {
   result := []int{}

   // Loop through the slice and add unique elements to the result slice
   for i := 0; i < len(slice); i++ {
      // Check if the element has already been added to the result slice
      duplicate := false
      for j := 0; j < len(result); j++ {
         if slice[i] == result[j] {
            duplicate = true
            break
         }
      }
      // Add the element to the result slice if it's not a duplicate
      if !duplicate {
         result = append(result, slice[i])
      }
   }
   return result
}

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

Output

[1 2 3 4]

In this example, we loop through the input slice and check if each element has already been added to the result slice. If an element is not a duplicate, we add it to the result slice. Finally, we return the result slice.

Here's how you can use this function to remove duplicates from a slice −

input := []int{1, 2, 2, 3, 3, 3, 4, 5, 5}
output := removeDuplicates(input)
fmt.Println(output) // Output: [1 2 3 4 5]

Conclusion

In this article, we discussed two different methods for removing duplicate values from a slice in Golang. The first method uses a map to store unique elements, while the second method uses a nested loop to compare each element to all previous elements in the slice. While the map-based method is more efficient, the nested loop method is simpler to understand and implement.

Regardless of which method you choose, removing duplicates from a slice can be a useful operation in many different applications. With the techniques we've covered here, you should be able to easily remove duplicates from any slice in your Golang code.

Keep in mind that these methods assume that the input slice is not too large. If the input slice is very large, you may need to consider using a more efficient algorithm or data structure to remove duplicates. Additionally, if the input slice contains elements of a non-primitive type, you will need to define your own equality function to check for duplicates.