第一个go程序和基本语法

时间 2019-12-16

标签第一个程序基本语法繁體版

原文原文链接

目录java

第一个go程序和基本语法
- 一. 第一个go程序
- 二. 基础语法

第一个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; 是一个指针变量