I'm currently playing with Google Go.
There's a lot of ways to declare and/or initialize variables.
Can someone explains pros/cons of each way (samples, as far as i know, below) :
var strArr0 *[10]string = new([10]string)
var strArr1 = new([10]string)
var strArr2 = make([]string,10)
var strArr3 [10]string
strArr4 := make([]string,10)
What is your preferred syntax, and why ?
Thanks, SO folks !
分享 I've numbered your examples 1-5, and I'll walk through them here. Hope this helps!
var strArr0 *[10]string = new([10]string) // (1)
This allocates a new array of strings, of length 10, and returns a pointer to the array.
var strArr1 = new([10]string) // (2)
This is exactly the same as 1. It's just shorthand, that works due to Go's type inference. It could be shortened further to:
strArr1 := new([10]string) // (2a)
Where 1, 2, 2a all produce exactly the same result.
var strArr2 = make([]string,10) // (3)
This makes a slice of strings, with length 10. A slice refers to some subset of an underlying array. From the golang spec:
The make() call allocates a new, hidden array to which the returned slice value refers.
make([]T, length, capacity)produces the same slice as allocating an array and slicing it, so these two examples result in the same slice:
make([]int, 50, 100) new([100]int)[0:50]
So 3 is equivalent to any of the following:
var strArr2 = new([10]string)[0:10] // Slicing an explicitly created array
var strArr2 []string = new([10]string)[0:10] // Explicitly declaring the type of strArr2, rather than inferring
strArr2 := new([10]string)[0:10] // Using the := shorthand instead of var
new or make are used depending on what type you're creating. make is used solely for slices, maps and channels. They used a different keyword to convey the idea that make is initializing some data structure under the hood, rather than just zeroing memory.
The next one is back to arrays rather than slices:
var strArr3 [10]string // (4)
This is the same as 1, 2, and 2a.
strArr4 := make([]string,10) // (5)
Same as 3. := is just shorthand when initializing a variable and the type can be inferred.
So which to choose? This is up to your personal style a bit, but in general one choice is obviously going to maximise the clarity of your code e.g. using type inference when the type is obvious:
foo := bar.ToStringArray()
or declaring the types when it's less so and the type will be useful to see:
var foo []string = bar.DoSomethingOpaque()
On slices versus arrays, you'll usually create whatever type is required for some function you're calling.
分享
