Go语言入门--基础语法

Go语言入门系列文章目录

• Go语言入门–基础语法
• Go语言入门–流程语句
• Go语言入门–数组和切片
• 集合(Map)(咕咕咕)
• 字符串(string)
• 函数
• 指针
• 结构体
• 方法
• 接口
• 错误
• 包
• IO操作
• 并发
• 反射

---

一、变量

1.1 什么是变量

变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。

所以变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变

1.2 声明变量

1.2.1 单变量声明

• 指定变量类型，声明后若不赋值，使用默认值

数值类型变量对应的零值是0，布尔类型变量对应的零值是false，字符串类型对应的零值是空字符串，接口或引用类型（包括slice、指针、map、chan和函数）变量对应的零值是nil。数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。

var name type
name = value

• 根据值自行判定变量类型

如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。

var name = value

• 简短变量声明 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误

name := value

简短变量声明语句只有对已经在同级词法域声明过的变量才和赋值操作语句等价，如果变量是在外部词法域声明的，那么简短变量声明语句将会在当前词法域重新声明一个新的变量。
即这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

1.2.2多变量声明

• 以逗号分隔，声明与赋值分开，若不赋值，存在默认值

var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3

• 直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

• 集合类型

var (
    name1 type1
    name2 type2
)

1.2.3 注意事项

• 变量必须先定义才能使用
• go语言是静态语言，要求变量的类型和赋值的类型必须一致。
• 变量名不能冲突。(同一个作用于域内不能冲突)
• 简短定义方式，左边的变量名至少有一个是新的
• 简短定义方式，不能定义全局变量。
• 变量的零值。也叫默认值。
• 变量定义了就要使用，否则无法通过编译。

二、常量

1.1 什么是常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量

1.2 声明变量

1.2.1声明变量

const identifier [type] = value

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

 多重赋值： const a, b, c = 1, false, "str" 

• 常量可以作为枚举，常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

• 常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

package main

import (
    "fmt"
)

func main() {
    const (
        x uint16 = 16
        y
        s = "abc"
        z
    )
    fmt.Printf("%T,%v\n", y, y)
    fmt.Printf("%T,%v\n", z, z)
}

运行结果：

1.2.2 iota

• iota，特殊常量，可以认为是一个可以被编译器修改的常量

• iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

• 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

• iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            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)
}

运行结果：

1.2.3 注意事项

• 量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

• 不曾使用的常量，在编译的时候，是不会报错的

• 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

• 如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

• 自增默认是int类型，可以自行进行显示指定类型

• 数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址

三、基本数据类型

1.1 布尔型bool

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

1.2 数值型

1.2.1 整数型

• int8
  有符号 8 位整型 (-128 到 127) 长度：8bit

• int16
  有符号 16 位整型 (-32768 到 32767)

• int32
  有符号 32 位整型 (-2147483648 到 2147483647)

• int64
  有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

• uint8
  无符号 8 位整型 (0 到 255)8位都用于表示数值：

• uint16
  无符号 16 位整型 (0 到 65535)

• uint32
  无符号 32 位整型 (0 到 4294967295)

• uint64
  无符号 64 位整型 (0 到 18446744073709551615)

int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。
大小:32位系统32位，64位系统64位。
范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。

1.3浮点型

• float32

IEEE-754 32位浮点型数

• float64

IEEE-754 64位浮点型数

• complex64

32 位实数和虚数

• complex128

64 位实数和虚数

1.4其他

• byte

类似 uint8

• rune

类似 int32

• uint

32 或 64 位

• int

与 uint 一样大小

• uintptr

无符号整型，用于存放一个指针

1.5 字符串型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

var str string
str = "Hello World"

1.6 数据类型转换：Type Convert

语法格式：Type(Value)

常数：在有需要的时候，会自动转型

变量：需要手动转型 T(V)

注意点：兼容类型可以转换

四、复合类型(派生类型)

1、指针类型（Pointer）
2、数组类型
3、结构化类型(struct)
4、Channel 类型
5、函数类型
6、切片类型
7、接口类型（interface）
8、Map 类型

五、运算符

表达式：(a + b) * c

​ a,b,c叫做操作数

​ +，*，叫做运算符

1 运算符

1.1 算术运算符

+ - * / %(求余) ++ --

1.2 关系运算符

== != > < >= <=

1.3 逻辑运算符

运算符 描述
&& 所谓逻辑与运算符。如果两个操作数都非零，则条件变为真
|| 所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真
! 所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

1.4 位运算符

最难理解的就是^了，只要认为AB两者都相同的时候，为0，其他都为1

假设A为60，B为13
运算 描述 示例
A为60(0011 1100)，B为13(0000 1101)

操作符	描述	结果
&	二进制与操作副本位的结果，如果它存在于两个操作数 (A & B) = 12	0000 1100
|	二进制或操作副本，如果它存在一个操作数 (A | B) = 61	0011 1101
^	二进制异或操作副本，如果它被设置在一个操作数就是按位取非 (A ^ B) = 49	0011 0001
&^	二进制位清空&^ 清零a中，ab都为1的位 (A&^B)=48	0011 0000
<<	二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数 A << 2 =240	1111 0000
>>	二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动 A >> 2 = 15	0000 1111

1.5 赋值运算符

运算符	描述	示例
=	简单的赋值操作符，分配值从右边的操作数左侧的操作数	C = A + B 将分配A + B的值到C
+=	相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数	C += A 相当于 C = C + A
-=	减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数	C -= A 相当于 C = C - A
*=	乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数	C * = A 相当于 C = C*A
/=	除法赋值运算符，它把左操作数与右操作数和分配结果左操作数	C /= A 相当于 C = C / A
%=	模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数	C %= A 相当于 C = C % A
<<=	左移位并赋值运算符	C <<= 2 相同于 C = C << 2
>>=	向右移位并赋值运算符	C >>= A 相当于 C = C>> A
&=	按位与赋值运算符	C&= 2 相同于 C = C & 2
^=	模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数	C ^= 2 相同于 C = C ^ 2
|=	按位或并赋值运算符	C |= 2 相同于 C = C | 2

1.6优先级运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级	运算符
7	~ ! ++ –
6	* / % << >> & &^
5	+ - ^
4	== != < <= >= >
3	<-
2	&&
1	||

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
算术运算符 可以适用于整数、浮点数和复数
取模运算符%仅用于整数间的运算

四、键盘输入和打印输出

1打印输出

1.1 fmt包

fmt包实现了类似C语言printf和scanf的格式化I/O。格式化verb（’verb’）源自C语言但更简单。

详见官网fmt的API：https://golang.google.cn/pkg/fmt/

1.2 导入包

import "fmt"COPY

1.3 常用打印函数

• 打印：

func Print(a …interface{}) (n int, err error)

• 格式化打印：

func Printf(format string, a …interface{}) (n int, err error)

• 打印后换行

func Println(a …interface{}) (n int, err error)

• 格式化打印中的常用占位符：

占位符	效果
%v	原样输出
%T	打印类型
%t	bool类型
%s	字符串
%f	浮点
%d	10进制的整数
%b	2进制的整数
%o	8进制
%x，%X	16进制
%c	打印字符
%p	打印地址

示例代码：

package main

import (
    "fmt"
)

func main() {
    a := 100           //int
    b := 3.14          //float64
    c := true          // bool
    d := "Hello World" //string
    e := "Ruby"        //string
    f := 'A'
    fmt.Printf("%T,%b\n", a, a)
    fmt.Printf("%T,%f\n", b, b)
    fmt.Printf("%T,%t\n", c, c)
    fmt.Printf("%T,%s\n", d, d)
    fmt.Printf("%T,%s\n", e, e)
    fmt.Printf("%T,%d,%c\n", f, f, f)
    fmt.Println("-----------------------")
    fmt.Printf("%v\n", a)
    fmt.Printf("%v\n", b)
    fmt.Printf("%v\n", c)
    fmt.Printf("%v\n", d)
    fmt.Printf("%v\n", e)
    fmt.Printf("%v\n", f)

}

运行结果：

2键盘输入

2.1 fmt包读取键盘输入

• 常用方法：

func Scan(a …interface{}) (n int, err error)

func Scanf(format string, a …interface{}) (n int, err error)

func Scanln(a …interface{}) (n int, err error)

示例代码：

package main

import (
    "fmt"
)

func main() {
    var x int
    var y float64
    fmt.Println("请输入一个整数，一个浮点类型：")
    fmt.Scanln(&x,&y)//读取键盘的输入，通过操作地址，赋值给x和y   阻塞式
    fmt.Printf("x的数值：%d，y的数值：%f\n",x,y)

    fmt.Scanf("%d,%f",&x,&y)
    fmt.Printf("x:%d,y:%f\n",x,y)
}

运行结果：

2.2 bufio包读取

bufio包中都是IO操作的方法：

先创建Reader对象：

 reader := bufio.NewReader(os.Stdin)

然后就可以各种读取了：

示例代码：

package main

import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    fmt.Println("请输入一个字符串：")
    reader := bufio.NewReader(os.Stdin)
    s1, _ := reader.ReadString('\n')
    fmt.Println("读到的数据：", s1)

}

运行效果：

总结

本文为我自己的学习笔记,记录一下方便以后查阅. 如有问题请和我联系