How to efficiently concatenate string array and string in golang

I have a bunch of strings and []strings in golang which I need to concatenate. But for some reason I am getting a lot of whitespaces along the way which I need to get rid of.

Here's the code

    tests := strings.TrimSpace(s[0])
    dep_string := make ([]string, len(tests) + len(sfinal))
    dep_string = append (dep_string,tests)
    for _,v := range sfinal {
      dep_string = append(dep_string,v)
    }
    fmt.Println("dep_String is ",dep_string)
    

Input: 
s[0] = "filename"
sfinal = [test test1]

expected output
[filename test test1]

actual output
[     filename test test1]

It's really weird; even after using TrimSpace I am not able to get rid of excess space. Is there any efficient way to concatenate them?

The whitespace is due to all of the empty elements in dep_string. When you use the make function, it creates a slice with the specified length and capacity, filled with a bunch of nothing. Then, when you use append, it sees that the slice has reached its maximum capacity, extends the slice, then adds your elements, after all of the nothing. The solution is to make a slice with the capacity to hold all of your elements, but with initial length zero:

dep_string := make ([]string, 0, len(tests) + len(sfinal))

strings.TrimSpace is unnecessary. You can read more at http://blog.golang.org/slices

Bill DeRose and Saposhiente are correct about how slices work.

As for a simpler way of solving your problem, you could also do (play):

fmt.Println("join is",strings.Join(append(s[:1],sfinal...)," "))

When you do the assignment dep_string := make ([]string, len(tests) + len(sfinal)), Go zeros out the allocated memory so dep_string then has len(tests) + len(sfinal) empty strings at the front of it. As it's written now you append to the end of the slice, after all those zeroed out strings.

Run this to see where those blanks are showing up in your code. You can fix it by making a slice of length 0 and capacity len(tests) + len(sfinal) instead. You can then concatenate them by using strings.Join.

Here's a simple and efficient solution to your problem.

package main

import "fmt"

func main() {
	s := make([]string, 1, 4)
	s[0] = "filename"
	sfinal := []string{"test", "test1"}
	dep_string := append(s[:1], sfinal...)
	fmt.Println("dep_String is ", dep_string)
}

Output:

dep_String is  [filename test test1]

When you do the assignment dep_string := make ([]string, len(tests) + len(sfinal)), it allocate len(tests) + len(sfinal) null strings ,it is 10 null strings in your case,so when you do the assignment fmt.Println("dep_String is ",dep_string) ,it will print 10 null strings, because fmt.Println(slice of string) will add blank between two elements,so it will print 9 blanks ,so it will prints [ filename test test1] after you append, the whitespaces is the blanks between the 10 null string.