Go 是一种类 C 语言，大部分语法和 C 类似。

一、第一个 go 程序，Hello world。

package main

import "fmt" // 实现格式化的 I/O

/* Print something */
func main() {
    fmt.Printf("Hello, world\n")
}
1
2
3
4
5
6
7
8
在不引起语义混淆的情况下，Go 可以省略句末的分号，编译器会在每句末尾自动加上分号；并且强制要求左花括号位于句末，另起一行会出现编译错误。
首行这个是必须的。所有的 Go 文件以 package <something> 开头，对于独立运行的执行文件必须是 package main；
将 fmt 包（函数库）导入到 main，可以使用小括号导入多个包，如
import (
    "fmt"
    "io"
)
1
2
3
4
在 Go 中， package 总是首先出现，然后是 import，接着是其他所有内容。当 Go 程序在执行的时候，首先调用的函数是 main()，这是从 C 中继承而来。
Go 的注释可以用 C 风格注释 /* */ 和 C++ 风格注释 / /。
二、变量、数据类型

1、变量

Go 声明变量时类型放在变量名之后 var varname vartype。其中 var 为声明变量的保留字。Go 编译器会对未初始化的变量自动赋值其类型的 0 。

/* 先声明，后初始化 */
var a int // 声明 int 类型变量
var b bool // 声明 bool 类型变量
a = 10 // 赋值
b = true

/* 声明变量并初始化 */
var c int = 12

/* 声明并赋值的简写形式，变量类型是根据值推断出来的，但是只能用在函数内部 */
d := 8
1
2
3
4
5
6
7
8
9
10
11
多个 var 的声明可以成组（使用圆括号），const 和 import 同样可以如此做。相同类型的多个变量可以放在同一行，也可以使用平行赋值。一个特殊的变量名 _ 表示赋给它的值都将被丢弃。
/* 成组声明变量 */
var (
    ia int
    bb bool
)

/* 相同类型变量同行声明 */
var ic, id int
var ic, id int = 1, 2 // 声明并初始化

/* 平行赋值 */
ie, bg := 3, true // ie = 3, bg = true
_, bg := 3, true // 3被丢弃
1
2
3
4
5
6
7
8
9
10
11
12
13
注意：Go 编译器对声明但未使用的变量会报错。

2、类型

bool 类型

值为 true 和 false。
数字类型

整型

有符号整数：int int8 int16 int32 int64
无符号整数：uint uint8(byte) uint16 uint32 uint64

byte 是 uint8 的别名，rune 是 int32 的别名。

赋值可以用八进制、十六进制或科学计数法： 077， 0xFF， 1e3 或者 6.022e23 这些都是合法的。
注意：int 类型是和系统相关的，在 32位操作系统上是32位，64为操作系统上时64位。其他类型都和系统类型无关。

注意：不同的数据类型之间不能混用，否则会出现编译出错。Go 的数据类型不支持隐式转换，必须显示转换。

var a int = 2
var b int32
b = a + a // 错误，int 不能隐式转换为 int32
b = b + 5 // 可以
1
2
3
4
浮点型

float32 float64

常量

常量（const）是在编译时被创建。只能是数字，字符串和布尔型。可以使用 itoa 生成枚举值，第一次使用时值为 0，再一次在新行使用时值加 1。

const x = 4 // 声明常量     
/* 成组声明 */
const (
    x1 = 4
    y1 = true
)
/* itoa生成枚举值 */     
const (
    a = iota // a = 0
    b = iota // b = 1
    c        // c = 2 可以省略重复的 itoa，其值自动加 1
)
1
2
3
4
5
6
7
8
9
10
11
12
字符串

字符串在 Go 中是 UTF-8 的由双引号（”“）包裹的字符序列。如果你使用单引号（”）则表示一个字符（ UTF-8编码）——这种在 Go 中不是 string。

注意：一旦给变量赋值，字符串就不能修改了：在 Go 中字符串是不可变的。

var s string = "hello"
s[0] = 'c'  // 报错

/* 先转换在修改 */
s := "hello"
c := [] byte(s) 0.
c[0] = 'c' 1.
s2 := string(c) 2.
fmt.Printf("%s\n", s2)
1
2
3
4
5
6
7
8
9
多行字符串连接需要将 “+” 放在当前行尾部，不要放在下一行开头，否则编译器会误解加入分号导致错误。另一种方式是使用反引号 ` 作为原始字符串符号，但是此时引号中的转义字符不会被转义。

s := "Starting part"
    + "Ending part"
// 会被转换为：
s := "Starting part" ;
    + "Ending part" ;
// 这是错误的语法，应当这样写：
s := "Starting part" +
    "Ending part"
// 使用反引号 ` 作为原始字符串符号，但转义字符不被解释
s := `Starting part // s 中含有换行符
    Ending part`
1
2
3
4
5
6
7
8
9
10
11
rune

Rune 是 int32 的别名。用 UTF-8 进行编码。一般用在需要遍历字符串中的字符。可以循环每个字节（仅在使用 US ASCII 编码字符串时与字符等价，而它们在 Go 中不存在！）。因此为了获得实际的字符，需要使用 rune 类型。

复数

Go 原生支持复数。默认变量类型是 complex128 （ 64 位虚数部分）。还有 complex64（32 位的虚数部分）。复数写为 re + im i， re 是实数部分，im 是虚数部分，而 i 是标记 ‘i’ ( √− 1)。

var c complex64 = 5+5i;
fmt.Printf("Value is: %v", c)
1
2
将会打印： (5+5i)。

注意：对于简写形式复数声明赋值如 v := a + bi，b 必须存在，否则出现 i 无定义。

错误

Go 有为了错误而存在的内建类型，叫做 error。
---------------------
【转载】仅作分享，侵删
作者：abc123man
原文：https://blog.csdn.net/abc123man/article/details/47183671

奈斯