GO语言的基本语法之变量，常量，条件语句，循环语句

作为慕课网得笔记自己看

定义变量：

使用var关键字

• var a, b, C bool
• var s1, s2 string = "hello", "world'
• 可放在函数内,或直接放在包内
• 使用var()集中定义变量

让编译器自动决定类型

• vara,b,i,s1, s2 = true, false, 3, "hello", "world"

使用:=定义变量

• a,b,i,s1, s2:= true, false, 3, "hello", "world"
• 只能在函数内使用

内建变量类型：

• bool, string就是正常的布尔和string
• (u)int, (u)int8, (u)int16, (u)int32, (u)int64, 加个u就是无符号整数，不加u就是有符号整数
• 有符号整数还分为两类，一种规定长度，一种没规定长度，没规定长度的跟着操作系统走
• uintptr就是指针，长度一样是跟着操作系统来的
• byte, rune ，其中的rune就是字符型，就是GO语言的char类型，32位
• float32, float64, complex64, complex128，浮点数类型，这个complex是复数，就是带有实部和虚部的那个

强制类型转换：

只有强制的类型转换

常量定义：

• const filename = "abc.txt"
• const 数值可作为各种类型使用
• consta,b=3,4
• var C int = int(math.Sqrt(a*a + b * b))

还有特殊的常量，枚举类型

• 普通的枚举类型
• 自增值的枚举类型

示例代码如下：

package main

import (

   "fmt"

   "math"

   "math/cmplx"

)

//函数外面定义变量，不能使用:=

//这样的全部都是包内的变量，不是全局变量

var (

   aa = 3

   ss = "kkk"

   bb = true

)

//这里是用函数定义一个变量

func variableZeroValue() {

   var a int

   var s string

   fmt.Printf("%d %q\n", a, s)

}

//这里是赋上初值，PS:定义了就必须要用

func variableInitialValue() {

   var a, b int = 3, 4

   var s string = "abc"

   fmt.Println(a, b, s)

}

//省略类型名，自动辨识初值，不是一个类型也可以写在一行

func variableTypeDeduction() {

   var a, b, c, s = 3, 4, true, "def"

   fmt.Println(a, b, c, s)

}

//省略var，使用:=和使用var是一样的

//第一次必须要使用:=，后面就还要用=，不需要再用:=

func variableShorter() {

   a, b, c, s := 3, 4, true, "def"

   b = 5

   fmt.Println(a, b, c, s)

}

//欧拉公式

func euler() {

   fmt.Printf("%.3f\n",

      cmplx.Exp(1i*math.Pi)+1)

}

//强制类型转换

func triangle() {

   var a, b int = 3, 4

   fmt.Println(calcTriangle(a, b))

}

//强制类型转换

func calcTriangle(a, b int) int {

   var c int

   c = int(math.Sqrt(float64(a*a + b*b)))

   return c

}

//设置常量

func consts() {

   const (

      filename = "abc.txt"

      a, b     = 3, 4

   )

   var c int

   c = int(math.Sqrt(a*a + b*b))

   fmt.Println(filename, c)

}

//特殊常量：枚举类型

func enums() {

   const (

      cpp = iota//iota表示自增值

      _

      python

      golang

      javascript

   )

   const (

      b = 1 << (10 * iota)

      kb

      mb

      gb

      tb

      pb

   )

   fmt.Println(cpp, javascript, python, golang)

   fmt.Println(b, kb, mb, gb, tb, pb)

}

func main() {

   fmt.Println("Hello world")

   variableZeroValue()

   variableInitialValue()

   variableTypeDeduction()

   variableShorter()

   fmt.Println(aa, ss, bb)

   euler()

   triangle()

   consts()

   enums()

}

变量定义要点：

• 变量类型写在变量名之后
• 编译器可推测变量类型
• 没有char ,只有rune
• 原生支持复数类型

---

条件语句：

if：

• if的条件不需要括号括起来
• if的条件里可以赋值
• if的条件里赋值的变量作用域就在这个if语句中

switch：

• switch会自动break，除非使用fallthrough
• switch后面可以不带表达式

示例代码如下：

package main

import (

   "fmt"

   "io/ioutil"

)

//switch函数用法

func grade(score int) string {

   g := ""

   switch {

   case score < 0 || score > 100:

      panic(fmt.Sprintf(

         "Wrong score: %d", score))

   case score < 60:

      g = "F"

   case score < 80:

      g = "C"

   case score < 90:

      g = "B"

   case score <= 100:

      g = "A"

   }

   return g

}

func main() {

   // If "abc.txt" is not found,

   // please check what current directory is,

   // and change filename accordingly.

   const filename = "abc.txt"

   //ioutil.ReadFile读出abc.txt的内容

   if contents, err := ioutil.ReadFile(filename); err != nil {

      fmt.Println(err)

   } else {

      fmt.Printf("%s\n", contents)

   }

   fmt.Println(

      grade(0),

      grade(59),

      grade(60),

      grade(82),

      grade(99),

      grade(100),

      // Uncomment to see it panics.

      // grade(-3),

   )

}

循环语句：

for：

• for的条件里不需要括号
• for的条件里可以省略初始条件,结束条件,递增表达式
• 可以省略初始条件，相当于while
• 什么都省略的情况为死循环

示例代码如下：

package main

import (

   "bufio"

   "fmt"

   "io"

   "os"

   "strconv"

   "strings"

)

//将整数转换为二进制表达式

func convertToBin(n int) string {

   result := ""

   for ; n > 0; n /= 2 {

      lsb := n % 2

      //strconv.Itoa变为字符串

      result = strconv.Itoa(lsb) + result

   }

   return result

}

//读取文件

func printFile(filename string) {

   file, err := os.Open(filename)

   if err != nil {

      panic(err)

   }

   printFileContents(file)

}

//读取文件内容

func printFileContents(reader io.Reader) {

   scanner := bufio.NewScanner(reader)

   for scanner.Scan() {

      fmt.Println(scanner.Text())

   }

}

//死循环

func forever() {

   for {

      fmt.Println("abc")

   }

}

func main() {

   fmt.Println("convertToBin results:")

   fmt.Println(

      convertToBin(5),  // 101

      convertToBin(13), // 1101

      convertToBin(72387885),

      convertToBin(0),

   )

   fmt.Println("abc.txt contents:")

   printFile("lang/basic/branch/abc.txt")

   fmt.Println("printing a string:")

   s := `abc"d"

   kkkk

   123

   p`

   printFileContents(strings.NewReader(s))

   // Uncomment to see it runs forever

   // forever()

}

基本语法要点：

• for, if后面的条件没有括号
• if 条件里也可定义变量
• 没有while
• switch不需要break ,也可以直接switch多个条件

函数：

函数返回多个值时可以起名字

仅用于非常简单的函数

对于调用者而言没有区别

函数语法要点回顾：

返回值类型写在最后面

可返回多个值

函数作为参数

没有默认参数,可选参数

指针：

指针不能运算

参数传递是值传递还是引用传递？

GO语言只有值传递一种方式，值传递和指针配合