Go学习(2):基本语法

系统管理员 2022-05-11 07:18 304阅读 0赞

# 基本语法 #

## 一、二进制、八进制、十进制、十六进制【扩展内容】 ##

### 1.1 进制 ###

二进制：逢二进一，数值只有0和1。

八进制：逢八进一，数值有0,1,2,3,4,5,6,7

十进制：逢十进一，数值有0,1,2,3,4,5,6,7,8,9

十六进制：逢十六进一，数值有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

### 1.2 进制转换 ###

二进制、八进制、十六进制转为十进制

十进制转为二进制、八进制、十六进制

### 1.3 原码，反码，补码 ###

#### 1.3.1 机器数和真值 ####

机器数：一个数在计算机中的二进制表示形式。叫做这个数的机器数。机器数是带符号的，最高位0表示正数，1表示负数。
    	示例：
    		比如10进制中的+3，计算机长度为8位。转为二进制是0000 0011。
    		比如-3，转为二进制是1000 0011。
    
    真值：就是我们日常说的十进制的正数，负数和0，比如-1，-2，-100，0，1，2，1000,100000等等。
    	因为第一位是符号位，所以机器数的形式值就不等于真正的数值。
    	比如1000 0011，
    		作为负数可以是-3，作为正数可以说131.
    	为了区分，将带符号位的计算数对应的真正的数值称为机器数的真值。

### 1.3.2 原码，反码，补码 ###

原码：就是符号位加上真值的绝对值，即第一位表示符号位，其余位表示值。
    +1 = [0000 0001]原
    -1 = [1000 0001]原
    原码是人脑最容易理解和计算的表示方式.
    
    反码：正数的反码是其本身，负数的反码是在其原码的基础上，符号位不变，其余各位按位取反。
    +1 = [0000 0001]原 = [0000 0001]反
    -1 = [1000 0001]原 = [1111 1110]反
    一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。
    
    补码：正数的补码是其本身，负数的补码是在原码的基础上，符号位不变，其余各位取反后+1。
    +1 = [0000 0001]原 = [0000 0001]反 = [0000 0001]补
    -1 = [1000 0001]原 = [1111 1110]反 = [1111 1111]补
    对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

> 于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码。计算十进制的表达式: 1-1=0
> 
> 1 - 1 = 1 + (-1) = \[00000001\]原 + \[10000001\]原 = \[10000010\]原 = -2
> 
> 如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.
> 
> 为了解决原码做减法的问题, 出现了反码。计算十进制的表达式:
> 
> 1-1=0
> 
> 1 - 1 = 1 + (-1)  
> = \[0000 0001\]原 + \[1000 0001\]原  
> = \[0000 0001\]反 + \[1111 1110\]反  
> = \[1111 1111\]反 = \[1000 0000\]原  
> = -0
> 
> 发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在”0”这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有\[0000 0000\]原和\[1000 0000\]原两个编码表示0.
> 
> 于是补码的出现, 解决了0的符号以及两个编码的问题:
> 
> 1-1 = 1 + (-1)  
> = \[0000 0001\]原 + \[1000 0001\]原  
> = \[0000 0001\]补 + \[1111 1111\]补  
> = \[0000 0000\]补=\[0000 0000\]原
> 
> 这样0用\[0000 0000\]表示, 而以前出现问题的-0则不存在了.而且可以用\[1000 0000\]表示-128:

## 二、变量与常量 ##

### 2.1 什么是变量 ###

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

### 2.2 声明变量 ###

var名称类型是声明单个变量的语法。

> 以字母或下划线开头，由一个或多个字母、数字、下划线组成

声明一个变量

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

var name type
    name = value

第二种，根据值自行判定变量类型(类型推断Type inference)

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

var name = value

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

name := value
    
    // 例如
    var a int = 10
    var b = 10
    c : = 10

> 这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

示例代码：

package main
    var a = "Hello"
    var b string = "World"
    var c bool
    
    func main(){ 
        println(a, b, c)
    }

运行结果：

Hello World false

#### 多变量声明 ####

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

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

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

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

第三种，集合类型

var (
        name1 type1
        name2 type2
    )

#### 注意事项 ####

如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

func main() { 
       var a string = "abc"
       fmt.Println("hello, world")
    }

尝试编译这段代码将得到错误 a declared and not used

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

在同一个作用域中，已存在同名的变量，则之后的声明初始化，则退化为赋值操作。但这个前提是，最少要有一个新的变量被定义，且在同一作用域，例如，下面的y就是新定义的变量

package main
    
    import (
    	"fmt"
    )
    
    func main() { 
    	x := 140
    	fmt.Println(&x)
    	x, y := 200, "abc"
    	fmt.Println(&x, x)
    	fmt.Print(y)
    }

运行结果：

0xc04200a2b0
    0xc04200a2b0 200
    abc

**空白标识符 \_ 也被用于抛弃值**，如值 5 在：\_, b = 5, 7 中被抛弃

\_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值

并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)

1.变量必须先声明，才能够使用，而且每个变量只能被声明一次。
    2.因为go是强类型语言，赋值类型要对应
    3.name := value，这种声明变量的方式，不能在函数外部使用
    4.默认值：也叫零值。

### 2.3 常量声明 ###

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

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

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

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

const identifier [type] = value

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

package main
    
    import "fmt"
    
    func main() { 
       const LENGTH int = 10
       const WIDTH int = 5   
       var area int
       const a, b, c = 1, false, "str" //多重赋值
    
       area = LENGTH * WIDTH
       fmt.Printf("面积为 : %d", area)
       println()
       println(a, b, c)   
    }

运行结果：

面积为 : 50
    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)
    }

运行结果：

uint16,16
    string,abc

### 2.4 iota ###

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

> 在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1

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)
    }

运行结果：

0 1 2 ha ha 100 100 7 8

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

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

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

## 三、基本数据类型 ##

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

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>布尔型</td> 
   <td align="left">布尔型的值只可以是常量 true 或者 false。一个简单的例子：<br>var b bool = true。</td> 
  </tr> 
  <tr> 
   <td>数字类型</td> 
   <td align="left">整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码</td> 
  </tr> 
  <tr> 
   <td>字符串类型</td> 
   <td align="left">字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。</td> 
  </tr> 
  <tr> 
   <td>派生类型</td> 
   <td align="left">包括：<br>(a) 指针类型（Pointer）<br>(b) 数组类型<br>(c) 结构化类型(struct)<br> (d) Channel 类型<br>(e) 函数类型<br>(f) 切片类型<br>(g) 接口类型（interface）<br>(h) Map 类型</td> 
  </tr> 
 </tbody> 
</table>

![002_E6_95_B0_E6_8D_AE_E7_B1_BB_E5_9E_8B.jpg][]

### 2.1 布尔型bool ###

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

### 2.2 数值型 ###

**1、整型**

*  int8  
    有符号 8 位整型 (-128 到 127)
 *  int16  
    有符号 16 位整型 (-32768 到 32767)
 *  int32  
    有符号 32 位整型 (-2147483648 到 2147483647)
 *  int64  
    有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
 *  uint8  
    无符号 8 位整型 (0 到 255)
 *  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
    
    无符号整型，用于存放一个指针

### 2.3 字符串型 ###

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

var str string
    	str = "Hello World"

### 2.4 派生类型(复合类型) ###

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

## 四、运算符 ##

### 3.1 算术运算符 ###

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

### 3.2 关系运算符 ###

== != > < >= <=

### 3.3 逻辑运算符 ###

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

### 3.4 位运算符 ###

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

假设A为60，B为13

<table> 
 <thead> 
  <tr> 
   <th>运算</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>二进制与操作副本位的结果，如果它存在于两个操作数</td> 
   <td>(A &amp; B) = 12, 也就是 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>二进制或操作副本，如果它存在一个操作数</td> 
   <td>(A | B) = 61, 也就是 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>二进制异或操作副本，如果它被设置在一个操作数但不能同时是比特</td> 
   <td>(A ^ B) = 49, 也就是 0011 0001</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数</td> 
   <td>A &lt;&lt; 2 will give 240 也就是 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动</td> 
   <td>A &gt;&gt; 2 = 15 也就是 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

### 3.5 赋值运算符 ###

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

### 3.6优先级 ###

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

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

[002_E6_95_B0_E6_8D_AE_E7_B1_BB_E5_9E_8B.jpg]: http://om1c35wrq.bkt.clouddn.com/002%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.jpg