基本语法——数据类型

基本数据类型

以下是go中可用的基本数据类型

布尔型bool

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

数值型

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位系统。

2、浮点型

  • float32

    IEEE-754 32位浮点型数

  • float64

    IEEE-754 64位浮点型数

  • complex64

    32 位实数和虚数

  • complex128

    64 位实数和虚数

3、其他

  • byte

    类似 uint8

  • rune

    类似 int32

  • uint

    32 或 64 位

  • int

    与 uint 一样大小

  • uintptr

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

字符串型

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

1
2
var str string
str = "Hello World"

数据类型转换：Type Convert

语法格式：Type(Value)

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

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

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

复合类型(派生类型)

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

键盘输入和打印输出

打印输出

fmt包

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

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

导入包

1
import "fmt"

常用打印函数

打印：

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进制
%x：0-9，a-f
%X：0-9，A-F
%c，打印字符
%p，打印地址

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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)

}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
int,1100100
float64,3.140000
bool,true
string,Hello World
string,Ruby
int32,65,A
-----------------------
100
3.14
true
Hello World
Ruby
65

键盘输入

fmt包读取键盘输入

常用方法：

​ Scan 从标准输入扫描文本，读取由 空白符 分隔的值分别保存到本函数的参数中。（换行符也被视为空白符）

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)
}

运行结果：

1
2
3
4
5
请输入一个整数，一个浮点类型：
100 3.14
x的数值：100，y的数值：3.140000
100,5.20
x:100,y:5.200000

bufio包读取

https://golang.google.cn/pkg/bufio/

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

先创建Reader对象,然后就可以各种读取了。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

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

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

}

运行效果：

1
2
3
请输入一个字符串：
hello wxy
读到的数据： hello wxy

解释：

  • reader := bufio.NewReader(os.Stdin)：这行代码创建了一个用于读取用户输入的读取器。bufio.NewReader 函数接受一个参数 os.Stdin，它表示标准输入（通常是键盘输入）。reader 是一个读取器对象，我们可以使用它来读取用户输入的字符串。
  • s1, _ := reader.ReadString('\n')：这行代码使用读取器 reader 从标准输入读取字符串，直到遇到换行符 ('\n') 为止。它将读取的字符串赋值给变量 s1。注意，这里使用了 _（下划线）来忽略函数的第二个返回值（表示可能的错误），因为我们不关心错误处理。