「Golang成长之路」基础语法

一、变量定义

Golang的变量定义相比c/c++，其最为特殊之处在于c/c++是将变量类型放在变量的前面，而Go语言则是将变量类型放在变量的后面，如下：
这是c/c++:

#include <iostream>
using namespace std

int main(){
int a;
int b;
float c;
}

Go语言变量定义：

package main
import "fmt"
//求和
func add(k int , y int ){
   var a int
   var b int 
   a = k + y
   b = k - y
   fmt.Println(a)
   fmt.Println(a)

二、Golang的内建变量类型

• Go语言和其他编程一样，都有内建变量类型

1. (u)int型

   (u)int,(u)int8, (u)int16, (u)int32, (u)int64

2. float型

   float32, float64 //不能只是用float,在go语言中，不存在单独的float

3. string型
   在go中string和其他语言一样

   package main
   import "fmt"
   func main(){
        var a string = "abcdefg"
        fmt.Print(a)
   }

   输出如下：

   abcdefg

4. bool型
   对于bool来说，go中没有什么不同的，和其他编程语言一样，只有true和false

5. rune
   rune在其他编程语言中叫char——字符型；其长度为32位。

6. complex
   分为两类：

   complex64, complex128

7. byte

• 类型转换
  类型转换就是将一种类型装换为另一种类型，如：

  package main
  import ("fmt"
          "math"
         )
  func exchange(g1 int ,g2 int ){
     var x  int
     x = int(math.Sqrt(float64(g1 * g1 + g2 * g2))) //这里开根号一定是浮点数 需要将float64(g1 * g1 + g2 * g2)转换为float类型，又因为x在定义是为 int 类型，所以又需要将最后转换为int类型
     fmt.Print(x)
  }

  最后输出：

  5

三、常量与枚举

1. 常量
   说完变量 来说说常量，如下：

   package main
   import ("fmt"
        "math"
        )
   func consts(){
   const (
      filename = "abc.txt"
          a, b = 3, 4
   )
   var c int 
   c = int(math.Sqrt((3*3 + 4*4)))
   fmt.Print(c)
   fmt.Print("\n")
   fmt.Print(filename,c)
   }
   func main(){
     consts()
   }

   输出：

   5
   abc.txt  5

2. 枚举

   package main
   import "fmt"
   func consts(){
   const (
      cpp = 0
      java = 1
      python = 2
      golang = 3
   )
   fmt.Print(cpp, java, python, golang)
   }
   func main(){
       consts()
   }

   输出：

   0 1 2 3

   在Golang中可以使用iota来实现自增：

   package main
   import "fmt"
   //枚举自增
   func enums(){
      const(
      cpp = iota
      java
      python 
      golang  
      )
   fmt.Print(cpp, java, python, golang)
   }
   func main(){
        enums()
   }

   输出：

   0 1 2 3

四、条件语句

1. if语句

   var x int = 59  //对于Go语言变量定义也可是：x := 59 可以不对类型进行划分
   if x < 60 {  //x < 60 为true；x >= 60 为false
    fmt.Print("不及格")
   }

2. if - else语句

   const filename = "abc1.txt"
   pass, err  := ioutil.ReadFile(filename) //pass接受filename信息，err接受出错信息，如果读取正常则err == nil
   if err != nil {
       fmt.Println(err)
   } else {
       fmt.Printf("%s\n",pass)
   }

3. switch语句
   在Go语言中每一个case下是不需要break的，它会自动的结束。

   func evel1(a,b int , op string) int {
      switch op{
       case "+":
          return a+b
       case "-":
          return a-b
       case "*":
          return a*b
       case "/":
          return a/b
       default:
          return 0
   }
   }

五、循环语句

在Go中循环语句最不同的就是没有while循环,对于Go语言，只是用for循环就够用了。

1. for死循环

   for{  //不使用如何条件，就是死循环
     fmt.Print("Golang")
   }

2. while循环的取代
   前面说过go没有while，其实只需要使用for循环就可以实现while

   //没有起始条件和递增条件，就是while循环
   for i < 10 {
     fmt.Print("Golang")
   }

3. for循环

   //求100的阶乘
   func add2() int {
     var sum int = 0
     for i := 0; i <= 100; i++{
         sum = sum + i
     }
     return sum
   }

   sum = 5050

六、函数

在前面的内容中，其实就已经出现函数了，在Go中函数的返回值可以有多个，函数在定义是是将返回类型放在函数名的后面。定义函数是需要使用关键字func。

1. 函数的返回类型放在函数名的后面

   //求100的阶乘
   func add2() int {  //将int放在函数名之后
   var sum int = 0
   for i := 0; i <= 100; i++{
      sum = sum + i
   }
   return sum
   }

2. Go函数可以有多个返回值

   //交换数值函数
   func sawp(a, b int ) (int,int ){  //返回两个int类型的值
      return b ,a
   }

   又如：

   //求商，求余
   func div(a, b int) (int, int){
      return a/b ,a%b
   }

3. 函数的另一种求和

   package main
   import "fmt"
   func sum(numbers ...int) int{
      s:= 0
      for i := range numbers{
          s += numbers[i]
      }
      return s
   }
   func main(){
        fmt.Print(sum(0, 1, 2, 3, 4, 5))
   }

   输出：

   15

七、指针

在Go语言中指针并没有像c/c++中那么麻烦
指针：一个指针变量指向了一个值的内存地址。（也就是我们声明了一个指针之后，可以像变量赋值一样，把一个值的内存地址放入到指针当中。）类似于变量和常量。
下面来看一个下例子：

package main
import "fmt"
//go指针
func pointer() {
   var a int = 5
   var pa* int
   pa = &a
   *pa = 1
   fmt.Println(a)
   }
func main(){
     pointer()
  }

输出：

1

Golang函数的传参方式：

1. 值传递：
   使用普通变量作为函数参数的时候，在传递参数时只是对变量值得拷贝，即将实参的值复制给变参，当函数对变参进行处理时，并不会影响原来实参的值。

   package main
   import (
    "fmt"
   )
   func swap(a int, b int) {
      var temp int
      temp = a
      a = b
      b = temp
   }
   func main() {
    x := 5
    y := 10
    swap(x, y)
    fmt.Print(x, y)
   }

   输出结果：

   5 10

   传递给swap的是x，y的值得拷贝，函数对拷贝的值做了交换，但却没有改变x,y的值。

2. 指针传递

   函数的变量不仅可以使用普通变量，还可以使用指针变量，使用指针变量作为函数的参数时，在进行参数传递时将是一个地址拷贝，即将实参的内存地址复制给变参，这时对变参的修改也将会影响到实参的值。

   package main
   import (
    "fmt"
   )
   func swap(a *int, b *int) {
      var temp int
      temp = *a
      *a = *b
      *b = temp
   }
   func main() {
        x := 5
        y := 10
        swap(&x, &y)
        fmt.Print(x, y)
   }

   输出结果：

   10 5

本作品采用《CC 协议》，转载必须注明作者和本文链接