Go之路四：基本语法(运算符和数组)

Posted 2021-07-06 中國颜值的半壁江山

1、运算符

Go 语言内置的运算符有：

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 位运算符
5. 赋值运算符

算术运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余

注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

关系运算符

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

逻辑运算符

运算符	描述
&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
!	逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符	描述
&	参与运算的两数各对应的二进位相与。 （两位均为1才为1）
|	参与运算的两数各对应的二进位相或。 （两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

赋值运算符

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
|=	按位或后赋值
^=	按位异或后赋值

2、Array数组

数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。 基本语法：

// 定义一个长度为3元素类型为int的数组a
var a [3]int

数组定义

var 数组变量名 [元素数量]T

比如：var a [5]int， 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。 [5]int和[10]int是不同的类型。

var a [3]int
var b [4]int
a = b //不可以这样做，因为此时a和b是不同的类型

数组的初始化

数组的初始化也有很多方式。

方法一：

初始化数组时可以使用初始化列表来设置数组元素的值。

func array() {
   var testArray [3]int                           // 数组会初始化为int类型的零值
   var numArray = [3]int{1, 100}                  // 使用指定的初始值完成初始化
   var cityArray = [3]string{"北京", "上海", "深圳"}// 使用指定的初始值完成初始化
   fmt.Println(testArray)                         // [0 0 0]
   fmt.Println(numArray)                          // [1 2 0]
   fmt.Println(cityArray)                         // [北京 上海 深圳]
}

--->>>
[0 0 0]
[1 100 0]
[北京 上海 深圳]

方法二：

func array_2() {
   var testArray [3]int
   var numArray = [...]int{2, 4}
   var cityArray = [...]string{"曹县", "北京"}
   fmt.Println(testArray)                          //[0 0 0]
   fmt.Println(numArray)                           //[1 2]
   fmt.Printf("type of numArray:%T\\n", numArray)   //type of numArray:[2]int
   fmt.Println(cityArray)                          //[北京 上海 深圳]
   fmt.Printf("type of cityArray:%T\\n", cityArray) //type of cityArray:[3]string
}

--->>>
[0 0 0]
[2 4]
type of numArray:[2]int
[曹县 北京]
type of cityArray:[2]string

方法三:

我们还可以使用指定索引值的方式来初始化数组，例如:

func array_3()  {
   a := [5]int{1:3, 3:9}
   fmt.Println(a)
}

--->>>
[0 3 0 9 0]

数组的遍历

遍历数组a有以下两种方法：

方法一：

func array_for_1() {
   a := [...]string{"曹县", "北京", "上海", "广州"}
   for i:=0; i<len(a); {
      fmt.Println(a[i])
      i++
   }
}

--->>>
曹县
北京
上海
广州

方法二：

func array_for_2() {
   a := [...]string{"曹县", "北京", "上海", "广州"}
   for k, v :=range a {
      fmt.Println(k, v)
   }
}

--->>>
0 曹县
1 北京
2 上海
3 广州

多维数组

Go语言是支持多维数组的，我们这里以二维数组为例（数组中又嵌套数组）。

二维数组的定义

func doub_array() {
   a11 := [3][2]string{
      {"安徽", "合肥"},
      {"山东", "济南"},
      {"宇宙", "曹县"},
   }
   fmt.Println(a11)
   fmt.Println(a11[2][1])
}

--->>>
[[安徽 合肥] [山东 济南] [宇宙 曹县]]
曹县

二位数组的遍历

func doub_array() {
   a11 := [3][2]string{
      {"安徽", "合肥"},
      {"山东", "济南"},
      {"宇宙", "曹县"},
   }

   for _, v1 := range a11 {
      //fmt.Println(v1)
      for _, v2 := range v1 {
         fmt.Printf("%s\\t", v2)
      }
      fmt.Println()
   }
}

--->>>
安徽	合肥	
山东	济南	
宇宙	曹县

注意： 多维数组只有第一层可以使用...来让编译器推导数组长度。例如：

//支持的写法
a := [...][2]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},
}
//不支持多维数组的内层使用...
b := [3][...]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},
}

数组是值类型

数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

func modifyArray(x [3]int) {
	x[0] = 100
}

func modifyArray2(x [3][2]int) {
	x[2][0] = 100
}
func main() {
	a := [3]int{10, 20, 30}
	modifyArray(a) //在modify中修改的是a的副本x
	fmt.Println(a) //[10 20 30]
	b := [3][2]int{
		{1, 1},
		{1, 1},
		{1, 1},
	}
	modifyArray2(b) //在modify中修改的是b的副本x
	fmt.Println(b)  //[[1 1] [1 1] [1 1]]
}

注意：

1. 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
2. [n]*T表示指针数组，*[n]T表示数组指针 。

3、练习题:

1. 求数组[1, 3, 5, 7, 8]所有元素的和

2. 找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。

解答：

func array_5() {
	// 求和
	a := [...]int{1, 3, 5, 7, 8}
	var b int
	for _, k := range a {
		b = b + k
	}
	fmt.Println(b)
}

func array_6() {
	// 找到数组中和为指定数值的两个元素的下标,如数组 [1, 3, 5, 7, 8]
	a := []int{1, 3, 4, 5, 7, 8}
	for i := 0; i < len(a); i++ {
		for j := i+1; j <len(a); j++ {
			if a[i]+a[j] == 8 {
				fmt.Printf("(%d, %d)\\n",i, j)
			}
		}
	}
}