Go语言基本语法

隔壁王小猿 2020-05-10

412

肯定不少猿问，为啥要学习Go语言，答案很简单，市场上Go语言工程师需求量远大于供应量，一句话，学会Go语言能找到好工作~ O(∩_∩)O哈哈~ 其实只要自身本来强，都可以找到心仪的工作的

废话不多说，开始我的表演~

如果各位童鞋想要获得下面的源码，请搜索gzh：隔壁王小猿，关注后回复“Go语言基本语法”即可获得

变量的定义

使用var关键字

var a,b,c bool
var s1,s2 string = “hello”,”world”
可以放在函数内，或者直接放在包内
使用var()集中定义变量，函数内和包内都可以用

让编译器自动决定类型

var a,b,i,s1,s2 = true,false,3, “hello”,”world”

使用:=定义变量

a,b,i,s1,s2 := true,false,3, “hello”,”world”
只能在函数内使用，包内不能使用

内建变量类型

bool string
(u)int (u)int8 (u)int16 (u)int32 (u)int64 intptr
u代表无符号
8、16、32、64代表长度
无长度的整形，根据操作系统的位数
Intptr是整数指针
byte rune
byte是2^3 = 8位
rune长度是 32，类似char类型
float32 float64 complex64 complex128
float浮点型，32/64代表位数
complex复数，64位复数（float32实部，float32虚部），128位类型

常量的定义

const filename = “abc.txt”
const数值可以作为各种类型使用，变量不可以
const a,b = 3,4
var c int = int(math.Sqrt(a*a+b*b))

枚举类型

使用常量定义枚举类型
普通枚举类型
自增值枚举类型 iota
变量常量总结
变量类型写在变量名之后
编译器可推测变量的类型
没有char，只有rune
原生支持复数类型

先来看一下这部分的源码说明：

package basic
import (
  "bytes"
  "fmt"
  "math"
  "math/cmplx"
)
//包变量- 包里面是可用的，并不是全局变量
var (
  a_pkg = 123
  b_pkg = true
  c_pkg = "kkk"
)
//包内不能用 := 声明变量
//abc, bcd := 123, false
func variableZeroValue() {
  //函数局部变量
  var a int
  var s string
  fmt.Printf("%d    %q", a, s)
  fmt.Println()
}
func variableInitialValue() {
  var a, b int = 1, 2
  var s string = "abd"
  fmt.Println(a, b, s)
}
func euler() {
  fmt.Printf("%.3f\n",
    cmplx.Exp(1i*math.Pi)+1)
  fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
}
func triangle() {
  var a, b int = 30, 40
  var c int
  c = int(math.Sqrt(float64(a*a + b*b)))
  fmt.Println(c)
  ////var a, b  = 30, 40
  //var a, b  float64 = 30, 40
  ////var c int
  //c = int(math.Sqrt(a*a + b*b))
  ////fmt.Println(c)
}
func variableTypeDeduction() {
  var a, b, c, s = 3, 4, false, "def"
  fmt.Println(a, b, c, s)
}
func variableShortor() {
  abc, bcd := 123, false
  fmt.Println(abc, bcd)
  ss := "abs"
  fmt.Println(ss)
  ss = "abcd"
  fmt.Println(ss)
  var (
    s_a = 2
    s_d = 3
  )
  fmt.Println(s_a, s_d)
}
const fileName = "abc.txt"
const (
  file1 = "file1"
  file2 = "file2"
)
func consts() {
  const a, b = 3, 4
  var c int
  c = int(math.Sqrt(a*a + b*b))
  fmt.Println(c)
  //fmt.Println(fileName, file1, file2)
}
func hello(abc ...interface{}) {


  //fmt.Println(abc)


  for argNum, arg := range abc {
    if argNum > 0 {
      fmt.Println(argNum, arg)
    }
  }
}
func enums() {
  const (
    cpp = iota
    java
    python
    c
    golang
    javascript = 100
    _
    csharp = iota
  )
  fmt.Println(cpp, java, python, c, golang, javascript, csharp)


  const (
    b = 1 << (10 * iota)
    kb
    mb
    gb
    tb
    pb
  )
  fmt.Println(b, kb, mb, gb, tb, pb)
}
func main() {
  //fmt.Println("Hello world!")
  //variableZeroValue()
  //variableInitialValue()
  //variableTypeDeduction()
  //variableShortor()
  //
  //fmt.Println(a_pkg, b_pkg, c_pkg)
  //euler()
  //triangle()
  //var str string
  //str = "anc"
  //fmt.Println(str)
  //consts()
  //hello(fileName, file1, file2, 123)
  enums()
  var bufabc bytes.Buffer
  fmt.Println(bufabc)


}

条件-if、switch

If：用法1

  contents, err := ioutil.ReadFile(filename)
  if err != nil {
    fmt.Println(err)
  } else {
    fmt.Printf("%s\n", contents)
  }
  fmt.Println()

If：用法2

  if contents, err := ioutil.ReadFile(filename); err != nil {
    fmt.Println(err)
  } else{
    fmt.Printf("%s\n", contents)
  }

If：总结

If的条件里可以赋值
If的条件里赋值的变量作用域就在if语句里，其他地方访问不到

Switch：用法1

func eval(a, b int, op string) int {
  var result int
  switch op {
  case "+":
    result = a + b
  case "-":
    result = a - b
  case "*":
    result = a * b
  case "/":
    result = a / b
  default:
    panic("unsupported operator:" + op)
  }
  return result
}

Switch：用法2-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
}

循环-for

  sum := 0
  for i := 1; i <= 100; i++ {
    sum += i
  }

for的条件里不需要括号
for的条件里可以圣罗初始条件，结束条件，递增表达式
省略初始条件

func convertToBin(n int) string {
  result := ""
  for ; n > 0; n /= 2 {
    lsb := n % 2
    result = strconv.Itoa(lsb) + result
  }
  return result
}

省略递增表达式

func printfile(filename string) {
  if file, err := os.Open(filename); err != nil {
    panic(err)
  } else {
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
      fmt.Println(scanner.Text())
    }
  }
}

省略结束条件-死循环

func forever() {
  for {
    fmt.Println("abc")
  }
}

条件与循环总结

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

函数

函数可以返回多个值，并且可以起名字

func div(a, b int) (q, r int) {
  q, r = a/b, a%b
  return q, r
}

函数可以作为参数传递

func apply(op func(int, int) int, a, b int) int {
  fmt.Println("Calling function %s with args "+
    "(%d,%d)", runtime.FuncForPC(reflect.ValueOf(op).Pointer()), a, b)
  return op(a, b)
}

匿名函数

  i2 := apply(func(a int, b int) int {
    return int(math.Pow(float64(a), float64(b)))
  }, a, b)

可变参数列表

func sumcan(numbers ...int) int {
  sum := 0
  for i := range numbers {
    sum += numbers[i]
  }
  return sum
}

函数总结

返回值类型写在最前面
可返回多个值
函数作为参数，
没有默认参数，没有可选参数，有可变参数
没有函数重载

指针

示例

  var a int = 2
  fmt.Println(a)
  var pa *int = &a
  fmt.Printf("*** before *** pa = %s, *pa = %d, &a = %s, a = %d.\n", pa, *pa, &a, a)
  *pa = 3
  fmt.Printf("*** after ***  pa = %s, *pa = %d, &a = %s, a = %d. \n", pa, *pa, &a, a)

输出：

2
*** before *** pa = %!s(*int=0xc00000a0c8), *pa = 2, &a = %!s(*int=0xc00000a0c8), a = 2.
*** after ***  pa = %!s(*int=0xc00000a0c8), *pa = 3, &a = %!s(*int=0xc00000a0c8), a = 3.

参数传递：Go语言只有值传递，没有引用传递

func swap(a, b int) {
  a, b = b, a
}
func swappointer(a, b *int) {
  *a, *b = *b, *a
}
func swapreturn(a, b int) (int, int) {
  return b, a
}
func main() {
  a, b := 3, 4
  fmt.Println(a, b)
  swap(a, b)
  fmt.Println(a, b)
  swappointer(&a, &b)
  fmt.Println(a, b)
  a, b = swapreturn(a, b)
  fmt.Println(a, b)
}

输出

后续小猿还会提供内建容器、面向对象、面向接口、函数式编程、资源管理和错误处理、测试与性能优化、channel等go语言基础文章，敬请期待~

更多精彩可以关注小猿的知乎~https://www.zhihu.com/people/wang-jun-96-9

更多精彩可以关注小猿的博客~https://blog.csdn.net/wby90

数据库

文章转载自隔壁王小猿，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

Go语言基本语法

评论