一、变量定义

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 intvar 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

1. float型

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

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

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

1. 输出如下：

复制
abcdefg

1. bool型
2. 对于bool来说，go中没有什么不同的，和其他编程语言一样，只有true和false
3. rune
4. rune在其他编程语言中叫char——字符型；其长度为32位。
5. complex
6. 分为两类：

复制
complex64, complex128

1. 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. 常量
2. 说完变量 来说说常量，如下：

复制
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()
}

1. 输出：

复制
5
abc.txt  5

1. 枚举

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

1. 输出：

复制
0 1 2 3

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

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

1. 输出：

复制
0 1 2 3

四、条件语句

1. if语句

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

1. 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)
}

1. switch语句
2. 在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")
}

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

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

1. for循环

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

1. 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
}

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

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

1. 又如：

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

1. 函数的另一种求和

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

1. 输出：

复制
15

七、指针

在Go语言中指针并没有像c/c++中那么麻烦

指针：一个指针变量指向了一个值的内存地址。（也就是我们声明了一个指针之后，可以像变量赋值一样，把一个值的内存地址放入到指针当中。）类似于变量和常量。

下面来看一个下例子：

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

输出：

复制
1

Golang函数的传参方式：

1. 值传递：
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 := 10swap(x, y)
  fmt.Print(x, y)
}

1. 输出结果：

复制
5 10

1. 传递给swap的是x，y的值得拷贝，函数对拷贝的值做了交换，但却没有改变x,y的值。
2. 指针传递
3. 函数的变量不仅可以使用普通变量，还可以使用指针变量，使用指针变量作为函数的参数时，在进行参数传递时将是一个地址拷贝，即将实参的内存地址复制给变参，这时对变参的修改也将会影响到实参的值。

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

1. 输出结果：

复制
10 5