Go语言基础入门第三章

常量

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

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

const identifier [type] = value

可以省略类型说明符[type]，因为编译器可以根据变量的值来推断其类型。

显式类型定义：const b string = “abc”

隐式类型定义：const b = “abc”

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

代码如下：

package main

func main() {
   //常量
   var URL string = "www.baidu.com"
   var URL2 = "www.cs.com"
   var a, b, c = 3.14, "cs", 5
   println(URL, URL2, a, b, c)
}

特殊常量iota

iota，特殊常量，可以任务是一个可以被编译器修改的常量。iota是go语言的常量计数器

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

iota可以被用作枚举值：

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

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

const(
	a = iota
	b
	c
)

例子：

布尔类型

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

package main

import "fmt"

func main() {
   var a bool
   var b bool

   a = true
   b = false

   fmt.Printf("%T, %t\n", a, b)
   fmt.Printf("%T, %t\n", b, b)
   fmt.Printf("%T, %t\n", a, a)
}

数字型

整型int和浮点型float32、float64，Go语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。

Go也有基于架构的类型，例如：uint无符号、int有符号

序号	类型和描述
1	uint8 无符号8位整型（0到255）
2	uint16 无符号16位整型（0到65535）
3	uint32 无符号32位整型（0到4294967295）
4	uint64 无符号64位整型（0到18446744073709551615）
5	int8 有符号8位整型（-128到127）
6	int16 有符号16位整型（-32768到32767）
7	int32 有符号32位整型（-2147483648到2147483647）
8	int64 有符号64位整型（-9223372036854775808到9223372036854775807）

字符串

package main

import "fmt"

func main() {
   var str string
   str = "www"
   fmt.Printf("%T, %s\n", str, str)

   //单引号 字符， 整型-ASCII字符码
   v1 := 'A'
   v2 := "A"

   //所有的中国汉字的编码表：GBK
   //全世界的字符编码表：Unicode编码表
   fmt.Printf("%T, %d\n", v1, v1)
   fmt.Printf("%T, %s\n", v2, v2)

   //字符串连接 +
   println("hello" + "wk")

   //转义字符 \
   println("hello\\'world")
}

数据类型转换

在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明:

valueOfTypeB = typeB(ValueOfTypeA)

类型B的值 = 类型B(类型A的值)

package main

import (
   "fmt"
   "strconv"
)

func main() {
   a := 5.0
   b := int(a)
   c := strconv.FormatFloat(a, 'f', 1, 64)
   fmt.Printf("%T, %f\n", a, a)
   fmt.Printf("%T, %d\n", b, b)
   fmt.Printf("%T, %s\n", c, c)
}

类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型(将int16 转换为 int32)。当一个取值范围较大的类型转换到取值范围较小的类型时将 int32 转换为 int16 或将 float32 转换为 int)，会发生度丢失（截断）的情况。

运算符

---

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

算术运算符

下表列出了所有Go语言的算术运算符。假定A值为10，B值为20。

运算符	描述	实例
+	相加	A+B 输出结果为 30
-	相减	A-B 输出结果为 -10
*	相乘	A*B 输出结果为 200
/	相除	B/A 输出结果为 2
%	求余	B%A 输出结果为 0
++	自增	A++ 输出结果为 11
–	自减	A-- 输出结果为 9

关系运算符

下表列出了所有Go语言的算术运算符。假定A值为10，B值为20。

运算符	描述	实例
==	检查两个值是否相等，如果相等返回true，否则返回false	(A == B) 结果为false
!=	检查两个值是否不相等，如果不相等返回true，否则返回false	(A != B) 结果为true
>	检查左边的值是否大于右边的值，如果大于返回true，否则返回false	(A > B) 结果为false
<	检查左边的值是否小于右边的值，如果小于返回true，否则返回false	(A < B) 结果为true
>=	检查左边的值是否大于等于右边的值，如果大于等于返回true，否则返回false	(A >= B) 结果为false
<=	检查左边的值是否小于等于右边的值，如果小于等于返回true，否则返回false	(A <= B) 结果为true

逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定A值为 True，B 值为 False。

运算符	描述	实例
&&	逻辑AND运算。如果两边的条件都为true则返回true，否则返回false	(A && B) 结果为false
||	逻辑OR运算符。如果两边的条件有一个为true则返回true，否则返回false	(A|| B) 结果为 true
！	逻辑NOT运算符。对条件取反，条件为true则返回false，否则返回true。	(!A) 结果为false

位运算符

Go语言支持的位运算符如下表所不。假定A为60，B为13：

运算符	描述	实例
&	按位与运算符"&”是双目运算符。都是1结果为1，否则是0	(A & B)结果为12,二进制为 0000 1100
|	按位或运算符”"是双目运算符。都是0结果为0，否是是1	(A | B) 结果为61，二进制为0011 1101
^	按位异或运算符”^"是双目运算符。不同则为1，相同为0	(A ^ B)结果为49,二进制为0011 0001
&^	位清空，a &^b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.	(A &^ B)结果为 48,二进制为 0011 0000
<<	左移运算符<<”是双目运算符。左移n位就是乘以2的n次方。其功能把”<<”左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	(A << 2)结果为240进制为 1111 0000
>>	右移运算符”>>”是双目运算符。右移n位就是除以2的n次方。其功能是把”>>”左边的运算数的各二进位全部右移若干位，">>”右边的数指定移动的位数。	(A >> 2)结果为 15，二进制为0000 1111

赋值运算符

下表列出了所有Go语言的赋值运算符：

运算符	描述	实例
=	将符号右边的值赋给左边的对象
+=	相加之后赋值	C += A 等价于 C = C + A （以下类推）
-=	相减之后赋值
*=	相乘之后赋值
/=	相除之后赋值
%=	求余之后赋值
<<=	左移之后赋值
>>=	右移之后赋值
&=	按位与之后赋值
^=	按位异或之后赋值
|=	按位或之后赋值

键盘输入输出

package main

import "fmt"

func main() {
   var x int
   var y float64

   //定义了两个变量，用键盘录入这两个变量的值
   fmt.Println("请输入两个数，第一个整数，第二个浮点数：")

   //变量取地址 &变量
   fmt.Scanln(&x, &y)
   fmt.Println("x:", x)
   fmt.Println("y:", y)
}