go入门

一.第一个程序

//每个go源码的开头都是package，表示所属的包
//main表示可编译成二进制文件
package main

//导入格式化包，不用时会报错
//不能使用单引号
import "fmt"

//main主函数入口，不能带参数，不能定义返回值
//func声明函数放入关键字
//其那边大阔号不能单起一行
func main(){
    fmt.Println("wocao go!")
    }

// go单行注释，与java和C++一样

/*
   多行注释
*/

 

二.基础语法

　　1.命名

• go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则
• 一个名字必须以一个字母或下划线开头，后面可以跟任意数量的字母、数字或下划线
• go区分大小写，hello Hello不同
• 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多个预定义的名字，用于内建的常量、类型和函数

内建常量:
    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.变量

　　　　变量的声明：

package main

import "fmt"

func main(){
    var a int
    var b int
    //一次性声明多个变量
    var(
        c int
        d int
    )
    //变量都会有一个初始0值
    fmt.Print(a,b,c,d)
}

//运行结果
//0 0 0 0
//变量都会初始值为0

　　　　变量的初始化：

package main

import (
    "fmt"
    "reflect"
)

func main()  {
    //声明并初始化
    var a int=10
    var b int=10
    // := 是声明并初始化
    c :=30

    //利用反射查看c的类型
    fmt.Print("c的类型是：",reflect.TypeOf(c))
    fmt.Print(a,b,c)

}

//结果
//c的类型是：int   10 10 30

　　　　　变量赋值：

package main

import "fmt"

func main() {
    //直接赋值
    var a int
    a = 10
    b := 20
    //多重赋值
    var c, d, e int
    c, d, e = 10, 20, 30

    fmt.Print(a, b,c,d,e)

}

//注意：声明的变量不调用会报错

　　　　 匿名变量

　　　　　　_代表特殊的变量名，作用是占位

package main

import "fmt"

//int，string为返回值类型
func test()(int,string){
    return 666,"我有大懒觉"
}

//调用并把返回值赋予——和s
func main(){
    _,s:=test()
    fmt.Print(s)
}

　　3.常量与枚举

   声明常量
   iota常量生成器
   枚举类型

 　　　　声明常量

package main

import "fmt"

//const声明常量
const filename="abc.txt"

func main(){
    fmt.Print(filename)
}

　　　　声明多个常量：

package main

import "fmt"

const filename = "cc.txt"

func constant(){
   //声明多个常量
   const(
      filename="dd.txt"
      a=1
      b=2
      c,d=3,4
   )
   //就近原则
   fmt.Print(a,b,c,d,filename)
}

func main()  {
   constant()
}

　　　　定义枚举类：

package main

func enum(){
    const(
        python=1
        java=2
        linux=3
    )
    print(python,java,linux)
}

func main(){
    enum()
}

　　　　iota生成器

package main

func enum(){
    const(
        python=iota
        java
        linux
    )
    print(python,java,linux)
}

func main(){
    enum()
}

//结果
//012

　　　　iota参与运算：

package main

func enum()  {
    const(
        //1<<0
        //1*2^0
        //位运算
        b=1<<(10*iota)
        kb
        mb
        gb
        tb
        pb
    )
    print(b,kb,mb,gb,tb,pb)
}

func main(){
    enum()
}

　　4.基本数据类型

 

　　整型：

package main

import (
    "reflect"
    "fmt"
)

func main(){
    var a int
    a=10
    b :=20
    print(a,b)
    //默认推断类型是int
    fmt.Println(reflect.TypeOf(b))
}

　　浮点型：

package main

import (
    "fmt"
    "reflect"
)

func main(){
    var f1 float32
    f1=12
    f2 :=12.0
    fmt.Println(f1)
    //默认推断64
    fmt.Println(reflect.TypeOf(f2))
}

　　布尔值：

package main

import (
    "fmt"
    "reflect"
)

func main(){
    var v1  bool
    v1=true
    v2 :=(1==2)
    fmt.Println(v1,v2)
    fmt.Println(reflect.TypeOf(v2))
}

　　　byets类型：

package main

import "fmt"

func main(){
    var ch byte
    ch='a'
    fmt.Println(ch)
    fmt.Printf("ch=%c",ch)
}

　　字符串：

package main

import "fmt"

func main(){
    var str string
    str="abc"
    fmt.Printf(str)
    fmt.Println()
    str2 :=`hello
        mike \n \r 测试
        `
    fmt.Println(str2)

 　　5.fmt包的使用

　　

　　

　　　　输出：

package main

import "fmt"

func main(){
    a :=15
    //%b是二进制转换  1111
    fmt.Printf("a=%b\n",a)

    //只输出%
    fmt.Printf("%%\n")

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

    //浮点
    f :=3.14
    //%g紧凑格式  f=3.140000,3.14
    fmt.Printf("f=%f,%g\n",f,f)


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



}

　　输入：

package main

import "fmt"

func main(){
    var v int
    fmt.Println("请输入数字：")
    fmt.Scan(&v)
    fmt.Println("v=",v)
}

 　　6.类名别名

package main

import (
    "fmt"
    "reflect"
)

func main(){
    //int取别名
    type myint int
    var i myint=100
    fmt.Println(reflect.TypeOf(i))
    //main.myint
}

 　　7.类型转换（go必须显示转换）

package main

import "fmt"

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

 　　8.运算符

　　　　算数运算符，假定 A 值为 10，B 值为 20。

　　

运算符	描述	实例
+	相加	A + B 输出结果 30
-	相减	A - B 输出结果 -10
*	相乘	A * B 输出结果 200
/	相除	B / A 输出结果 2
%	求余	B % A 输出结果 0
++	自增	A++ 输出结果 11
--	自减	A-- 输出结果 9

　　　　关系运算符：假定 A 值为 10，B 值为 20。

　　　　

运算符	描述	实例
==	检查两个值是否相等，如果相等返回 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

　　

 

　　　　逻辑运行算符：假定 A 值为 True，B 值为 False。

　　　　

运算符	描述	实例
&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。	(A && B) 为 False
||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。	(A || B) 为 True
!	逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。	!(A && B) 为 True