快捷键不能过多，一个 ide 就有许多快捷键，再加上浏览器，终端等等，快捷键如此之多，而且快捷键与功能之间并没有关系，也就是说，你只能靠大量练习形成肌肉记忆，这并不是一个高效的学习方式。
一般来说，对于一个应用来说，记忆 20，30 个都是很多的了，最主要的不是把快捷键记住，而是你要知道你在干什么，你要干什么。
比如我曾经无数次搜索 Goland 的快捷键表，可是最后记忆的还是那么几个，几乎没有增加，像什么 alt+shift，实现接口的 ctrl+i ，我看见过许多次，可是我仍然无法记住。
现在看来，这种方式就是错误的，不应该去“记忆”，而是要先理解它是什么意义，然后在用的时候会想到有这么一个功能，然后再去用。
自然我们会时常忘记对应的快捷键是什么，但这其实反而并不是太大的问题。为了解决这个问题，我们有两个方法。一就是写 cheat-list，要用的时候直接查，而就是使用搜索功能，直接搜索对应的快捷键。而在 Goland 中，搜索功能就是特殊的几个快捷键，如搜索 action, file, type 等。
这里扩展一下 i3 桌面，也是这么个道理，把多余的画面去掉，即可以强迫我们使用键盘，也能强迫我们使用搜索功能。无鼠标编程显然效率是灰常高的，当然也比时常要移动手去使用鼠标要舒适，还有 b 格加成。然后同时使用搜索功能也有几个好处。一是强化功能的印象，搜索时，其名字往往代表其功能，故在搜索时能表明知道自己在做什么，也能强化有这个功能的印象，许多功能并不是只有这个工具才有，这种强化思维也能迁移，会提高有意识提高效率的意识，会主动去寻找提高效率的方式，同时迁移工具时也会考虑这些。最后就是熟悉一下单词，比如我现在已经能熟练拼写 settings, plugins, keymap, background等等。。这能加大我们接触英语的可能性，因为这是我们主动的，而不是被动的。
自由度过高，大幅度的修改快捷键有一些坏处，如难以迁移，从迁移环境时比较麻烦，别人难以使用，有时会有牵一发而动全身的效果，改一个快捷键可能会造成后续大量的快捷键冲突，自定义的不符合人体工程学，上手成本过高等等。我曾经在 Goland 中使用 vim 插件，给 action 自定义了大量的快捷键，而且不同模式移动光标方法也不同，我使用的键盘也是可编程键盘，然后折腾了许久，最后对这一套我自己也不熟悉，编程效率直线下贱，而代码却未敲几行，甚至我还尝试过不同的键盘布局，最后我想到有时会使用其他环境而放弃了。总之，一切皆有度。
上 下 左 右
Ctrl+左/右 移动到上/下一个单词
home/end 移动到行首/尾
page up/down 向上/下翻页
Ctrl+home/end 移动到文件首/尾处
Ctlr+m 屏幕滑动到光标所在处，即屏幕以光标为中心
Ctrl+上/下 屏幕滑动但光标不动
跳转到定义
ctrl+B
屏幕跳转到任意字符
插件： acejump-lite
alt+m 后输入字符
ctrl+shfit 返回刚打开的 tab
Ctrl+e 查看最近编辑的文件
enter 新建下一行并移动到下一行, 改变此行
ctrl+enter 拆分此行，鼠标不动，在行尾使用，可新建下一行并鼠标不动
shift+enter 新建下一行并移动到下一行（不改变此行)
ctrl+alt+enter 新建上一行并到上一行
Ctrl+Shift+A 查找 action
Ctrl+N fing type
Ctrl+Shift+N 查找 file
Ctrl+Alt+Shift+N 查找 func
Ctrl+3 移动到下一个 error
Ctrl+2 移动到上一个 error
Ctrl+[ 跳转到函数大括号开始
Ctrl+] 跳转到函数大括号结束
这三个设置为一个快捷键比较方便，我使用的是硬件编程，也可是试试 vim 插件，我还没有找到其他方法能够这样设置
Ctrl+Alt+L 格式化代码
Ctrl+Alt+O 优化导入的类和包
Ctrl+S save
Ctrl+/ 行注释
Ctrl+shift+/ 快注释
Alt+1 打开侧边栏
Shift+F6 rename 所有的文件，类名，函数名，属性名都可以重命名，使用 Shift+F6 重命名，所有使用过这个名称的地方都会跟着改变
Ctrl+1 显示 error
Ctrl+p 显示参数 parameter info
Ctrl+Q show documentation, 用来显示返回值比较方便
Ctrl+R run
Ctrl+b 到变量声明处
Ctrl+w extend w
Ctrl+shift+y translate
Ctrl+shift+o show translation log
Ctrl+k git add and commit
Ctrk+shift+k git push
Ctrl+shift+space 智能提示
Ctrl+shift+f find in path
Ctrl+shift+r replace in path
Alt+j 选中相同的变量
Ctrl+shift+c 复制当前的文件的路径
Ctrl+d 重复当前行或选中文本
Ctrl+x 剪切当前行
Ctrl+c 双击复制当前行
Ctrl+y 删除当前行
此 action name 是 show context actions
这个键的作用可以在 Settings>Editor>Intensions>go 中查看
最常用的几个就是 struct 相关和调用函数以及add comment了
使用 struct 时，补全 其所有 fileds，只限于第一层，若 fileds 有 struct ，则不 fill 子 struct, 在 使用的 struct 里使用即可
Before
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Person{}
After
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Persona{
Name: "",
Location: Address{},
}
使用 struct 时，补全 其所有 fileds，只限于第一层，若 fileds 有 struct ，则递归的 fill 所有 struct, 在 使用的 struct 里使用即可
Before
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Person{}
After
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Persona{
Name: "",
Location: Address{
Street: "",
City: "",
},
}
使用 struct， 选择一个 filed 补全， 在使用的 struct 里使用即可
Before
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Person{}
After
type Address struct { Street string; City string }
type Person struct { Name string; Location Address }
_ = Persona{
Name: "",
}
给 struct 生成 new 方法，在 struct 的声明处使用
Before
type Person struct {
name string
age int
}
After
type Person struct {
name string
age int
}
func NewPerson(name string, age int) *Person {
return &Person{name: name, age: age}
}
给 struct filed 生成 getter 方法，在 struct 声明处，对着要生成的特定 file 即可
Before
type Person struct {
name string
}
After
type Person struct {
name string
}
func (p *Person) Name() string {
return p.name
}
给 struct filed 生成 setter 方法，在 struct 声明处，对着要生成的特定 file 即可
Before
type Person struct {
name string
}
After
type Person struct {
name string
}
func (p *Person) SetName(name string) {
p.name = name
}
给 struct filed 生成 getter 和 setter 方法，在 struct 声明处，对着要生成的特定 file 即可
Before
type Person struct {
name string
}
After
type Person struct {
name string
}
func (p *Person) Name() string {
return p.name
}
func (p *Person) SetName(name string) {
p.name = name
}
给结构体实现某接口，接口可以是自定义的，也可以是已有的。也就是给结构体生成接口含有的所有方法。这个功能有快捷键 Ctrl+i, 对着结构体的声明处使用即可
Before
package main
type A struct {}
type B interface {
a1() int
a2() int
a3() int
}
After
package main
type A struct {}
func (*A) a1() int {
panic("implement me")
}
func (*A) a2() int {
panic("implement me")
}
func (*A) a3() int {
panic("implement me")
}
type B interface {
a1() int
a2() int
a3() int
}
使用了一个 struct, 然后又写了一个赋值语句，这个命令是把两个语句合成一个语句，在 初始化语句里使用即可
Before
s := S{}
s.foo = `bar`
After
s := S{foo: `bar`}
使用 struct 时，把 filed name 去掉，在使用 struct 时使用
Before
var _ = struct{int; string; slice []int}{string : "a", int : 2}
After
var _ = struct{int; string; slice []int}{2, "a", nil}
调用函数时，迅速生成赋值返回值变量，对着调用的函数名使用
Before
func Add(a int, b int) int {
return a + b
}
func main() {
Add(1, 2)
}
After
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
add, err := Add(1, 2)
}
调用函数后，把没有使用的赋值变量变为 _ , 对着没有使用的变量使用即可
Before
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a, err := Add(1, 2)
}
After
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
_, err := Add(1, 2)
}
调用函数时，若有多个返回值，而赋值的变量没有返回值多，那么对着变量使用后，会自动补全返回值个数
Before
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a := Add(1, 2)
}
After
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a, _ := Add(1, 2)
}
调用函数时，若赋值的变量没有声明，那么对其使用就会直接声明后赋值
Before
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a = Add(1, 2)
}
AAfter
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a := Add(1, 2)
}
函数 return 返回值时，若个数不够，那么在 return 使用会自动增加返回值
Before
func Add(a int, b int) (int, error) {
return a + b
}
After
func Add(a int, b int) (int, error) {
return a + b, nil
}
函数 return 返回值时，若个数不够, 或者调用函数时，赋值的变量比返回值少，使用后会把返回值减少到对应个数
Before
func Add(a int, b int) (int, error) {
return a + b, nil
}
func main() {
a := Add(1, 2)
}
After
func Add(a int, b int) int {
return a + b
}
func main() {
a := Add(1, 2)
}
或者
Before
func Add(a int, b int) (int, error) {
return a + b
}
After
func Add(a int, b int) int {
return a + b
}
给单个变量声明时添加括号，在变量声明处使用
Before
var a string
After
var (
a string
)
这里说一下 import 时的情况，在 goland 中，只 import 了一个package，要加括号的话在 import 后直接打 ( 即可，goland 会自动把其放入括号中
与 Add parens to delartion 相反，去除括号
Before
var (
a string
)
After
var a string
给连续三个以上的变量声明划分为一组，空格隔开的不算，对着变量使用即可
Before
var a string
var b int
var c float32
var d bool
var e int
After
var a string
var (
b int
c float32
d bool
)
var e int
与 Merge all declaration 相反，会把括号里的变量分开声明
Before
var (
a string
b int
c int
)
After
var a string
var b int
var c int
把这个变量和上一个声明的变量放在一个括号中，空格不影响
Before
var a string
var b int
After
var (
a string
b int
)
把这个变量和上一个声明的变量放在一行，空格不影响
Before
var a int
var b int
After
var a, b int
于 merge declaration up via comma 相反，把一行声明的变量变为多行声明
Before
var a, b int
After
var a int
var b int
把 var 变量的声明格式变为更短的 := 格式，在 var 变量声明处使用
Before
var x = 1
After
x := 1
与 convert to short var declaration 相反，把 := 声明的变量变为 var 声明的格式，在 := 变量声明处使用
Before
x := 1
After
var x = 1
在声明函数的地方，对着函数名可以生成此函数的注释
Before
package foo
func Foo() {
}
After
package foo
// Foo
func Foo() {
}
在支持格式化的函数的参数里， 即 ("") 的引号中使用。选择一个变量后，会自动生成相应的格式化输出。
如 int 类型 a, 输入 a 后会自动生成 %d, 而无需记忆对应的意义。
Before
func log(count int) {
fmt.Printf(`count is: `)
}
After
func log(count int) {
fmt.Printf(`count is: %d`, count)
}
在参数和返回值时，转换类型的写法, 在参数或返回值括号内使用即可
Before
func foo(s1, s2 string) (i1, i2 int) {
return 0, 1
}
After
func foo(s1 string, s2 string) (i1 int, i2 int) {
return 0, 1
}
与上面的 Expand signature types 相反
Before
func bar(s1 string, s2 string) (i1 int, i2 int) {
return 0, 1
}
After
func bar(s1, s2 string) (i1, i2 int) {
return 0, 1
}
把私有 func, type, filed 变为公有的，在 func或 type 或 sturct 里的 filed 里使用即可
Before
func private() {}
After
func Private() {}
把 if- else 语句反过来，在 操作符 处使用即可
Before
a := 1
if a >= 2 {
fmt.Println("a >= 2")
} else {
fmt.Println("a < 2")
}
After
a := 1
if a < 2 {
fmt.Println("a < 2")
} else {
fmt.Println("a >= 2")
}
在 import 后添加想要拉的包 path, 任何使用这个 action, 可以直接拉包，类似 go get。
在导的包前或使用的包名中使用，可以直接用包里的函数
Before
package main
import "fmt"
func main() {
fmt.Println("Hello World!")
}
After
package main
import . "fmt"
func main() {
Println("Hello World!")
}
和 Add dot import alias 相反，取消其效果，导的包前或使用的包名中使用
Before
package main
import . "fmt"
func main() {
Println("Hello World!")
}
After
package main
import "fmt"
func main() {
fmt.Println("Hello World!")
}
这个同样在导的包前或使用的包名中使用，可以给包设置别名
Before
package main
import "fmt"
func main() {
fmt.Println("Hello World!")
}
After
package main
import fmtAlias "fmt"
func main() {
fmtAlias.Println("Hello World!")
}
这几个都是不常用的（至少我没怎么用到)
此 action name 是 go to test
这个键一共有 4 个功能
这个是最常用的，在函数内使用即可。
这个功能是生成函数测试。
go 中的测试文件需要在原有文件名后加上 _test, 测试函数需要在函数名前加上 Test ,参数也是特殊的。
如果手动生成的话比较麻烦且容易忘记，于是可以使用此快捷键。
如：
Before
db.go 中
func Hello {
fmt.Println("Hello World")
}
After
生成 db_test.go 文件
其中
func TestHello(t *testing.T) {
//...
}
生成此 files 内的所有函数的 test
生成此 package 内的所有函数的 test
生成空 test file, 里面没有 TestFunc
有时候要把莫东西加到括号中，可以先加上左括号，然后对着此行使用，会自动补全右括号并移动到下一行
Before
func main() {
fmt.Println ("Hello World!"
}
After
func main() {
fmt.Println("Hello Wrold!")
}
有时候大括号多了，会不小心删除右括号，这时候使用会自动生成右括号
Before
func main(){
fmt.Println("hello World!")
After
func main() {
fmt.Println("hello world!")
}
原文：https://www.cnblogs.com/just-save/p/12993705.html