golang常用方法积累

  • 日志记录
  • HTTP请求
  • 字符处理
    • strings库
  • 正则匹配
  • 类型定义
    • 不定参数类型定义
    • var
    • const
    • map
      • map转json
    • json
    • type
    • json性能优化
  • 关键字
    • go
    • defer
    • break
    • continue
    • goto
  • 时间处理

日志记录

  • log日志包

学习自:https://www.jianshu.com/p/d634316a9487

func main() {log.Println("helloworld:","https://blog.csdn.net/weixin_43819222")log.Printf("helloworld：%s\n","https://blog.csdn.net/weixin_43819222")
}

Println与Printf的区别：
1.Println:可以打印出字符串，和变量
2.Printf:只可以打印出格式化的字符串,可以输出字符串类型的变量，不可以输出整形变量和整形
3.Sprintf：用传入的格式化规则符将传入的变量格式化，(终端中不会有显示)，返回为 格式化后的字符串(常用于赋值)

  • 定制抬头信息
func init(){log.SetFlags(log.Ldate|Lshortfile)
}
///
选项常量
const (Ldate         = 1 << iota     //日期示例： 2009/01/23Ltime                         //时间示例: 01:23:23Lmicroseconds                 //毫秒示例: 01:23:23.123123.Llongfile                     //绝对路径和行号: /a/b/c/d.go:23Lshortfile                    //文件和行号: d.go:23.LUTC                          //日期时间转为0时区的LstdFlags     = Ldate | Ltime //Go提供的标准抬头信息
)

设置日志前缀
func init(){log.SetPrefix("【duanyiwen】")log.SetFlags(log.LstdFlags | log.Lshortfile |log.LUTC)
}
///
【duanyiwen】2017/04/29 05:53:26 main.go:11: helloworld: https://blog.csdn.net/weixin_43819222
【duanyiwen】2017/04/29 05:53:26 main.go:12: helloworld：duanyiwen
  • 定制日志
var (Info *log.LoggerWarning *log.LoggerError * log.Logger
)
将ERROR级输出到文本
func init(){errFile,err:=os.OpenFile("errors.log",os.O_CREATE|os.O_WRONLY|os.O_APPEND,0666)if err!=nil{log.Fatalln("打开日志文件失败：",err)}Info = log.New(os.Stdout,"Info:",log.Ldate | log.Ltime | log.Lshortfile)Warning = log.New(os.Stdout,"Warning:",log.Ldate | log.Ltime | log.Lshortfile)Error = log.New(io.MultiWriter(os.Stderr,errFile),"Error:",log.Ldate | log.Ltime | log.Lshortfile)
}
全部归到文本
LogFile,err:=os.OpenFile("duanyiwen.log",os.O_CREATE|os.O_WRONLY|os.O_APPEND,0666)
Info = log.New(io.MultiWriter(os.Stderr,LogFile),"Info:",log.Ldate | log.Ltime | log.Lshortfile)
Warning = log.New(io.MultiWriter(os.Stderr,LogFile),"Warning:",log.Ldate | log.Ltime | log.Lshortfile)
Error = log.New(io.MultiWriter(os.Stderr,LogFile),"Error:",log.Ldate | log.Ltime | log.Lshortfile)

HTTP请求

学习:https://www.cnblogs.com/Paul-watermelon/p/11386392.html

  • Get请求
package main
import ("fmt","io/ioutil","net/http"
)func main() {resp, err := http.Get("http://baidu.com")if err != nil {fmt.Println(err)return}defer resp.Body.Close()body, err := ioutil.ReadAll(resp.Body)fmt.Println(string(body))fmt.Println(resp.StatusCode)if resp.StatusCode == 200 {fmt.Println("ok")}
}
  • Get变量入参
package mainimport ("fmt""io/ioutil""net/http""net/url"
)func main() {params := url.Values()Url, err := url.Parse("http://baidu.com")if err != nil {return}params.Set("name","Paul_Chan")params.Set("age","26")Url.RawQuery = params.Encode()//解码中文urlPath := Url.String()fmt.Println(urlPath) // https://www.baidu.com?age=26&name=Paul_chanresp,err := http.Get(urlPath)defer resp.Body.Close()body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body))
}
  • 解析json类型的返回结果
package mainimport ("encoding/json""fmt""io/ioutil""net/http"
)type result struct {Args string `json:"args"`Headers map[string]string `json:"headers"`Origin string `json:"origin"`Url string `json:"url"`
}func main() {resp, err := http.Get("http://baidu.com")if err != nil {return}defer resp.Body.Close()body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body))var res result_ = json.Unmarshal(body,&res)fmt.Printf("%#v",res)//%#v 用Go的语法打印。//比如main.People{name:”sam”, phone:main.Phone{mobile:”12345”, office:”67890”}}
}
  • Get添加请求头
func main() {client := &http.Client{}req,_ := http.NewRequest("GET","http://xxx.com",nil)req.Header.Add("name","Paul_Chan")req.Header.Add("age","26")resp,_ := client.Do(req)body, _ := ioutil.ReadAll(resp.Body)fmt.Printf(string(body))
}
  • Post请求
package mainimport ("fmt""io/ioutil""net/http""net/url"
)
//表单提交
func main() {urlValues := url.Values{}urlValues.Add("name","Paul_Chan")urlValues.Add("age","26")resp, _ := http.PostForm("http://xxx.com/post",urlValues)body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body))
}
//“text/html”提交
package mainimport ("fmt""io/ioutil""net/http""net/url""strings"
)
func main() {urlValues := url.Values{"name":{"Paul_Chan"},"age":{"26"},}reqBody:= urlValues.Encode()resp, _ := http.Post("http://baidu.com/post", "text/html",strings.NewReader(reqBody))body,_:= ioutil.ReadAll(resp.Body)fmt.Println(string(body))
}
  • POST-json
package mainimport ("bytes""encoding/json""fmt""io/ioutil""net/http"
)func main() {client := &http.Client{}data := make(map[string]interface{})data["name"] = "zhaofan"data["age"] = "23"bytesData, _ := json.Marshal(data)req, _ := http.NewRequest("POST","http://httpbin.org/post",bytes.NewReader(bytesData))req.Header.Add("Content-Type", "application/json")resp, _ := client.Do(req)body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body))
}///不要client,使用http.post
func main() {data := make(map[string]interface{})data["name"] = "zhaofan"data["age"] = "23"bytesData, _ := json.Marshal(data)resp, _ := http.Post("http://httpbin.org/post","application/json", bytes.NewReader(bytesData))body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body))
}
  • POST-Client提交表单
func LogIn2() (*http.Response, error) {data := url.Values{}data.Set("name", name)data.Set("password", password)data.Set("autologin", "1")data.Set("enter", "Sign in")r, _ := http.NewRequest(POST, login_url, strings.NewReader(data.Encode()))r.Header.Add("Content-Type", "application/x-www-form-urlencoded")resp, err := client.Do(r)if err != nil {Error.Fatalln(err)return nil, err}return resp, nil}
  • Cookies保存
package mainimport ("fmt""net/http""net/http/cookiejar"
)func main() {jar, _ := cookiejar.New(nil)timeOut := time.Duration(1 * time.Second)fmt.Println("Start Request Server")client := &http.Client{}client.Jar = jarclient.Timeout = timeOuturl := "http://127.0.0.1:8889/test"req, _ := http.NewRequest("GET", url, nil)//第一次发请求client.Do(req)fmt.Printf("第一次 %s \n", req.Cookies())
}

字符处理

  • 格式化赋值
b := "hello world"
a := fmt.Sprintf("%s",b)
fmt.Println(a)
  • 查询变量类型

    • fmt
    fmt.Printf("%s类型为%T\n",c,c)
    • 自定义
    import "fmt"
func main() {v := "hello world"fmt.Println(typeof(v))
}
func typeof(v interface{}) string {return fmt.Sprintf("%T", v)
}
    • 反射
    import ("reflect""fmt"
)
func main() {v := "hello world"fmt.Println(typeof(v))
}
func typeof(v interface{}) string {return reflect.TypeOf(v).String()
}
  • 字符切割
import ("strings""fmt"
)
func main() {b := "hello:world"c := strings.Split(b,":")fmt.Printf("%s类型为%T\n",c,c)
}
  • 定义变量
/[]string类型
func main() {a := [2]string{"111","222"}fmt.Println(a)
}
[]byte
func main() {a := []byte("Hello World!")fmt.Println(a)
}

strings库

fmt.Println(strings.HasPrefix(s3, "a")) //判断前缀
fmt.Println(strings.HasSuffix(s3, "0")) //判断后缀
fmt.Println(strings.Contains(s3, "9"))  //字符串包含关系
fmt.Println(strings.Index(s3, "0"))     //判断子字符串或字符在父字符串中出现的位置（索引）
fmt.Println(strings.LastIndex(s3, "0")) //最后出现位置的索引
fmt.Println(strings.Replace(s3,"0","1",-1))//如果 n = -1 则替换所有字符串
fmt.Println(strings.Count(s3,"0"))//出现的非重叠次数
fmt.Println(strings.Repeat(s3,2))//重复字符串
fmt.Println(strings.ToLower(s3))//修改字符串大小写
fmt.Println(strings.ToUpper(s3))//修改字符串大小写
fmt.Println(strings.TrimSpace(s3))//修剪字符串 去掉开头和结尾空格
fmt.Println(strings.Trim(strings.TrimSpace(s3),"a"))//修剪字符串 去掉开头和结尾字符串

正则匹配

  • 判断是否匹配
package main;
import (// "bytes""fmt""regexp"// "strings"
)
func main() {match,_ := regexp.MatchString("H(.*)d!","Hello World!")fmt.Println(match)//truematch2,_ := regexp.Match("H(.*)d!",[]byte("Hello World!"))fmt.Println(match2)//truerex, _ := regexp.Compile("H(.*)d!")fmt.Println(rex.MatchString("Hello World!"))//true
}
  • 返回匹配字符
func main() {rex, _ := regexp.Compile("H(.*)d!")fmt.Println(rex.MatchString("Hello World!"))text := "Hello World! Hworld！"//返回匹配项目fmt.Println(rex.FindString(text))//返回匹配项目起始索引fmt.Println(rex.FindStringIndex(text))//返回全局匹配和局部匹配（局部匹配即精确匹配括号内的）fmt.Println(rex.FindStringSubmatch(text))//返回全局匹配和局部匹配的索引fmt.Println(rex.FindStringSubmatchIndex(text),len(rex.FindStringSubmatchIndex(text)))//返回所有匹配项fmt.Println(rex.FindAllString(text, -1),len(rex.FindAllString(text, -1)))//返回所有全局匹配和局部匹配的字符索引rex.FindAllStringSubmatchIndex(text,-1)//入参正整数来限制匹配数量text2 := "Hello World! Held! Hellowrld! world Haaaaaad"res, _ := regexp.Compile("H([a-z]+)d!")fmt.Println(res.FindAllString(text2, 2)) //-1即所有，1，2，3次
}
  • 替换匹配字符
func main() {rex, _ := regexp.Compile("H([a-z]+)d!")result := rex.ReplaceAllString("Hello World! Held! world","html")fmt.Println(result)//将匹配项进行大小写转换in := []byte("Hello World! Held! world")out := rex.ReplaceAllFunc(in,bytes.ToUpper)fmt.Println(string(out))//全部转大写c := []byte("aaaaasss dddff ggvv adas")fmt.Println(string(bytes.ToUpper(c)))a := "aaaaasss dddff ggvv adas"fmt.Println(strings.ToUpper(a))}

类型定义

不定参数类型定义

  • 定义python中的print函数
import ("time""fmt"
)func print(args interface{}) {fmt.Println(args)
}func main() {timeStr := time.Now().Format("2006-01-02 02:02:03")print(timeStr)print("222222")
}

var

// 初始化多个同类型变量
var name1, name2, name3 string = "name1", "name2", "name3"
//初始化多个不同类变量
var (name string = "keyworkd"count int = 2
)
//省略变量类型
var name1, name2, name3 = "name1", "name2", "name3"

const

const可以全局，局部定义。常量不可赋值修改

map

package mainimport("fmt"// "time"// "runtime"
)func typeof(v interface{}) string {return fmt.Sprintf("%T", v)
}func main() {m := make(map[string]int)m["k"] = 7m["b"] = 7v := m["k"]fmt.Println(m)fmt.Println("v:",v)fmt.Println(len(m))delete(m,"k")fmt.Println(m,typeof(m))
}

map转json

import("fmt""encoding/json"// "time"// "runtime"
)func main() {s := []map[string]interface{}{}m1 := map[string]interface{}{"name":"John","age":10}m2 := map[string]interface{}{"name":"Alex","age":12}s = append(s, m1, m2)s = append(s, m2)fmt.Println("s:", s)b, err := json.Marshal(s)if err != nil {fmt.Println("json.Marshal failed:",err)return}fmt.Println("b:", string(b))
}

json

使用高性能json包：jsonitor

学习自：https://www.jianshu.com/p/f797343eb04f
go get github.com/json-iterator/go

import ("fmt""github.com/json-iterator/go"   // 引入"os""strings"
)type ColorGroup struct {ID      intName    stringColors  []string
}type Animal struct {Name    stringOrder   string
}func main() {// ================= 序列化 =====================group := ColorGroup{ID:     1,Name:   "Reds",Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},}b, err := jsoniter.Marshal(group)bb, err :=  jsoniter.MarshalIndent(group, "", " ")if err != nil{fmt.Println("error: ", err)}os.Stdout.Write(b)fmt.Println()os.Stdout.Write(bb)fmt.Println()// ===================  Deconde 解码 =================jsoniter.NewDecoder(os.Stdin).Decode(&group)fmt.Println(group)//encoder := jsoniter.NewEncoder(os.Stdout)//encoder.SetEscapeHTML(true)//encoder.Encode(bb)//fmt.Println(string(bb))// =================== 反序列化 =======================var jsonBlob = []byte(`[{"Name": "Platypus", "Order": "Monotremata"},{"Name": "Quoll",    "Order": "Dasyuromorphia"}]`)var animals []Animalif err := jsoniter.Unmarshal(jsonBlob, &animals); err != nil{fmt.Println("error: ", err)}fmt.Printf("the unmarshal is  %+v", animals)// ======================= 流式 ========================fmt.Println()// 序列化stream := jsoniter.ConfigFastest.BorrowStream(nil)defer jsoniter.ConfigFastest.ReturnStream(stream)stream.WriteVal(group)if stream.Error != nil{fmt.Println("error: ", stream.Error)}os.Stdout.Write(stream.Buffer())fmt.Println()// 反序列化iter := jsoniter.ConfigFastest.BorrowIterator(jsonBlob)defer jsoniter.ConfigFastest.ReturnIterator(iter)iter.ReadVal(&animals)if iter.Error != nil{fmt.Println("error： ", iter.Error)}fmt.Printf("%+v", animals)fmt.Println()// ====================其他操作===================// getval := []byte(`{"ID":1,"Name":"Reds","Colors":
{"c":"Crimson","r":"Red","rb":"Ruby","m":"Maroon","tests":["tests_1","tests_2","tests_3","tests_4"]}}`)fmt.Println(jsoniter.Get(val, "Colors").ToString())fmt.Println("the result is " , jsoniter.Get(val, "Colors","tests",0).ToString())// fmt.Println(jsoniter.Get(val, "colors", 0).ToString())fmt.Println()hello := MyKey("hello")output, _ := jsoniter.Marshal(map[*MyKey]string{&hello: "world"})fmt.Println(string(output))obj := map[*MyKey]string{}jsoniter.Unmarshal(output, &obj)for k, v := range obj{fmt.Println(*k," = ", v)}}
// 自定义类型
// 序列化： 需要实现MarshellText
type MyKey stringfunc (m *MyKey) MarshalText() ([]byte, error){// return []byte(string(*m)) , nil  // 针对序列化的内容不做任何调整return []byte(strings.Replace(string(*m), "h","H",-1)), nil
}func(m *MyKey) UnmarshalText(text []byte) error{*m = MyKey(text[:])  // 针对text不做处理return nil
}

package mainimport ("fmt""encoding/json"
)type FamilyRequestBody struct {Family string `json:"family"`
}type DataRequestBody struct {Family FamilyRequestBody `json:"family"`
}type EventRequestBody struct {Account string `json:"account"`Player  string `json:"player"`Count   int    `json:"count"`
}type TeamRequestBody struct {Account string `json:"account"`Team    string `json:"team"`
}type PlayerRequestBody struct {Account string          `json:"account"`Team    string          `json:"team"`Player  string          `json:"player"`Data    DataRequestBody `json:"data"`
}func main() {l := PlayerRequestBody{Account: "my-account",Team:    "12345",Player:  "23424234",Data:    DataRequestBody{FamilyRequestBody{Family: "12345"}},}fmt.Printf("%#v,%T", l, l)fmt.Println(l)bb, _ :=  json.Marshal(l)fmt.Println(string(bb))
}

type

go结构体生成：http://json2struct.mervine.net/

  • 定义嵌套结构
type ColorGroup struct {ID  intName stringColors []string
}type Animal struct {Name stringOrder string
}type Data struct { data0 map[string]interface{} data1 string
}

package mainimport "fmt"type s1 struct {ID strings2 s2s3 s3
}type s2 struct {WebSiteName stringURL         string
}type s3 struct {KeyWord []stringWhere   string
}func main() {ss := s1{ID: "123456",s2: s2{WebSiteName: "ydook.com",URL:         "www.ydook.com",},s3: s3{// 重点：在结构体内部使用数组KeyWord: []string{"IT", "AI", "Web", "technology", "knowledge"},Where:   "IT",},}fmt.Println(ss)
}

https://rabbit52.com/2018/07/go-define-nested-struct/

{"success": true,"data": {"name": "hugo"},"identifi": {"key": "xxx","secret": "secret"},"errors": [{"code": "not_found","message": "something"}]
}
//
type Resp struct {Success boolIdentifi struct {Key stringSecret string}Data interface{}Errors []struct {Code stringMessage string}
}resp := new(Resp)
json.Unmarshal(respBody, resp)
  • 数组加字典
package mainimport ("fmt"
)func main() {result := []map[string]interface{}{}mp1 := map[string]interface{}{"one" : 1,"two" : 2,}mp2 := map[string]interface{}{"three" : 3,"four" : 4,}mp3 := make(map[string]interface{})for k,v := range mp1 {if _,ok := mp1[k]; ok {mp3[k] = v          }}for k,v := range mp2 {if _,ok := mp2[k]; ok {mp3[k] = v}}result = append(result,mp1,mp2)fmt.Println(result)
}

json性能优化

  • 1.使用jsoniter包进行序列化，struct比map更快。
  • 2.相对于解码，json.NewEncoder进行大JSON的编码比json.marshal性能高，因为内部使用pool
  • 3.json.NewDecoder用于http连接与socket连接的读取与写入，或者文件读取
  • 4.json.Unmarshal用于直接是byte的输入
  • 5.jsoniter兼容标准库只需要json := jsoniter.ConfigCompatibleWithStandardLibrary

关键字

go

defer

用于资源的释放，会在函数返回之前,return之后进行调用。

  • 特点一：多个defer语句，压入栈后，遵循先入后出规则
  • 特点二：defer语句压入时，会将传入的变量值一同压入栈中，不受下文变量值变化的影响

break

跳出当前循环

continue

跳过本次循环，继续下次循环

goto

跳转到指定标签处

时间处理

///时间常量（时间格式化）
const (ANSIC       = "Mon Jan _2 15:04:05 2006"UnixDate    = "Mon Jan _2 15:04:05 MST 2006"RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"RFC822      = "02 Jan 06 15:04 MST"RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zoneRFC850      = "Monday, 02-Jan-06 15:04:05 MST"RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zoneRFC3339     = "2006-01-02T15:04:05Z07:00"RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"Kitchen     = "3:04PM"// Handy time stamps.Stamp      = "Jan _2 15:04:05"StampMilli = "Jan _2 15:04:05.000"StampMicro = "Jan _2 15:04:05.000000"StampNano  = "Jan _2 15:04:05.000000000"
)
  • 时间加减
func main() {now := time.Now()m, _ := time.ParseDuration("-1m")m1 := now.Add(m)fmt.Println(m1)fmt.Println(now)
}

golang常用方法积累相关推荐

  1. Cloudpods Golang实践

    Cloudpods是完全自研的一套云平台,Golang是该平台的主要后端开发语言.本文介绍我们在平台开发迭代过程中关于Golang的经验以及在Golang上积累的框架和库,包括积累的Golang工具库 ...

  2. golang基本数据类型string字符串常用方法代码示例

  3. Golang基础教程——字符串常用方法总结

    目录 string包 字符串比较 字符串查找 字符串重复 字符串替换 字符串删除 字符串大小写转换 字符串前缀后缀 字符串分割 字符串拼接 strconv包 string包 字符串比较 函数接口 // ...

  4. Golang filepath包常用方法介绍

    本文介绍与文件路径相关包,该工具包位于path/filepath中,该包试图与目标操作系统定义的文件路径兼容.本文介绍一些常用函数,如获取文件绝对路径,获取文件名或目录名.遍历文件.分割文件路径.文件 ...

  5. Golang的strings和strconv常用方法

    package mainimport ("fmt""strconv""strings" )func main() {str := " ...

  6. golang socket读写同时_epoll在Golang的应用

    使用Golang可以轻松地为每一个TCP连接创建一个协程去服务而不用担心性能问题,这是因为Go内部使用goroutine结合IO多路复用实现了一个"异步"的IO模型,这使得开发者不 ...

  7. 如何写出优雅的 Golang 代码

    Go 语言是一门简单.易学的编程语言,对于有编程背景的工程师来说,学习 Go 语言并写出能够运行的代码并不是一件困难的事情,对于之前有过其他语言经验的开发者来说,写什么语言都像自己学过的语言其实是有问 ...

  8. golang 正则使用总结

    正则表达式的语法可以说基本和编程语言无关,大同小异,不过就是调用的方法不同而已. 以一个案例总结下golang的正则常用方法. 注: 下面的regObj指regexp.Compile后的值,可理解为正 ...

  9. golang ide 简介

    2019年,GO的发展已有十年之久.在这期间出现了很多能被GO语言使用的IDE,把它们都详细介绍一遍是不现实的.接下来,重点介绍我比较了解几款IDE. Goland Goland,商业公司jetbra ...

最新文章

  1. 构造数独 算法及代码实现
  2. emacs org-mode文件转html文件
  3. OpenGL保守光栅化
  4. raid操作相关命令笔记
  5. 使用ArcGIS JavaScript API 3.18 加载天地图
  6. java 连接 sql2005,java与sql server2005 连接有关问题
  7. Spring 3.1和Hibernate的持久层
  8. 【JS 逆向百例】层层嵌套，某加速商城 RSA 加密
  9. oracle权限的分配
  10. 想当老板的人,三点特征很重要(转)
  11. python3.7怎么安装tensorflow_gpu_（更新版）python3.7 Windows10 tensorflow-GPU 安装
  12. 淘宝的开源分布式文件系统TFS
  13. js中如何判断按钮是否被点击了
  14. 【NLP】谷歌综述论文 Efficient Transformers 阅读笔记
  15. （音视频学习笔记）：ffplay命令选项及使用案例
  16. matlab 三边测量,三边测量的定位算法，matlab转为c
  17. Qt开源作品41-网络调试助手增强版V2022
  18. bluecms 手把手教你0day挖掘-基础入门篇
  19. win10系统的qq无网络连接网络连接到服务器,Win10能上qq打不开网页_Win10能上qq不能上网怎么办？-192路由网...
  20. Android Studio连接海马玩模拟器

热门文章

  1. LCS(最长公共子序列)及其O(n)空间优化，O(nlogn)时间复杂度优化
  2. 【开启SSH】小米AIoT路由器 AC2350 (R2350)
  3. python --- 实现LU=PA分解（部分主元的高斯消去）/带行交换的LU分解
  4. 常用控件：列表框控件ListBox
  5. 2022年推荐云计算行业研究报告投资策略产业发展前景市场行情分析（附件中为网盘链接，报告持续更新）
  6. 山川湖海 - Android无障碍功能优化实践
  7. c语言partition头文件,c语言_头文件_windows.h
  8. 西门子博图功能指令——多路分用
  9. c#窗体调查问卷_如何在Microsoft窗体中创建问卷
  10. stm32+cubemx+adc+time定时采集+dma多通道采集