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

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
", 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
",
      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
", 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语言只有值传递一种方式，值传递和指针配合