Category - Golang

2022-01-06 19:24:31    187    0    0
  1. package main
  2. import (
  3. "syscall"
  4. "unsafe"
  5. )
  6. func main() {
  7. setTitle(`你好世界!`)
  8. }
  9. func setTitle(title string) {
  10. kernel32, _ := syscall.LoadLibrary(`kernel32.dll`)
  11. sct, _ := syscall.GetProcAddress(kernel32, `SetConsoleTitleW`)
  12. syscall.Syscall(sct, 1, uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))), 0, 0)
  13. syscall.FreeLibrary(kernel32)
  14. }
2018-10-11 17:35:46    62    0    0

//hunter.go
package main

import "fmt"

func main() {
//bool
var a bool

  1. a = true
  2. fmt.Printf("a = %d\n", a)
  3. c := false
  4. fmt.Printf("c = %d\n", c)
  5. var f1 float32 = 3.14
  6. fmt.Println("f1 = ", f1)
  7. fmt.Printf("f1 = %T\n", f1)
  8. //字符类型
  9. var byte1 byte
  10. byte1 = 97 //ascll码 大小写相差32 小写大
  11. //格式化输出 %c以字符方式打印 %d以整形方式打印
  12. fmt.Printf("byte1 = %c %d\n", byte1, byte1)
  13. var rune1 rune = 'a'
  14. fmt.Println("rune1 = ", rune1)
  15. fmt.Printf("rune1 = %c\n", rune1)
  16. fmt.Printf("rune1 = %T\n", rune1)
  17. //字符串类型
  18. var str1 string
  19. str1 = "abc"
  20. fmt.Println("str1 = ", str1)
  21. //字符和字符串的区别
  22. var ch byte
  23. var str2 string
  24. //字符
  25. //1 单引号
  26. //2 往往只有一个字符 转义字符除外
  27. ch = 'a'
  28. fmt.Println("ch = \n", ch)
  29. //字符串
  30. //1 双引号
  31. //2 一个或者多个字符
  32. //3 字符串都是隐藏了一个结束符 \0
  33. str2 = "a"
  34. fmt.Println("str2 = \n", str2)
  35. str2 = "hello"
  36. //可以从下标取其中一个字符
  37. fmt.Printf("str2[2] = %c\n", str2[2])
  38. //复数类型
  39. var com1 complex128
  40. com1 = 2.1 + 3.14i
  41. fmt.Println("com1 = ", com1)
  42. //一样可以自动推导
  43. com2 := 2 + 1.1i
  44. //通过内奸函数 取得 实部和虚部
  45. fmt.Println("real(com2) = ", real(com2), ", imag
2018-10-11 17:35:46    44    0    0

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

2018-10-11 17:35:46    96    0    0
  1. package main
  2. import "fmt"
  3. func main() {
  4. //1、iota常量自动生成器 每隔一行 自动累加1
  5. //2、iota给常量赋值
  6. const (
  7. a = iota //0
  8. b = iota //1
  9. c = iota //2
  10. )
  11. fmt.Printf("a = %d,b = %d,c = %d\n", a, b, c)
  12. //3 iota 遇到const 就会重置为0
  13. const d = iota
  14. fmt.Printf("d = %d\n", d)
  15. //可以只写一个iota
  16. const (
  17. a1 = iota //0
  18. b1 //1
  19. c1 //2
  20. )
  21. fmt.Printf("a1 = %d,b1 = %d,c1 = %d\n", a1, b1, c1)
  22. //5 如果在同一行 值都一样
  23. const (
  24. i = iota
  25. j1, j2, j3 = iota, iota, iota
  26. k = iota
  27. )
  28. fmt.Printf("i = %d,j1 = %d,j2 = %d,j3 = %d\n,k = %d\n", i, j1, j2, j3, k)
  29. }
2018-10-11 17:35:46    58    0    0

package main

import "fmt"

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

  1. //选中代码 按ctrl+、 注释和取消注释的快捷键
  2. //var a int
  3. //var b float64
  4. //a,b = 10,3.14
  5. //简便写法
  6. var (
  7. a int = 1
  8. b float64 = 1.34
  9. )
  10. fmt.Printf("a = ", a)
  11. fmt.Printf("b = ", b)
  12. //常量也可以
  13. // const(
  14. // a int = 1
  15. // b float64 = 1.34
  16. // )
  17. //自动类型推导也可以
  18. // var(
  19. // a = 1
  20. // b = 1.34
  21. // )

}

2018-10-11 17:35:46    82    0    0

package main

  1. import "fmt"
  2. func main() {
  3. //变量 程序运行期间 可以改变的量 变量声明需要var
  4. //常量 程序运行期间 不可以改变的量 常量声明需要const
  5. const a int = 2
  6. fmt.Println("a = ", a)
  7. // a = 3 赋值会导致错误
  8. //常量 赋值不允许使用:=
  9. }
2018-10-11 17:35:46    73    0    0

package main

import "fmt"

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

  1. //交换变量的值 传统方法
  2. var tmp int
  3. tmp = a
  4. a = b
  5. b = tmp
  6. fmt.Println("a,b", a, b)
  7. //利用多重赋值 交换变量
  8. i, j := 10, 20
  9. i, j = j, i
  10. fmt.Println("i,j", i, j)
  11. //_匿名变量 丢弃数据 不处理
  12. tmp, _ = i, j
  13. fmt.Println("tmp =", tmp)
  14. //_匿名变量配合返函数返回值使用 才有优势
  15. _, y, _ := test()
  16. fmt.Printf("y = ", y)

}

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

2018-10-11 17:35:46    57    0    0

package main

import "fmt"

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

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

}

2018-10-11 17:35:46    34    0    0

package main
import "fmt"

  1. func main() {
  2. //赋值前 必须声明变量
  3. var a int
  4. a = 10
  5. fmt.Println(a)
  6. //:=自动推导类型 等效于 先声明变量b 再给b赋值20
  7. //自动推导同一个变量名只能使用一次
  8. b := 20
  9. fmt.Println(b)
  10. }
2018-10-11 17:35:46    30    0    0
  1. package main
  2. import "fmt" //导入包之后 必须要使用 否则编译不通过
  3. func main() {
  4. //1、声明变量的格式 var 变量名 数据类型 变量名必须使用 否则编译不通过
  5. //var 变量名 类型
  6. //没有初始化的变量,默认值为0
  7. //在同一个{}里生命的变量名是唯一的
  8. //也可以同事声明多变量
  9. var a int
  10. fmt.Println("a = ", a)
  11. //2、初始化变量
  12. var b int = 233 //初始化
  13. b = 666 //赋值
  14. fmt.Println(b)
  15. //3、自动推导类型 必须初始化 通过初始化的值确定类型
  16. c := 30
  17. //%T 打印变量所属的类型
  18. fmt.Printf("c type is %T", c)
  19. d := "interesting"
  20. fmt.Printf(" d type is ", d)
  21. }

输出结果

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

1/2