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

巴特西

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

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

定义变量：

内建变量类型：

强制类型转换：

常量定义：

示例代码如下：

变量定义要点：

条件语句：

if：

switch：

循环语句：

for：

基本语法要点：

函数：

指针：

最新文章

热门文章