Golang语法与代码格式速记【转】
// Description: Golang语法与代码格式速记
// Author: cxy
// Date: 2013-04-01
// Version: 0.3
// TODO 说明 // TODO package // Go是采用语法解析器自动在每行末尾增加分号,所以在写代码的时候可以把分号省略。
// Go编程中只有几个地方需要手工增加分号,如: for循环使用分号把初始化,条件和遍历元素分开。在一行中有多条语句时,需要增加分号。
// 不能把控制语句(if, for, switch, or select)、函数、方法 的左大括号单独放在一行, 如果你这样作了语法解析器会在大括号之前插入一个分号,导致编译错误。 // 引用包名与导入路径的最后一个目录一致
import "fmt"
import "math/rand"
fmt.Println(rand.Intn(10)) // 0到10之间的非负伪随机数 // 用圆括号组合导入包,这是“factored”导入语句
import ("fmt"; "math")
import (
"fmt"
"math"
)
// 导入包可以定义别名,防止同名称的包冲突
import n "net/http"
import (
控制台 "fmt"
m "math"
)
控制台.Println(m.Pi) // 首字母大写的名称是被导出的, 首字母小写的名称只能在同一包内访问(同包跨文件也能访问)
var In int // In is public
var in byte // in is private
var 看不见 string // 看不见 is private
const Com bool = false // Com is public
const 还是看不见 uint8 = 1 // 还是看不见 is private
type Integer int // Integer is public
type ブーリアン *bool // ブーリアン is private
func Export() {} // Export is public
func 导入() {} // 导入 is private
func (me *Integer) valueOf(s string) int {} // valueOf is private
func (i ブーリアン) String() string {} // String is public // Go 的基本类型:
┌──────┬─────────┬────────┬─────────┬───────────┬────────────┐
│ bool │ string │ │ │ │ │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ int │ int8 │ int16 │ int32 │ int64 │ │
│ │ │ │ rune │ │ │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ uint │ uint8 │ uint16 │ uint32 │ uint64 │ uintptr │
│ │ byte │ │ │ │ │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ │ │ │ float32 │ float64 │ │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ │ │ │ │ complex64 │ complex128 │
└──────┴─────────┴────────┴─────────┴───────────┴────────────┘
// byte 是 uint8 的别名
// rune 是 int32 的别名,代表一个Unicode码点 // 变量声明, 使用var关键字 (Go中只能使用var声明变量,无需显式初始化值)
var i int // i = 0
var s string // s = "" (Go中的string不存在nil(null)值,默认零值就是空串 "" 或 ``)
var e error // e = nil, error是Go的内建接口类型,不是基本类型。 // var 语句声明了一个变量的列表,类型在变量名之后
var a,b,c int // a = 0, b = 0, c = 0
var (
a int // a = 0
b string // b = ""
c uint // c = 0
) // 变量定义时初始化赋值,每个变量对应一个值
var a int = 0
var a,b int = 0, 1 // 初始化使用表达式时,可以省略类型,变量从初始值中获得类型
var a = 'A' // a int32
c := 1 + 2i // c complex128
var a,b = 0, "B" // a int, b string
a, b := 0, "B" // a int, b string
c := `formatted
string` // c string // := 结构不能使用在函数外,函数外的每个语法块都必须以关键字开始 // 常量可以是字符、字符串、布尔或数字类型的值,数值常量是高精度的值
const x int = 3
const (
a byte = 'A'
b string = "B"
c bool = true
d int = 4
e float32 = 5.1
f complex64 = 6 + 6i
) // 未指定类型的常量由常量值决定其类型
const a = 0 // a int
const (
b = 2.3 // b float64
c = true // c bool
) // 自动枚举常量 iota
// iota的枚举值可以赋值给数值兼容类型
// 每个常量单独声明时, iota不会自动递增(无意义)
const a int = iota // a = 0
const b int = iota // b = 0
const c byte = iota // c = 0
const d uint64 = iota // d = 0 // 常量组合声明时, iota每次引用会逐步自增, 初始值为0,步进值为1
const (
a uint8 = iota // a = 0
b int16 = iota // b = 1
c rune = iota // c = 2
d float64 = iota // d = 3
e uintptr = iota // e = 4
) // 枚举的常量都为同一类型时, 可以使用简单序列格式.
const (
a = iota // a int32 = 0
b // b int32 = 1
c // c int32 = 2
) // 枚举序列中的未指定类型的常量会跟随序列前面最后一次出现类型定义的类型
const (
a byte = iota // a uint8 = 0
b // b uint8 = 1
c // c uint8 = 2
d rune = iota // d int32 = 3
e // e int32 = 4
f // f int32 = 5
) // iota自增值只在一个常量定义组合中有效,跳出常量组合定义后iota值归0
const (
a = iota // a int32 = 0
b // b int32 = 1
c // c int32 = 2
)
const (
e = iota // e int32 = 0 (iota重新初始化并自增)
f // f int32 = 1
) // 定制iota序列初始值与步进值 (通过数学公式实现)
const (
a = (iota + 2) * 3 // a int32 = 0 (a=(0+2)*3) 初始值为6,步进值为3
b // b int32 = 3 (b=(1+2)*3)
c // c int32 = 6 (c=(2+2)*3)
d // d int32 = 9 (d=(3+2)*3)
) // 数组声明带有长度信息,数组的长度固定
var a [3]int = [3]int{0, 1, 2} // a = [0 1 2]
var b [3]int = [3]int{} // b = [0 0 0]
var c = [3]int{} // c = [0 0 0]
d := [3]int{} // d = [0 0 0]
fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d)) // [3]int [3]int{0, 0, 0} 3 3
// 使用自动计算数组初始数据的长度
var a = []int{0, 1, 2}
x := [][3]int{{0, 1, 2}, {3, 4, 5}} // slice 指向数组的值,并且同时包含了长度信息
var a []int
fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(a), cap(a)) // []int []int(nil) 0 0
var a = new([]int)
fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(*a), cap(*a)) // *[]int &[]int(nil) 0 0
var b = make([]int, 0)
fmt.Printf("%T\t%#v\t%d\t%d\n", b, b, len(b), cap(b)) // []int []int{} 0 0
var c = make([]int, 3, 10)
fmt.Printf("%T\t%#v\t%d\t%d\n", c, c, len(c), cap(c)) // []int []int{} 3 10
var d []int = []int{0, 1, 2}
fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d)) // []int []int{0, 1, 2} 3 3 // slice 可以重新切片,创建一个新的 slice 值指向相同的数组
s := []int{0, 1, 2, 3, 4}
fmt.Println(s[1,3]) // [1 2] (截取从开始索引到结束索引-1 之间的片段)
fmt.Println(s[:4]) // [0 1 2 3]
fmt.Println(s[1:]) // [1 2 3 4]
fmt.Println(s[1:1]) // [] // 向slice中添加元素
s := make([]string, 3)
s = append(s, "a") // map 在使用之前必须用 make 来创建(不是 new);一个值为 nil 的 map 是空的,并且不能赋值
var m map[int]int
m[0] = 0 // × runtime error: assignment to entry in nil map
fmt.Printf("type: %T\n", m) // map[int]int
fmt.Printf("value: %#v\n", m) // map[int]int(nil)
fmt.Printf("value: %v\n", m) // map[]
fmt.Println("is nil: ", nil == m) // true
fmt.Println("length: ", len(m)) // 0,if m is nil, len(m) is zero. var m map[int]int = make(map[int]int)
m[0] = 0 // 插入或修改元素
fmt.Printf("type: %T\n", m) // map[int]int
fmt.Printf("value: %#v\n", m) // map[int]int(0:0)
fmt.Printf("value: %v\n", m) // map[0:0]
fmt.Println("is nil: ", nil == m) // false
fmt.Println("length: ", len(m)) // 1 m = map[int]int{
0:0,
1:1, // 最后的逗号是必须的
}
m = map[string]S{
"a":S{0,1},
"b":{2,3}, // 类型名称可省略
}
a := m["a"] // 取值
a, ok := m["a"] // 取值, 并通过ok(bool)判断key对应的元素是否存在.
delete(m, "a") // 删除key对应的元素. // 结构体(struct)就是一个字段的集合, type 定义跟其字面意思相符
type S struct {
A int
B, c string
}
type (
A struct {
s *S
}
B struct {
A // 组合
}
)
// 结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。
var s S = S{0, "1", "2"}
// 使用 Name: 语法可以仅列出部分字段。(字段名的顺序无关。)
var s S = S{A: 0, B: "1"}
var s S = S{}
// 特殊的前缀 & 构造了指向结构体文法的指针。
var s *S = &S{0, "1", "2"} // 表达式 new(T) 分配了一个零初始化的 T 值,并返回指向它的指针
var s *S = new(S)
// 有指针,但是没有指针运算,结构体字段使用点号来访问
// 结构体字段可以通过结构体指针来访问。通过指针间接的访问是透明的
fmt.Println(s.A)
fmt.Println((*s).A) // TODO interface
type IF interface {
a()
} // TODO chanel // TODO error // if 语句 小括号 ( )是可选的,而 { } 是必须的。
if (i < 0) // 编译错误.
println(i) if i < 0 // 编译错误.
println(i) if (i < 0) { // 编译通过.
println(i)
}
if i < 0 {
println(i)
} else {
println(i)
} // 可以在条件之前执行一个简单的语句,由这个语句定义的变量的作用域仅在 if/else 范围之内
if (i := 0; i < 1) { // 编译错误.
println(i)
} if i := 0; (i < 1) { // 编译通过.
println(i)
} if i := 0; i < 0 { // 使用gofmt格式化代码会自动移除代码中不必要的小括号( )
println(i)
} else if i == 0 {
println(i)
} else {
println(i)
} // if语句作用域范围内定义的变量会覆盖外部同名变量,(与方法函数内局部变量覆盖全局变量相同)
a, b := 0, 1
if a, b := 3, 4; a > 1 && b > 2 {
println(a, b) // 3 4
}
println(a, b) // 0 1 // 只有一种循环结构,for 循环。可以让前置、后置语句为空,或者全为空
for i := 0; i < 10; i++ {}
for i := 0; i < 10; {}
for ; i < 10; i++ {}
for ; i < 10; {}
for i < 10 {}
for ; ; {}
for {} // 小括号 ( )是可选的,而 { } 是必须的。
for (i := 0; i < 10; i++) {} // 编译错误.
for i := 0; (i < 10); i++ {} // 编译通过.
for (i < 10) {} // 编译通过. // TODO continue // TODO for range // TODO switch
// TODO fallthrough break
// TODO type assertion // TODO select // TODO goto // 函数可以没有参数或接受多个参数
func f() {}
func f(a int) {}
func f(a int, b byte) {}
func f(a int) {} // 可变参数
func f(a int, b bool, c string) {}
// 函数可以返回任意数量的返回值
func f() int {
return 0
}
func f() int, string {
return 0, "A"
}
// 函数返回结果参数,可以像变量那样命名和使用
func f() a int, b string {
a = 1
b = "B"
return // 或者 return a, b
} // 当两个或多个连续的函数命名参数是同一类型,则除了最后一个类型之外,其他都可以省略
func f(a,b,c int) {}
func f() a,b,c int {}
func f(a,b,c int) x,y,z int {} // 函数也是值,可以将函数赋值给变量
var f (func(i int) int) = func(i int) int {
return i
}
fmt.Println(f(3)) // 3
var f func() int = func() int {
return 0
}
fmt.Println(f()) // 0
var f func() = func() {}
var f = func() {}
f := func() {} // TODO defer // TODO 方法 // TODO 内建函数
append
cap
close
complex
copy
delete
imag
len
make
new
panic
println
real
recover // TODO 并发
go func() {}
Golang语法与代码格式速记【转】的更多相关文章
- css中代码格式以及@import的语法结构
CSS中代码格式 CSS是Cascading Style Sheets(层叠样式表)的缩写.是一种对web文档添加样式的简单机制,属于表现层的布局语言. 1.基本语法规范分析一个典型CSS的语句: p ...
- golang语法笔记
开始微服务,那就先温习下golang语法吧; golang变量类型 1. 整形 Go %b 表示为二进制 %c 该值对应的unicode码值 %d 表示为十进制 %o 表示为八 ...
- Golang 语法学习笔记
Golang 语法学习笔记 包.变量和函数. 包 每个 Go 程序都是由包组成的. 程序运行的入口是包 main. 包名与导入路径的最后一个目录一致."math/rand" 包由 ...
- golang语法学习(一):变量,常量以及数据类型
学习一门新的语言肯定是要从他的主要的语法開始,语法构成了整个程序设计的基础,从语法中我们也能够看到这门语言的一些特性.可是话说回来.语法这东西,不同的语言大同小异,所以这也对语法的记忆造成了一定的难度 ...
- 浅谈Kotlin(二):基本类型、基本语法、代码风格
浅谈Kotlin(一):简介及Android Studio中配置 浅谈Kotlin(二):基本类型.基本语法.代码风格 浅谈Kotlin(三):类 浅谈Kotlin(四):控制流 通过上面的文章,在A ...
- Word文档中的语法高亮显示代码
有时候我们程序员也需要在word文档里面显示代码,但是直接复制过去 不好看,格式也不太对,这里给大家分享一个Word文档中的语法高亮显示代码的方法 http://www.planetb.ca/synt ...
- 《阿里巴巴Java开发手册》代码格式部分应用——idea中checkstyle的使用教程
<阿里巴巴Java开发手册>代码格式部分应用--idea中checkstyle的使用教程 1.<阿里巴巴Java开发手册> 这是阿里巴巴工程师送给各位软件工程师的宝典,就像开车 ...
- python 代码格式
python 代码格式 Python对代码的缩进要求非常严格,如果不采用合理的代码缩进,将抛出SyntaxError异常 Python语句中一般以新行作为为语句的结束符.但是我们可以使用斜杠( )将一 ...
- 轻量级jQuery语法高亮代码高亮插件jQuery Litelighter。
<!DOCTYPE html><html><head><meta charset="UTF-8" /><title>jQ ...
随机推荐
- Android开发之Toast
第一次在博客园发布文章,就把我刚弄明白的关于Android开发中的提示设置,分享给大家. Toast是Android中经常用到的一个方法,用于简单的用户提示,经过摸索我发现了Toast的两种使用方式, ...
- EntityFramework 7 更名为EntityFramework Core(预发布状态)
前言 最近很少去学习和探索新的东西,尤其是之前一直比较关注的EF领域,本身不太懒,但是苦于环境比较影响自身的心情,所以迟迟没有下笔,但是不去学习感觉在精神层面缺少点什么,同时也有园友说EF又更新了,要 ...
- iOS开发之遍历Model类的属性并完善使用Runtime给Model类赋值
在上篇博客<iOS开发之使用Runtime给Model类赋值>中介绍了如何使用运行时在实体类的基类中添加给实体类的属性赋值的方法,这个方法的前提是字典的Key必须和实体类的Property ...
- Windows 使用 Yeoman generators 创建 ASP.NET 应用程序
上一篇:<Windows 搭建 .NET 跨平台环境并运行应用程序> 阅读目录: Install Node.js Install yeoman-generators Create ASP. ...
- [ES] 基础概念
Elasticsearch是基于Luence实现的一款搜索引擎,支持分布式和集群,并且搜索近实时,主要用于搜索和数据分析 索引 index 可以理解为数据库中的database,存储的是实际数据,因为 ...
- c#和Javascript中去重总结
一.前言 去重在我们的开发过程中经常遇到,避免重复元素的添加,我们需要对获取到的集合(包括List.Array等) 做相关的过滤操作.确保对象的唯一性,从而达到保证数据不冗余重复.由于自己是做.net ...
- 【原创】轻量级移动端即时通讯技术 MobileIMSDK 发布了
申明:MobileIMSDK目前为个人原创开源工程,投入了大量的时间和精力,希望对需要的人有所帮助.如需与作者交流,见文章底部个人签名处,互相学习.Q群:215891622,欢迎共同志趣者学习和交流. ...
- 一步一步开发Game服务器(二)登陆2
上一篇文章,讲解了简单的登陆情况.接下来我们继续讲解登陆模块. 在正常的游戏服务器情况下.在尚未登录前可以查看服务器大区情况,登陆后也可以查看服务器大区情况,然后选择大区服务器.进行登录操作. 这样的 ...
- C#开发微信门户及应用(44)--微信H5页面开发的经验总结
在我们开发微信页面的时候,需要大量用到了各种呈现的效果,一般可以使用Boostrap的效果来设计不同的页面,不过微信团队也提供很多这方面的资源,包括JSSDK的接口,以及Weui的页面样式和相关功能页 ...
- RabbitMQ框架学写笔记-20161201
1.RabbitMQ NUget .Net客户端4.1.1版本 对应的 .netframework版本是 4.5.1 以及以上 2.本地实现的效果图 3.实践代码: P-生产者: using Rabb ...