1.语法基础

1.例子

go 复制代码

//main函数 
package main

//使用fmt包  实现了IO函数
import "fmt"
//{不能单独放一行
func main() {
    //标识符以一个大写字母开头，可以被外部包的代码使用
    //小写开头，对包外不可见，protected修饰符
	fmt.Print("hello")
    //一行表示一个语句结束
    print("123")
}

如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。

2.字符串可以使用`+` 连接

3.变量声明

var age int

4.格式化字符串

go 复制代码

package main

import "fmt"

func main() {
	var age = 123
	var date = "12.1"
	var url = "Code=%d date=%s"
	var result = fmt.Sprintf(url, age, date)
	fmt.Print(result)
}

5.数据类型

1.bool var b bool = true

2.数字类型

int float32 float64 ,支持复数,位运算采用补码

uint8,16,32,64 无符号整型(后表示位)

int8,16,32,64

float32,64

complex64,128 复数

byte,rune(类似int32),uint(32/64),uintptr(存放指针)

go 1.9版本对于数字类型，无需定义int及float32、float64，系统会自动识别（有点像python）。

3.字符串类型

UTF-8 编码标识Unicode文本

4.派生类型: 包括：

(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构化类型(struct)
(d) Channel 类型 (管道?)
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型

6.声明变量

1.var 关键字 (莫名js)

go 复制代码

var x1,x2 int  

var b,c int = 1, 2 (python!)

未初始化0,"",false

以下几种类型为 nil：

go 复制代码

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

格式化符号

%b 一个二进制整数，将一个整数格式转化为二进制的表达方式 %c 一个Unicode的字符 %d 十进制整数 %o 八进制整数 %x 小写的十六进制数值 %X 大写的十六进制数值 %U 一个Unicode表示法表示的整型码值 %s 输出以原生的UTF8字节表示的字符，如果console不支持utf8编码，则会乱码 %t 以true或者false的方式输出布尔值 %v 使用默认格式输出值，或者如果方法存在，则使用类性值的String()方法输出自定义值 %T 输出值的类型 (类似 instance of)

fmt.Printf("%");

2.赋值语句

3.:=

go 复制代码

如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，格式：
:= 本身就是声明语句
v_name := value
intVal := 1 相等于：

var intVal int 
intVal =1 

// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

交换两个数
a,b=b,a

4. 常量

1.const

go 复制代码

const b string = "123"

//用于枚举
const (
  age = 12 
  xxx
)

内置的Println()/Print()函数都是标准错误输出 ，而fmt.Println()函数是标准输出
内置的Println()/Print()函数输出结果可能与预期结果顺序不一致 ，而fmt.Println()函数输出结果与预期结果完全一致 。(这个特性是由标准错误输出和标准输出决定)
内置Println()/Print()函数不能接受数组和结构体类型的数据
内置Println()/Print()函数对于组合类型的数据 输出的结果是参数值的地址 ，而fmt.Println()函数输出的是字面量

2.特殊常量iota(枚举? 0开始)

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

go 复制代码

const (
	a = iota //0
	b = iota //1
	c = iota //2
)

func main() {
	fmt.Print(c)
}
=================
func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
        //const 用于枚举,下一个如果没有初始化就与上面一致
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

===============
const (
    i=1<<iota
    j=3<<iota
    k  //枚举 3不变 iota+1=  3<<2
    l   //3 << 3
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

5. 包内变量

golang里面没有全局变量定义函数外的变量是包内变量，并且不能使用:= 只能使用var进行定义

Golang基础语法(1)

1.语法基础

1.例子

2.字符串可以使用+ 连接

3.变量声明

4.格式化字符串

5.数据类型

6.声明变量

1.var 关键字 (莫名js)

2.赋值语句

3.:=

4. 常量

1.const

2.特殊常量iota(枚举? 0开始)

5. 包内变量

2.字符串可以使用`+` 连接