package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部，complex64 的实部和虚部为 32 位，complex128 的实部和虚部为 64 位。

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}

Go 语言中要定义一个多行字符串时，就必须使用反引号字符：
s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

#判断map中键是否存在的特殊写法，格式如下:
value, ok := map[key]
如果key存在ok为true,value为对应的值；不存在ok为false,value为值类型的零值

type student struct{
Name string `json:"name"`
}
使用 tag 可以让结构体内数据在返回 json 时以小写出现

#初始化
##无缓冲通道
chan01:=make(chan string)
##有缓冲通道
make(chan int,3)（容量为3）
#单向通道
<-chan string 只接受，不发送
chan <- int 只发送，不接受

package main

import "fmt"

func main() {
str := "Hello,世界"
//utf-8遍历
for i := 0; i < len(str); i++ {
 ch := str[i]
 fmt.Println(ch)
}
fmt.Println("=============>Unicode遍历")
//Unicode遍历
for _, ch1 := range str {
 fmt.Println(ch1)
}
}

package packageName
其中：
package：声明包的关键字
packagename：包名，不能包含 - 符号，最好与其实现的功能相对应。
一个文件夹下面直接包含的文件只能归属一个包，同一个包的文件不能在多个文件夹下。
main包是应用程序的入口包，这种包编译后会得到一个可执行文件，而编译不包含main包的源代码则不会得到可执行文件。

scanf：
按照给定的格式依次读取数据（包括非法数据），不能换行输入;
如果要换行需要在前面加一个scanln吸收掉回车符，就像c语言中的getchar
scan：
比scanf高级，依次读取数据，遇到回车会忽略，可以换行输入;
如果要先用了scan输入，再用scanf输入的话，需要在中间加一个scanln
scanln：
类似scan，但是遇到换行（回车）立马结束输入，如果要换行输入必须用多个scanln

var choice byte
fmt.Scanf("%c",&choice)
在第二次循环时，该输入语句会被直接跳过

进行测试后发现
0
unexpected newline

判断是将换行符当作字符读取了
可能是由于在缓冲区中仍存在上一次输入留下的换行符（\n）
可以在语句中加上换行符
fmt.Scanf("%c \n",&choice)

//获取秒级时间戳
time.Now().Unix()
//获取毫秒级时间戳
time.Now().UnixNano()/1e6
// 纳秒级时间戳
fmt.Println(now.UnixNano())
// 时间戳小数部分 单位：纳秒
fmt.Println(now.Nanosecond())
//格式化时间
time.Now().Format("2006-01-02 15:04")
//字符串转时间格式
t, err := time.Parse("2006-01-02 15:04:05", "2019-05-20 18:30:50")
//时间戳转为字符串
t := time.Unix("1558348250", 0).Format("2006-01-02 15:04")

字符串转换为整型：
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func Atoi(s string) (i int, err error)
Atoi内部调用ParseInt(s,10,0)实现
参数 base 代表字符串按照给定的进制进行解释，一般base 的取值为 2~36。
如果 base 的值为 0，则会根据字符串的前缀来确定 base 的值：
"0x" 表示 16 进制； "0" 表示 8 进制；否则就是 10 进制。
参数 bitSize 表示的是整数取值范围，或者说整数的具体类型。
取值 0、8、16、32 和 64 分别代表 int、int8、int16、int32 和 int64。
i 则表示bitSize 能够表示的最大或最小值

整数转字符串：
func FormatUint(i uint64, base int) string 无符号整型转字符串
func FormatInt(i int64, base int) string  有符号整型转字符串
func Itoa(i int) string
Itoa 内部直接调用 FormatInt(i, 10) 实现的。
base 参数可以取 2~36（0-9，a-z）。

整数转为字符数组
func AppendInt(dst []byte, i int64, base int) []byte
func AppendUint(dst []byte, i uint64, base int) []byte
将整数转为字符数组 append 到目标字符数组中

字符串转bool：
func ParseBool(str string) (value bool, err error)
接受 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False 等字符串；
其他形式的字符串会返回错误
func FormatBool(b bool) string
直接返回 "true" 或 "false"
func AppendBool(dst []byte, b bool)
将 "true" 或 "false" append 到 dst 中
这里用了一个 append 函数对于字符串的特殊形式：append(dst, "true"...)

字符串和浮点：
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
FormatFloat 将浮点数 f 转换为字符串形式
f：要转换的浮点数
fmt：格式标记（b、e、E、f、g、G）
prec：精度（数字部分的长度，不包括指数部分）
bitSize：指定浮点类型（32:float32、64:float64），结果会据此进行舍入。

格式标记：
'b' (-ddddp±ddd，二进制指数)
'e' (-d.dddde±dd，十进制指数)
'E' (-d.ddddE±dd，十进制指数)
'f' (-ddd.dddd，没有指数)
'g' ('e':大指数，'f':其它情况)
'G' ('E':大指数，'f':其它情况)

如果格式标记为 'e'，'E'和'f'，则 prec 表示小数点后的数字位数
如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）
参考格式化输入输出中的旗标和精度说明



func ParseFloat(s string, bitSize int) (float64, error)
将字符串解析为浮点数，使用 IEEE754 规范进行舍入。
bigSize 取值有 32 和 64 两种，表示转换结果的精度。
如果有语法错误，则 err.Error = ErrSyntax
如果结果超出范围，则返回 ±Inf，err.Error = ErrRange

func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int)

os.Open()以只读方式打开文件
os.Close()

<1>read
<2>bufio    

os.Openfile()
file, err := os.OpenFile("xx.txt", os.O_CREATEos.O_WRONLY, 0666)

<1>Write/WriteString
<2>bufio.NewWriter

url(Uniform Resource Locator)统一资源定位符，由一串简单文本字符组成。
Url结构：Scheme://Login:password@Address:port/path/to/resource?query_string#fragment
Scheme: 协议，如http,https,ftp等
Login:password@: 身份验证
Address: 服务器地址
Port: 服务器端口
/path/to/resource: 文件路径
?query_string: 查询字符串
#fragment: 片段ID，如http页面中内部的标签
"https://xiaoming:123456@www.example.com:8080/resource/level/next?file=got.rar&timestamp=123432#temp"

type Request struct {
 Method string// 请求方法
 URL *url.URL// 请求地址
 Proto      string // 协议版本 "HTTP/1.0"
 ProtoMajor int    // 1 协议主版本
 ProtoMinor int    // 0 协议次版本
 Header Header// 请求头
 Body io.ReadCloser// 请求体
 GetBody func() (io.ReadCloser, error)// 获取请求体
 ContentLength int64// 内容长度
 TransferEncoding []string// 传输编码
 Close bool// 连接是否关闭
 Host string// 服务器主机地址
 Form url.Values// GET表单
 PostForm url.Values// POST表单
 MultipartForm *multipart.Form// 上传表单
 Trailer Header
 RemoteAddr string// 远程客户端地址
 RequestURI string// 请求URI
 TLS *tls.ConnectionState// HTTPS
 Cancel <-chan struct{}
 Response *Response// 响应
 ctx context.Context// 上下文对象
}

func main() {
 //注册路由
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Printf("Proto: %+v\n", r.Proto)
  fmt.Printf("ProtoMajor: %+v\n", r.ProtoMajor)
  fmt.Printf("ProtoMinor: %+v\n", r.ProtoMinor)
  fmt.Printf("URL: %+v\n", r.URL)
  fmt.Printf("RequestURI: %+v\n", r.RequestURI)
  fmt.Printf("RemoteAddr: %+v\n", r.RemoteAddr)
  fmt.Printf("Host: %+v\n", r.Host)
  fmt.Printf("Method: %+v\n", r.Method)
  fmt.Printf("ContentLength: %+v\n", r.ContentLength)
 })
 //监听端口接收连接
 if err := http.ListenAndServe(":8900", nil); err != nil {
  panic(err)
 }
}

Proto: HTTP/1.1
ProtoMajor: 1
ProtoMinor: 1
URL: /
RequestURI: /
RemoteAddr: 127.0.0.1:8110
Host: 127.0.0.1:8900
Method: GET
ContentLength: 0

type Header map[string][]string

func (h Header) Get(key string) string {
 return textproto.MIMEHeader(h).Get(key)
}

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
str := r.Header.Get("User-Agent")
w.Write([]byte(str))
})
http.ListenAndServe(":8080", nil)
output:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.