第一個go程序和基本語法

時間  2019-12-16
標籤 第一個 程序 基本 語法 简体版
原文   原文鏈接

目錄java

第一個go程序和基本語法

一. 第一個go程序

//package 聲明開頭表示代碼所屬包
package main

//導入格式化包,引了必須用
import "fmt"

//左括號{不能單起一行
func main(){
    fmt.Println("Go Lang, 開始浪吧~")
}

//  "//"表示單行註釋
//  "*/ */"表示多行註釋

二. 基礎語法

1. 命名

  • go語言中的函數名、變量名、常量名、類型名、語句標號和包名等全部的命名，都遵循一個簡單的命名規則python

  • 一個名字必須以一個字母或下劃線開頭，後面能夠跟任意數量的字母、數字或下劃線golang

  • go區分大小寫，hello和Hello不同app

  • go語言中有25個關鍵字，不能用於自定義名字函數

    break        default          func           interface         select
  case         defer            go             map               struct
  chan         else             goto           package           switch
  const        fallthrough      if             range             type
  continue     for              import         return            var

  • 還有30多個預約義的名字，用於內建的常量、類型和函數ui

    內建常量:
    true false iota nil

內建類型:
    int int8 int16 int32 int64
    uint uint8 uint16 uint32 uint64 uintptr
    float32 float64 complex128 complex64
    bool byte rune string error

內建函數:
    make len cap new append copy close delete
    complex real imag
    panic recover

2. 變量

2.1 聲明變量:指針

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

func main() {
    //第一種:
    var v1 int
    var v2 int

    //第二種:
    var v3, v4 int

    //第三種
    var(
        v5 int
        v6 int
    )

    //零值
    fmt.Println(v1, v2, v3, v4, v5, v6)

}

2.2 變量初始化code

//package 聲明開頭表示代碼所屬包
package main

import (
    "fmt"
    "reflect"
)

func main() {
    //方式一:
    var v1 int = 10

    //方式二:go編譯器自動推到出變量類型
    var v2 = 20

    //方式三:聲明加賦值, 必須在函數裏面用
    v3 := 30

    fmt.Println(v1, v2, v3)

    //利用反射查看變量類型
    fmt.Println("v3的類型是", reflect.TypeOf(v3))
}



//10 20 30  
//v3的類型是 int

2.3 變量賦值字符串

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

func main() {
    //1. 直接賦值
    var v1 int
    v1 = 123

    //2. 聲明並賦值
    i := 10
    j :=20

    //3. 多重賦值
    var v2, v3, v4 int
    v2, v3, v4 = 1, 2, 3
    
    fmt.Println(v1, v2, v3, v4, i, j)
}

匿名變量:編譯器

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

//(int, sting): 返回值類型
func test()(int, string){
    return 666,"浪不浪"
}


func main() {
    // "_"是特殊變量, 佔位
    _, s1 := test()
    fmt.Println(s1)

    a1, s1 := test()
    fmt.Println(a1,s1)
}


//浪不浪
//666 浪不浪

.

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

var abc = 456

func main() {
    //定義
    var a int
    var s string
    fmt.Println(a,s)
    
    fmt.Printf("%d %q\n", a,s)

    //定義多個
    var c,b int = 3,4
    fmt.Println(c,b)

    //不指定類型定義, 能夠寫一行
    j,k,q :=3,true,"xx"
    fmt.Println(j,k,q)
}


//0 
//0 ""
//3 4
//3 true xx

3 常量與枚舉

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

//常量 const
const filename = "luhan.txt"

////常量必須是可肯定的數字, 字符串, 布爾值
//var a = "haha"
//const file2  = a

//定義函數, 函數內寫常量
func consts() {
    //多個常量
    const (
        XX       = "haha1"
        OO       = "haha2"
        filename = "haha3"
    )
    fmt.Println(XX, OO, filename)
}

//1. 定義枚舉類型
func enums() {
    const (
        python = 0
        java   = 1
        golang = 2
    )
    fmt.Println(python, java, golang)
}

//2. 自增的枚舉類型
func enums1() {
    const (
        //iota關鍵字是自增
        pyhton = iota
        java
        golang
    )
    fmt.Println(pyhton, java, golang)
}

//3. iota還能夠參與計算
func enums2() {
    const (
        //位運算, n*2(10*1), 2^0 = 1
        b  = 1 << (10 * iota)
        kb
        mb
        gb
        tb
        pb
    )
    fmt.Println(b, kb, mb, gb, tb, pb )
}

func main() {
    consts()
    enums1()
    enums2()
}


//haha1 haha2 haha3
//0 1 2
//1 1024 1048576 1073741824 1099511627776 1125899906842624

4. 數據類型

  • u開頭是無符號類型
  • 8，16，32這些，最大最用是增長可移植性和維護性

  • short int long

    類型名稱    有無符號    bit數
int8    Yes 8
int16   Yes 16
int32   Yes 32
int64   Yes 64
uint8   No  8
uint16  No  16
uint32  No  32
uint64  No  64
int Yes 等於cpu位數
uint    No  等於cpu位數
rune    Yes 與 int32 等價
byte    No  與 uint8 等價
uintptr No  -

.

//package 聲明開頭表示代碼所屬包
package main

import (
    "fmt"
    "reflect"
)

func main() {
    //1.整型
    var v1  int32
    v1 = 123
    v2 := 64
    fmt.Println(v1,v2)
    //默認是int
    fmt.Println(reflect.TypeOf(v2))

    //2.浮點型
    var f1 float32
    f1 = 12
    fmt.Println(f1)
    f2 := 12.0
    fmt.Println(reflect.TypeOf(f2))

    //3.布爾型
    var b1 bool
    b1 = true
    fmt.Println(b1)
    b2 := (1==2)
    //打印類型
    fmt.Println(reflect.TypeOf(b2))

    //4.字符型
    var ch byte
    ch = 'a'
    fmt.Println(ch)
    fmt.Printf("ch = %c",ch)

    //5.字符串
    var str  string
    str = "luhan"
    s := str[0]
    fmt.Println(s)
    //反括號圈起來的字符串，原樣輸出
    str2 := `hello
    luhan \n \r xx
   `
    fmt.Println("str2=",str2)
}


//123 64
//int
//12
//float64
//true
//bool
//97
//ch = a108
//str2= hello
//luhan \n \r xx

5. fmt包的使用

輸出:

//package 聲明開頭表示代碼所屬包
package main

import "fmt"


func main() {
    //整型
    a := 15
    //%b：二進制
    fmt.Printf("a = %b\n",a)
    //只輸出一個%
    fmt.Printf("%%\n")

    //字符
    ch := 'a'
    fmt.Printf("ch = %c,%d\n",ch,97)

    //浮點
    f := 3.14
    //%g緊湊方式輸出
    fmt.Printf("f = %f,%g\n",f,f)

    //布爾型
    fmt.Printf("%t,%t\n",true,false)

    //字符串
    str := "hello.go"
    fmt.Printf("str = %s\n",str)
}

//a = 1111
//%
//ch = a,97
//f = 3.140000,3.14
//true,false
//str = hello.go

輸入:

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

func main() {
    //用戶輸入內容, 程序接收
    var v int

    //Print是不回車
    fmt.Print("請輸入一個整型:")

    //直接輸入
    //若是不是int，輸出零值
    fmt.Scan(&v)
    fmt.Println(v)
}

//請輸入一個整型:5
//5

6. 類型別名

//package 聲明開頭表示代碼所屬包
package main

import (
    "fmt"
    "reflect"
)

func main() {
    //type關鍵字定義別名
    type myint int
    var i myint = 100
    fmt.Println(i)
    fmt.Println(reflect.TypeOf(i))
}

//100
//main.myint

7. 類型轉換

go類型轉換不容許隱式轉換

//package 聲明開頭表示代碼所屬包
package main

import "fmt"

func main() {
    var ch byte = 'a'
    var i int = int(ch)
    fmt.Println(ch)
    fmt.Println(i)
}

//97
//97

8. 運算符

  • 算術運算符

    +   相加  A + B 輸出結果 30
  -   相減  A - B 輸出結果 -10
  *   相乘  A * B 輸出結果 200
  /   相除  B / A 輸出結果 2
  %   求餘  B % A 輸出結果 0
  ++  自增  A++ 輸出結果 11
  --  自減  A-- 輸出結果 9

  • 關係運算符

    ==  檢查兩個值是否相等，若是相等返回 True 不然返回 False。   (A == B) 爲 False
  !=  檢查兩個值是否不相等，若是不相等返回 True 不然返回 False。 (A != B) 爲 True
  >   檢查左邊值是否大於右邊值，若是是返回 True 不然返回 False。 (A > B) 爲 False
  <   檢查左邊值是否小於右邊值，若是是返回 True 不然返回 False。 (A < B) 爲 True
  >=  檢查左邊值是否大於等於右邊值，若是是返回 True 不然返回 False。   (A >= B) 爲 False
  <=  檢查左邊值是否小於等於右邊值，若是是返回 True 不然返回 False。   (A <= B) 爲 True

  • 邏輯運算符

    &&  邏輯 AND 運算符。 若是兩邊的操做數都是 True，則條件 True，不然爲 False。 (A && B) 爲 False
  ||  邏輯 OR 運算符。 若是兩邊的操做數有一個 True，則條件 True，不然爲 False。 (A || B) 爲 True
  !   邏輯 NOT 運算符。 若是條件爲 True，則邏輯 NOT 條件 False，不然爲 True。   !(A && B) 爲 True

  • 位運算符

    &   按位與運算符"&"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相與。  (A & B) 結果爲 12, 二進制爲 0000 1100
  |   按位或運算符"|"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相或   (A | B) 結果爲 61, 二進制爲 0011 1101
  ^   按位異或運算符"^"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果爲1。   (A ^ B) 結果爲 49, 二進制爲 0011 0001
  <<  左移運算符"<<"是雙目運算符。左移n位就是乘以2的n次方。 其功能把"<<"左邊的運算數的各二進位所有左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。   A << 2 結果爲 240 ，二進制爲 1111 0000
  >>  右移運算符">>"是雙目運算符。右移n位就是除以2的n次方。 其功能是把">>"左邊的運算數的各二進位所有右移若干位，">>"右邊的數指定移動的位數。 A >> 2 結果爲

  • 賦值運算符

    =   簡單的賦值運算符，將一個表達式的值賦給一個左值 C = A + B 將 A + B 表達式結果賦值給 C
  +=  相加後再賦值  C += A 等於 C = C + A
  -=  相減後再賦值  C -= A 等於 C = C - A
  *=  相乘後再賦值  C *= A 等於 C = C * A
  /=  相除後再賦值  C /= A 等於 C = C / A
  %=  求餘後再賦值  C %= A 等於 C = C % A
  <<= 左移後賦值   C <<= 2 等於 C = C << 2
  >>= 右移後賦值   C >>= 2 等於 C = C >> 2
  &=  按位與後賦值  C &= 2 等於 C = C & 2
  ^=  按位異或後賦值 C ^= 2 等於 C = C ^ 2
  |=  按位或後賦值  C |= 2 等於 C = C | 2

  • 其餘

    &   返回變量存儲地址    &a; 將給出變量的實際地址。
  *   指針變量。   *a; 是一個指針變量
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程