package main
import (
    "syscall"
    "unsafe"
)
func main() {
    setTitle(`你好世界！`)
}
func setTitle(title string) {
    kernel32, _ := syscall.LoadLibrary(`kernel32.dll`)
    sct, _ := syscall.GetProcAddress(kernel32, `SetConsoleTitleW`)
    syscall.Syscall(sct, 1, uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))), 0, 0)
    syscall.FreeLibrary(kernel32)
}

//hunter.go
package main

import "fmt"

func main() {
//bool
var a bool

a = true
fmt.Printf("a = %d\n", a)
c := false
fmt.Printf("c = %d\n", c)
var f1 float32 = 3.14
fmt.Println("f1 = ", f1)
fmt.Printf("f1 = %T\n", f1)
//字符类型
var byte1 byte
byte1 = 97 //ascll码  大小写相差32 小写大
//格式化输出 %c以字符方式打印  %d以整形方式打印
fmt.Printf("byte1 = %c %d\n", byte1, byte1)
var rune1 rune = 'a'
fmt.Println("rune1 = ", rune1)
fmt.Printf("rune1 = %c\n", rune1)
fmt.Printf("rune1 = %T\n", rune1)
//字符串类型
var str1 string
str1 = "abc"
fmt.Println("str1 = ", str1)
//字符和字符串的区别
var ch byte
var str2 string
//字符
//1 单引号
//2 往往只有一个字符  转义字符除外
ch = 'a'
fmt.Println("ch = \n", ch)
//字符串
//1 双引号
//2 一个或者多个字符
//3 字符串都是隐藏了一个结束符  \0
str2 = "a"
fmt.Println("str2 = \n", str2)
str2 = "hello"
//可以从下标取其中一个字符
fmt.Printf("str2[2] = %c\n", str2[2])
//复数类型
var com1 complex128
com1 = 2.1 + 3.14i
fmt.Println("com1 = ", com1)
//一样可以自动推导
com2 := 2 + 1.1i
//通过内奸函数 取得  实部和虚部
fmt.Println("real(com2) = ", real(com2), ", imag

bool 初始值 false
byte
rune 字符类型 专门存储unicode编码

int uint 长度 4 、 8 32bit 和 64bit
int8 uint8 长度1
int16 uint16 长度2
int32 uint32 长度4
int64 uint64 长度8
float32 长度4 精度7位
float64 长度4 精度15位

complex64
complex128

package main
import "fmt"
func main() {
    //1、iota常量自动生成器 每隔一行 自动累加1
    //2、iota给常量赋值
    const (
        a = iota //0
        b = iota //1
        c = iota //2
    )
    fmt.Printf("a = %d,b = %d,c = %d\n", a, b, c)
    //3 iota 遇到const 就会重置为0
    const d = iota
    fmt.Printf("d = %d\n", d)
    //可以只写一个iota
    const (
        a1 = iota //0
        b1        //1
        c1        //2
    )
    fmt.Printf("a1 = %d,b1 = %d,c1 = %d\n", a1, b1, c1)
    //5  如果在同一行 值都一样
    const (
        i          = iota
        j1, j2, j3 = iota, iota, iota
        k          = iota
    )
    fmt.Printf("i = %d,j1 = %d,j2 = %d,j3 = %d\n,k = %d\n", i, j1, j2, j3, k)
}

package main

import "fmt"

func main() {
//不同类型变量的声明（定义）

//选中代码 按ctrl+、 注释和取消注释的快捷键
//var a int
//var b float64
//a,b = 10,3.14
//简便写法
var (
    a int     = 1
    b float64 = 1.34
)
fmt.Printf("a = ", a)
fmt.Printf("b = ", b)
//常量也可以
//  const(
//      a int = 1
//      b float64 = 1.34
//  )
//自动类型推导也可以
//  var(
//      a = 1
//      b = 1.34
//  )

}

package main

import "fmt"
func main() {
    //变量 程序运行期间 可以改变的量  变量声明需要var
    //常量 程序运行期间 不可以改变的量  常量声明需要const
    const a int = 2
    fmt.Println("a = ", a)
    // a = 3  赋值会导致错误
    //常量 赋值不允许使用:=
}

package main

import "fmt"

func main() {
//多重赋值
a, b := 1, 2

//交换变量的值 传统方法
var tmp int
tmp = a
a = b
b = tmp
fmt.Println("a,b", a, b)
//利用多重赋值 交换变量
i, j := 10, 20
i, j = j, i
fmt.Println("i,j", i, j)
//_匿名变量 丢弃数据 不处理
tmp, _ = i, j
fmt.Println("tmp =", tmp)
//_匿名变量配合返函数返回值使用 才有优势
_, y, _ := test()
fmt.Printf("y = ", y)

}

func test() (a, b, c int) {
return 1, 2, 3
}

package main

import "fmt"

func main() {
a := 233
//一段一段输出 自动换行
fmt.Println("a = ", a)

//格式化输出   把b的内容放在%d的位置
//\n自动换行
fmt.Println("a = %d\n", a)

}

package main
import "fmt"

func main() {
    //赋值前 必须声明变量
    var a int
    a = 10
    fmt.Println(a)
    //:=自动推导类型  等效于 先声明变量b 再给b赋值20
    //自动推导同一个变量名只能使用一次
    b := 20
    fmt.Println(b)
}

package main
import "fmt" //导入包之后 必须要使用  否则编译不通过
func main() {
    //1、声明变量的格式 var 变量名  数据类型      变量名必须使用  否则编译不通过
    //var 变量名  类型
    //没有初始化的变量，默认值为0
    //在同一个{}里生命的变量名是唯一的
    //也可以同事声明多变量
    var a int
    fmt.Println("a = ", a)
    //2、初始化变量
    var b int = 233 //初始化
    b = 666         //赋值
    fmt.Println(b)
    //3、自动推导类型  必须初始化 通过初始化的值确定类型
    c := 30
    //%T  打印变量所属的类型
    fmt.Printf("c type is %T", c)
    d := "interesting"
    fmt.Printf("      d type is ", d)
}

输出结果

a = 0
666
c type is int d type is %!(EXTRA string=interesting)