[Question]
  [
What general tips do you have for golfing in Go? I'm new to Code Golfing and looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Go.
Please keep to one tip per answer.
  
[Answer]
Inspired by @EMBLEM's answer [here](https://codegolf.stackexchange.com/a/75569/53406).
You can put a package's functions in the global namespace when you import them like so:
```
package main
import ."fmt"
func main() {
    Printf("Hello World!")
}
```
[Answer]
Named return values can save a few bytes. For example:
```
func x()string{
r:="" //Do stuff
return r}
```
You can save 3 bytes with
```
func x()(r string){
//Do stuff
return}
```
It's more useful if you need to declare multiple variables at the start of your function.
[Answer]
You can name packages whatever you like when you import them.
```
package main
import f "fmt"
func main() {
    f.Printf("Hello World\n")
}
```
Learned this [here](https://stackoverflow.com/a/1727139/3161525).
[Answer]
If you need to compare many different values to a single one, it may be more space-efficient to use a `switch` with a single case.
```
if x==1||x==2||x==3||x==4{}
switch x{case 1,2,3,4:}
```
[Answer]
Go compiler has predefined `print` and `println` functions that don't require importing fmt, so instead of this.
```
package main
import."fmt"
func main(){Printf(`Hello World
`)}
```
You can write this.
```
package main
func main(){print(`Hello World
`)}
```
Note that this outputs to STDERR.
[Answer]
Go has different operator precedence for bit operations, `<<`, `>>`, `&`, etc. usually have lower precedence than `+` and `-` in most languages, but in Go they have the same precedence as `*` and `/`.
```
Precedence    Operator
5             *  /  %  <<  >>  &  &^
4             +  -  |  ^
3             ==  !=  <  <=  >  >=
2             &&
1             ||
```
This could be used to save some parentheses.
Most languages:
```
(a&b)*c
```
Go:
```
a&b*c
```
[Answer]
A lot of stuff in the for range loop is optional.
Standard version:
```
for i,v:=range a{
// Do stuff
}
```
If `i`, `v` has already been defined and can be overwritten:
```
for i,v=range a{
// Do stuff
}
```
If you don't care about value:
```
for i:=range a{
// Do stuff
}
```
If you don't care about value and `i` has already been defined:
```
for i=range a{
// Do stuff
}
```
If you don't care about index or value:
```
for range a{
// Do stuff
}
```
If you want an infinite loop:
```
for{
// Do stuff
}
```
[Answer]
Need a string to contain a newline? Don't write `\n`, create a raw string with backquotes and put a literal newline in it.
```
s:="\n" // 7 bytes
s:=`
` // 6 bytes
```
[Answer]
Declaring Multiple Variables:
```
i,s:=0,""
var(i int;s string)
```
Int From String Conversion: (limited but sometimes helpful)
```
n:=byte("9"[0])-48 // actual type is uint8
n,_:=strconv.Atoi("9")
```
And Vice Versa
```
s:=string(9+48)
s:=strconv.Itoa(9)
```
[Answer]
### When looping a constant `n` times, `for-range` is shorter up to `n <= 5`
If you need to loop a constant number of times, a `for range"..."{}` loop (where `...` is `n` characters) is shorter than a 3-part for loop up to `n <= 5` iterations.
The two loop forms are equivalent at `n == 5`:
```
for range`|||||`{}
for i:=0;i<5;i++{}
```
Past `n > 5`, use a 3-part loop.
[Answer]
You can put any number of opening braces on one line, but a line that contains opening braces may contain at most one closing brace.
Correct:
```
func main(){if true{switch{case 1==1:for{break
}}}}
```
Also correct:
```
func main(){if true{switch{case 1==1:for{break}
}}}
```
Also correct:
```
func main(){if true{switch{case 1==1:for{
break}}}}
```
Incorrect:
```
func main() {
    if true{for{break}}
}
```
[Answer]
Since [an allowable output format is writing to reference arguments](https://codegolf.meta.stackexchange.com/a/4942/88456), it may save bytes to pass a pointer instead of returning a value.
```
func f(a,b string)string{if g(a)>g(b){return a};return b}
func f(a,b string, s*string){s=&b;if g(a)>g(b){s=&a}}
```
[Answer]
If you're using a C-style 3-part for-loop, if your loop variable isn't dependent on something outside of its scope for its initialization, declare it with your other variable declarations to save a byte.
In these examples, `i` is initialized independently of `a`
```
func f(){a:=3;for i:=0;i<a;i++{}}
// vs
func f(){a,i:=3,0;for;i<a;i++{}}
```
[Answer]
When taking a single character substring from a string and want to keep it as a string, use string slices to not get a rune:
```
string(s[0]) // 12 bytes
s[:1]        // 4 bytes
string(s[10]) // 13 bytes
s[10:11]      // 8 bytes
string(s[100]) // 14 bytes
s[100:101]     // 10 bytes
string(s[1000]) // 15 bytes
s[1000:1001]    // 12 bytes
string(s[10000]) // 16 bytes
s[10000:10001]   // 14 bytes
```
This method is shorter than `string(s[index])` up to getting from index `100000` and above, but indexing strings of that size are rare.
[Answer]
Don't declare variables in the `for`'s init statement:
```
for i:=0;i<n;i++{...}
```
By declaring it outside you may save a byte when you need a variable outside of it beacause you can now assign to it (`=`) instead of declaring it (`:=`):
```
i:=0
for;i<n;i++{...}
i=0
for;i<n;i++{...}
```
You might even save a byte if you're not using the `for`'s post-statement by removing the semicolons
[Answer]
Make full use of Go's first-class functions by assigning long library function names to one-letter variables.
```
import."strings"
r:=Replace
```
[Answer]
# Shuffle elements with `rand.Perm`
I discovered `math/rand.Perm` the other day, which returns a slice of integers from 0 to `n`, shuffled.
### For strings
Given an input string `k`, and you need to return a string, and we have that string as a named return, `Perm` is shorter because you don't need to real with the boilerplate for `Shuffle` or the swapping:
```
Shuffle(len(k),func(i,j int){k[i],k[j]=k[j],k[i]}) // 48 bytes
for i:=range k{j:=Intn(i);k[i],k[j]=k[j],k[i]}     // 44 bytes, -4, no separate string needed
for i:=range Perm(len(k)){e+=k[i:i+1]}             // 36 bytes, -12
```
### For slices
Assuming the same conditions as above but with a slice, it is still shorter:
```
Shuffle(len(k),func(i,j int){k[i],k[j]=k[j],k[i]}) // 48 bytes
for i:=range k{j:=Intn(i);k[i],k[j]=k[j],k[i]}     // 44 bytes, -4, no separate slice needed
for i:=range Perm(len(k)){e=append(e,k[i])}        // 41 bytes, -7
```
[Answer]
## Use `min` and `max` to clamp values (Go 1.21+)
Say you have 2 comparables `l` and `h`, where you must satisfy `l <= h`. It is 1 byte shorter to use the builtins than an if-statement.
```
// assuming
l,h := n, 0
if h<l{h=l}
h=max(h,l)
if l>h{l=h}
l=min(h,l)
// and the opposite
l,h := 0, n
if h>l{h=l}
h=min(h,l)
if l<h{l=h}
l=max(h,l)
```
]