「Golang成長之路」基礎語法篇

yangkuang發表於2021-05-30
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 協議》，轉載必須註明作者和本文連結

相關文章