How to filter elements of a [][]string slice in Golang?

First of all i'm new here and i'm trying to learn Golang. I would like to check my csv file (which has 3 values; type, maker, model) and create a new one and after a filter operation i want to write new data(filtered) to the created csv file. Here is my code so you can understand me more clearly.

package main

import (
	"encoding/csv"
	"fmt"
	"os"
)

func main() {
	//openning my csv file which is vehicles.csv
	recordFile, err := os.Open("vehicles.csv")
	if err != nil{
		fmt.Println("An error encountered ::", err)
	}
	//reading it
	reader := csv.NewReader(recordFile)
	vehicles, _ := reader.ReadAll()
	//creating a new csv file
	newRecordFile, err := os.Create("newCsvFile.csv")
	if err != nil{
		fmt.Println("An error encountered ::", err)
	}
	//writing vehicles.csv into the new csv
	writer := csv.NewWriter(newRecordFile)
	err = writer.WriteAll(vehicles)
	if err != nil {
		fmt.Println("An error encountered ::", err)
	}
}

After i build it, it is working this way. It reads and writes the all data to new created csv file. But the problem here is, i want to filter duplicates of readed csv which is vehicles, i am creating another function (outside of the main function) to filter duplicates but i can't do it because vehicles 's type is [][]string, i searched the internet about filtering duplicates but all i found is int or string types. What i want to do is create a function and call it before WriteAll operation so WriteAll can write the correct (duplicates filtered) data into new csv file. Help me please!!
I appreciate any answer.
Happy coding!

This depends on how you define "uniqueness", but in general there are a few parts of this problem.

What is unique?

1. All fields must be equal
2. Only some fields must be equal
3. Normalize some or all fields before comparing

You have a few approaches for applying your uniqueness, including:

1. You can use a map, keyed by the "pieces" of uniqueness, requires O(N) state
2. You can sort the records and compare with the prior record as you iterate, requires O(1) state but is more complicated

You have two approaches for filtering and outputting:

1. You can build a new slice based on the old one using a loop and write all at once, this requires O(N) space
2. You can write the records out to the file as you go if you don't need to sort, this requires O(1) space

I think a reasonably simple and performant approach would be to pick (1) from the first, (1) from the second, and (2) from the third, which together would look like:

package main

import (
	"encoding/csv"
	"errors"
	"io"
	"log"
	"os"
)

func main() {
	input, err := os.Open("vehicles.csv")
	if err != nil {
		log.Fatalf("opening input file: %s", err)
	}

	output, err := os.Create("vehicles_filtered.csv")
	if err != nil {
		log.Fatalf("creating output file: %s", err)
	}
	defer func() {
		// Ensure the file is closed at the end of the program
		if err := output.Close(); err != nil {
			log.Fatalf("finalizing output file: %s", err)
		}
	}()

	reader := csv.NewReader(input)
	writer := csv.NewWriter(output)

	seen := make(map[[3]string]bool)
	for {
		// Read in one record
		record, err := reader.Read()
		if errors.Is(err, io.EOF) {
			break
		}
		if err != nil {
			log.Fatalf("reading record: %s", err)
		}
		if len(record) != 3 {
			log.Printf("bad record %q", record)
			continue
		}

		// Check if the record has been seen before, skipping if so
		key := [3]string{record[0], record[1], record[2]}
		if seen[key] {
			continue
		}
		seen[key] = true

		// Write the record
		if err := writer.Write(record); err != nil {
			log.Fatalf("writing record %d: %s", len(seen), err)
		}
	}
}