go语言一天入门（上）

超、凢脫俗 2023-02-09 10:23 5阅读 0赞

# 第一个go程序 #

package main
    
    import "fmt"
    
    func main() {
        /* 这是我的第一个简单的程序 */
        fmt.Println("Hello, World!")
    }

*  第一行代码 *package main* 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
 *  下一行 *import "fmt"* 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
 *  下一行 *func main()* 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
 *  下一行 /\*...\*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /\* 开头，并以 \*/ 结尾，多行注释一般用于包的文档描述或注释成块的代码片段。
 *  下一行 *fmt.Println(...)* 可以将字符串输出到控制台，并在最后自动增加换行字符 \\n。
 *  当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

# 数据类型 #

Go语言的基本类型有：

*  bool
 *  string
 *  int、int8、int16、int32、int64
 *  uint、uint8、uint16、uint32、uint64、uintptr
 *  byte // uint8 的别名
 *  rune // int32 的别名 代表一个 Unicode 码
 *  float32、float64
 *  complex64、complex128

# 变量 #

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。

**1）声明变量的一般形式是使用 var 关键字：var name type**

> Go和许多编程语言不同，它在声明变量时将变量的类型放名称后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：`int* a, b;` 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：var a, b \*int

多变量声明

var (
        a int
        b string
        c []float32
        d func() bool
        e struct {
            x int
        }
    )

**2）除 var 关键字外，还可使用更加简短的变量定义和初始化语法。**

名字 := 表达式

需要注意的是，简短模式（short variable declaration）有以下限制：

*  定义变量，同时显式初始化。
 *  不能提供数据类型。
 *  只能用在函数内部。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

**3）根据值自行判定变量类型。**

package main
    import "fmt"
    func main() {
        var d = true
        fmt.Println(d)
    }

# 算术运算符 #

package main
    
    import "fmt"
    
    func main() {
    
       var a int = 21
       var b int = 10
       var c int
    
       c = a + b
       fmt.Printf("第一行 - c 的值为 %d\n", c )
       c = a - b
       fmt.Printf("第二行 - c 的值为 %d\n", c )
       c = a * b
       fmt.Printf("第三行 - c 的值为 %d\n", c )
       c = a / b
       fmt.Printf("第四行 - c 的值为 %d\n", c )
       c = a % b
       fmt.Printf("第五行 - c 的值为 %d\n", c )
       a++
       fmt.Printf("第六行 - a 的值为 %d\n", a )
       a=21   // 为了方便测试，a 这里重新赋值为 21
       a--
       fmt.Printf("第七行 - a 的值为 %d\n", a )
    }

第一行 - c 的值为 31
    第二行 - c 的值为 11
    第三行 - c 的值为 210
    第四行 - c 的值为 2
    第五行 - c 的值为 1
    第六行 - a 的值为 22
    第七行 - a 的值为 20

# 位运算符 #

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

下表列出了位运算符 &, |, 和 ^ 的计算：

假定 A = 60; B = 13; 其二进制数转换为：

A = 0011 1100
    
    B = 0000 1101
    
    -----------------
    
    A&B = 0000 1100
    
    A|B = 0011 1101
    
    A^B = 0011 0001

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th style="width:468px;">描述</th> 
   <th style="width:285px;">实例</th> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td style="width:468px;">参与运算的两数各对应的二进位相与。</td> 
   <td style="width:285px;">(A &amp; B) 结果为 12, 二进制为 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td style="width:468px;">参与运算的两数各对应的二进位相或</td> 
   <td style="width:285px;">(A | B) 结果为 61, 二进制为 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td style="width:468px;">参与运算的两数各对应的二进位相异或，当两对应的位相异时，结果为1。</td> 
   <td style="width:285px;">(A ^ B) 结果为 49, 二进制为 0011 0001</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td style="width:468px;">左移n位就是乘以2的n次方。 其功能把"&lt;&lt;"左边的运算数的各二进位全部左移若干位，由"&lt;&lt;"右边的数指定移动的位数，高位丢弃，低位补0。</td> 
   <td style="width:285px;">A &lt;&lt; 2 结果为 240 ，二进制为 1111 0000</td> 
  </tr> 
 </tbody> 
</table>

# 赋值运算符 #

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

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <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 等于 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>

# 其他运算符 #

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>返回变量存储地址</td> 
   <td>&amp;a; 将给出变量的实际地址。</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>指针变量。</td> 
   <td>*a; 是一个指针变量</td> 
  </tr> 
 </tbody> 
</table>

以下实例演示了其他运算符的用法：

实例

package main
    
    import "fmt"
    
    func main() {
       var a int = 4
       var b int32
       var c float32
       var ptr *int
    
       /* 运算符实例 */
       fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
       fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
       fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );
    
       /*  & 和 * 运算符实例 */
       ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
       fmt.Printf("a 的值为  %d\n", a);
       fmt.Printf("*ptr 为 %d\n", *ptr);
    }

以上实例运行结果：

第 1 行 - a 变量类型为 = int
    第 2 行 - b 变量类型为 = int32
    第 3 行 - c 变量类型为 = float32
    a 的值为  4
    *ptr 为 4

# 运算符优先级 #

由上至下代表优先级由高到低：

# 循环 #

普通for循环

package main
    
    import "fmt"
    
    func main() {
            sum := 0
            for i := 0; i <= 10; i++ {
                    sum += i
            }
            fmt.Println(sum)
    }

foreach

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main
    import "fmt"
    
    func main() {
            strings := []string{"google", "runoob"}
            for i, s := range strings {
                    fmt.Println(i, s)
            }
    
    
            numbers := [6]int{1, 2, 3, 5} 
            for i,x:= range numbers {
                    fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
            }  
    }

# 函数 #

func function_name( [parameter list] ) [return_types] {
       函数体
    }

*  func：函数由 func 开始声明
 *  function\_name：函数名称，函数名和参数列表一起构成了函数签名。
 *  parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
 *  return\_types：返回类型，函数返回一列值。return\_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return\_types 不是必须的。
 *  函数体：函数定义的代码集合。

/* 函数返回两个数的最大值 */
    func max(num1, num2 int) int {
       /* 声明局部变量 */
       var result int
    
       if (num1 > num2) {
          result = num1
       } else {
          result = num2
       }
       return result 
    }

# 返回多个值 #

package main
    
    import "fmt"
    
    func swap(x, y string) (string, string) {
       return y, x
    }
    
    func main() {
       a, b := swap("Google", "Runoob")
       fmt.Println(a, b)
    }

# 引用传参 #

package main
    
    import "fmt"
    
    func main() {
       /* 定义局部变量 */
       var a int = 100
       var b int= 200
    
       fmt.Printf("交换前，a 的值 : %d\n", a )
       fmt.Printf("交换前，b 的值 : %d\n", b )
    
       /* 调用 swap() 函数
       * &a 指向 a 指针，a 变量的地址
       * &b 指向 b 指针，b 变量的地址
       */
       swap(&a, &b)
    
       fmt.Printf("交换后，a 的值 : %d\n", a )
       fmt.Printf("交换后，b 的值 : %d\n", b )
    }
    
    func swap(x *int, y *int) {
       var temp int
       temp = *x    /* 保存 x 地址上的值 */
       *x = *y      /* 将 y 值赋给 x */
       *y = temp    /* 将 temp 值赋给 y */
    }

# 数组 #

**声明：**

语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

**初始化：**

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

初始化数组中 \{\} 中的元素个数不能大于 \[\] 中的数字。

如果忽略 \[\] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

该实例与上面的实例是一样的，虽然没有设置数组的大小。

balance[4] = 50.0

**初始化二维数组：**

a = [3][4]int{  
     {0, 1, 2, 3} ,   /*  第一行索引为 0 */
     {4, 5, 6, 7} ,   /*  第二行索引为 1 */
     {8, 9, 10, 11},   /* 第三行索引为 2 */
    }

**注意：**以上代码中倒数第二行的 **\}** 必须要有逗号，因为最后一行的 **\}** 不能单独一行，也可以写成这样：

a = [3][4]int{  
     {0, 1, 2, 3} ,   /*  第一行索引为 0 */
     {4, 5, 6, 7} ,   /*  第二行索引为 1 */
     {8, 9, 10, 11}}   /* 第三行索引为 2 */

# 指针 #

和c一样

package main
    
    import "fmt"
    
    func main() {
       var a int= 20   /* 声明实际变量 */
       var ip *int        /* 声明指针变量 */
    
       ip = &a  /* 指针变量的存储地址 */
    
       fmt.Printf("a 变量的地址是: %x\n", &a  )
    
       /* 指针变量的存储地址 */
       fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
    
       /* 使用指针访问值 */
       fmt.Printf("*ip 变量的值: %d\n", *ip )
    }

a 变量的地址是: 20818a220
    ip 变量储存的指针地址: 20818a220
    *ip 变量的值: 20

**空指针判断：**

if(ptr != nil)     /* ptr 不是空指针 */
    if(ptr == nil)    /* ptr 是空指针 */

**多重指针：**

package main
    
    import "fmt"
    
    func main() {
    
       var a int
       var ptr *int
       var pptr **int
    
       a = 3000
    
       /* 指针 ptr 地址 */
       ptr = &a
    
       /* 指向指针 ptr 地址 */
       pptr = &ptr
    
       /* 获取 pptr 的值 */
       fmt.Printf("变量 a = %d\n", a )
       fmt.Printf("指针变量 *ptr = %d\n", *ptr )
       fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
    }

变量 a = 3000
    指针变量 *ptr = 3000
    指向指针的指针变量 **pptr = 3000