GO 编程知识点

2021-02-01 | 129 浏览

GO编程知识点

1.fmt.Scan()

//通过键盘获取数据  存放变量中
fmt.Scan(&score) //阻塞式请求

2.超时判断

	select {
	case value := <-intch:
		fmt.Println(value)
	case value := <-strch:
		fmt.Println(value)
	case <-time.After(time.Second * 5): //超时判断
		fmt.Println("超时")
		//default：阻塞操作
	}

go mod tidy

3.数据表设计加上字段

4.常用函数

#将两个值拼接在一起      strings.Join(os.Args[1:], " ")
#map的类型是字符串，值是int   make(map[string]int)
#每读取一行内容，这一行就作为map中的键，对应的值加一
for input.Scan(){
    counts[input.Text()]++
}
等于
line := input.Text()
counts[line]=counts[line]+1
每一次调用input.scan读取下一行，并且将结尾的换行符去掉；通过input.Text()来获取读到的内容，Scan函数在读到新行的时候返回true，在没有更多内容的时候返回false
#字符串切割为切片   strings.Split
#读取整个命名文件的内容     ReadFile

5. 常用包

flag包，程序的命令行参数来

package main

import (
	"flag"
	"fmt"
	"strings"
)

var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", "", "separator")

func main() {
	flag.Parse()
	fmt.Print(strings.Join(flag.Args(), *sep))
	if !*n {
		fmt.Println()
	}
}

6.函数

使用new创建的变量和取地址的普通变量没有什么不同，只是不需要引入和声明一个虚拟的名字，通过new(T)就可以直接在表达式中使用，因此new只是语法上的便利，不是一个概念

package main

import "fmt"

func abc() {
	p := new(int)   //new出来的值是一个地址
	fmt.Println(p)
	fmt.Println(*p)
}
func main() {
	abc()
}
下面两种方式是相同的行为：
func newInt() *int{
    return new(int)
}
func newInt()*int{
    var dummy int
    return & dummy
}

7.二元操作符优先级

*	/	%	<<	>>	&	&^
+	-	|	^
==	!=	<	<=	>	>=
&&
||

运算符

&	位运算符	AND
|	位运算符	OR
^	位运算符	XOR
&^	位清空		（AND NOT）
<<	左移
>>	右移

算术上,左移运算符x<<n等价于x乘以2^n;而右移运算x>>n等价于x除以2^n,向下取整

文字符号 rune

转义符：

\a	警告或者响铃
\b	退格符
\f	换页符
\n	换行符
\r	回车符
\t	制表符
\v	垂直制表符
\' 	单引号
\"	双引号
\\	反斜杠

字符串操作：

1.判断某个字符串是否为另一个字符串的前缀

func HasPrefix(s, prefix string) bool {
	return len(s) >= len(prefix) && s[:len(prefix)] == prefix
}

2.判断它是否是另一个字符串的后缀：

func HasSuffix(s, suffix string) bool {
	return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}

3.判断它是否是另一个子字符串

func Contains(s, substr string) bool {
	for i := 0; i < len(s); i++ {
		if HasPrefix(s[i:], substr) {
			return true
		}
	}
	return falseg
}

字符串和切片进行转换：

// Printints demonstrates the use of bytes.Buffer to format a string.
// 切片转换为字符串
package main

import (
	"bytes"
	"fmt"
)

// !+
// intsToString is like fmt.Sprint(values) but adds commas.
func intsToString(values []int) string {
	var buf bytes.Buffer
	buf.WriteByte('[')
	for i, v := range values {
		if i > 0 {
			buf.WriteString(", ")
		}
		fmt.Fprintf(&buf, "%d", v)
	}
	buf.WriteByte(']')
	return buf.String()
}

func main() {
	fmt.Println(intsToString([]int{1, 2, 3})) // "[1, 2, 3]"
}

//!-

字符串和数字的相互转换

要将整数转换为字符串，一种选择是使用fmt.Sprintf,另外一种做法是用函数strconv.Itoa

计算一个字符串在内存中占的字节大小

fmt.Println(unsafe.Sizeof(str1))

8.反射

stypeof :=reflect.TypeOf(Perple{})

通过反射获取结构体成员

package main

import (
	"fmt"
	"reflect"
)

// 在结构体操作中  结合json时，结构体成员首字母大写
type Perple struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	//通过反射获取结构体成员
	typeof := reflect.TypeOf(Perple{})
	//遍历结构体成员
	for i := 0; i < typeof.NumField(); i++ {
		field := typeof.Field(i)
		tag := field.Tag.Get("json")
		fmt.Println(tag)
	}
}

9.毫秒代码

计算毫秒代码

package main

import (
	"fmt"
	"sync"
	"time"
)

//计算后台运行时间
func dosomething(millisecs time.Duration, wg *sync.WaitGroup) {
	duration := millisecs * time.Millisecond
	time.Sleep(duration)
	fmt.Println("Function in background, duration:", duration)
	wg.Done()
}

func main() {
	var wg sync.WaitGroup // 这里为什么不需要初始化
	wg.Add(4)
	go dosomething(200, &wg)
	go dosomething(1400, &wg)
	go dosomething(150, &wg)
	go dosomething(11600, &wg)

	wg.Wait()
	fmt.Println("Done")
}


{
	"Company":"Lianshi",
	"Subjects":[
	"Go",
	"Web",
	"Python",
	"C++"
				],
"IsOk":true,
"Price":8980.88
}

10.命令行输入参数

args := os.Args

//获取用户输入的所有参数

DevOps