13.2 Go练习题答案
13.2 Go练习题答案
练习题1:
创建一个goroutine与主线程按顺序相互发送信息若干次 且打印
package temp import "fmt" //创建一个goroutine与主线程按顺序相互发送信息若干次 且打印
var c chan string //声明一个string管道
func Pingpong() {
i := 0
for {
fmt.Println(<-c) //打印管道中取出的数据
c <- fmt.Sprintf("From pingpong: say hi ,%d", i)
i++
}
}
func main() {
c = make(chan string) //初始化管道内存
//协程执行函数
go Pingpong()
//主函数循环打印十次
for i := 0; i < 10; i++ {
c <- fmt.Sprintf("From main: say hi,%d", i)
fmt.Println(<-c)
}
}
slice在自动扩容后,内存地址变化
package main import (
"fmt"
) /*
//有关slice的坑,slice在自动扩容后,内存地址已经变了
func Pingpong(s []int) {
s = append(s, 3)
} func main() {
s := make([]int, 0)
fmt.Println(s)
Pingpong(s)
fmt.Println(s)
}
*/ //提供返回值,将append这个心的切片返回
func Pingpong(s []int) []int {
s = append(s, 3)
return s
} func main() {
s := make([]int, 0) //初始容量是0,append后切片地址变了
fmt.Printf("%p %v\n", s, s)
s = Pingpong(s)
fmt.Printf("%p %v\n", s, s)
}
goroutine与闭包的坑
package main import (
"fmt"
) func main() {
s := []string{"a", "b", "c"}
for _, v := range s {
//此时func()是个闭包函数,变量v是c
//可以接收一个参数,作为值拷贝
go func(v) {
fmt.Println(v)
}(v)
}
select {} //用select阻塞main退出
}
写⼀一个程序,获取当前时间,并格式化成 2017/06/15 08:05:00形式
package main import (
"fmt"
"time"
) func main() {
now := time.Now()
//通过now.Format格式化时间
fmt.Println(now.Format("2006/01/02 15:04:05"))
}
写⼀一个程序,统计⼀一段代码的执⾏行行耗时,单位精确到微秒。
package main import (
"fmt"
"time"
) /*
1秒=1000毫秒(ms) 1秒=1,000,000 微秒(μs) 1秒=1,000,000,000 纳秒(ns)
*/
func Task() {
start := time.Now().UnixNano() //返回当前的纳秒数
time.Sleep(5 * time.Millisecond) //睡眠5毫秒
end := time.Now().UnixNano()
cost := (end - start) / 1000 //换算成us微秒
fmt.Printf("do task spend:%d us \n", cost)
} func main() {
Task()
}
99乘法表
func testMulti() {
//有9行,每行有同等数的列
//i代表行
for i := 1; i < 10; i++ {
//j代表列,从1开始,等同于行数
for j := 1; j <= i; j++ {
fmt.Printf("%d * %d = %d\t", j, i, j*i)
}
fmt.Println()
}
}
写⼀一个程序,对英⽂文字符串串进⾏行行逆序
func testReverString() {
var str = "hello超哥"
//对字符串操作,反转含有中文的字符串,转化为rune切片,rune切片存的是单个字符,而byte切片存单个字节
var r []rune = []rune(str)
//遍历rune切片,每次交换头尾2个值,因此只需要交换长度的一半
fmt.Println(len(r)) //默认rune切片长度是7
fmt.Printf("%c\n", r)
for i := 0; i < len(r)/2; i++ {
//因为索引是从0开始,因此长度要减一
//每次交换,头尾交换数据,交换5次
r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾,r[len(r)-i-1]是尾巴索引,交换给头索引,也就是9换0,8换1,7换2,6换3,5换4
fmt.Printf("%c\n", r)
}
str = string(r)
fmt.Printf("%s\n", str)
}
写⼀一个程序,判断⼀一个字符串串是否是回⽂文。
func isHuiwen(str string) bool {
//对字符串操作,反转含有中文的字符串,转化为rune切片,rune切片存的是单个字符,而byte切片存单个字节
var r []rune = []rune(str)
//遍历rune切片,每次交换头尾2个值,因此只需要交换长度的一半
fmt.Println(len(r)) //默认rune切片长度是7
for i := 0; i < len(r)/2; i++ {
//因为索引是从0开始,因此长度要减一
//每次交换,头尾交换数据,交换5次
r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾,r[len(r)-i-1]是尾巴索引,交换给头索引,也就是9换0,8换1,7换2,6换3,5换4
}
str1 := string(r)
if str1 == str {
return true
}
//这里由于 golint对代码的静态检查,因此不需要写else,直接return false即可
return false } func main() {
b := isHuiwen("上海自来水来自海上")
fmt.Println(b)
}
求1到100之内的所有质数,并打印到屏幕上
//质数p,又称素数(prime),指在大于1的自然数中,除了1和该数自身外,无法被其他自然数整除的数
//求1-100的质数,
func justify(n int) bool {
//对传入的数值判断
//如果小于等于1直接判断false
if n <= 1 {
return false
}
//循环判断2-100是否为素数
//此时i是除数,n是被除数
for i := 2; i < n; i++ {
//如果余数可以为0,代表可以被整除,也就不符合素数的概念
if n%i == 0 {
return false
}
}
return true
}
func test() {
//循环1-200的数,排除1
for i := 2; i < 100; i++ {
if justify(i) == true {
fmt.Printf("%d is prime\n", i)
}
}
} func main() {
test()
}
求100-1000的水仙花数
func isShuixianhua(n int) bool {
//个位数,一个数对10求模就是获取该数的个位数,例如153%10的值是3
first := n % 10
//十位数
second := (n / 10) % 10
//百位数
third := (n / 100) % 10
//水仙花数
sum := first*first*first + second*second*second + third*third*third
if sum == n {
return true
}
return false
}
func main() {
//遍历100-1000之间
for i := 100; i < 1000; i++ {
if isShuixianhua(i) == true {
fmt.Printf("%d 是水仙花数\n", i)
}
}
}
输⼊入⼀一⾏行行字符,分别统计出其中英⽂文字⺟母、空格、数字和其它字符的个数
func calc(str string) (charCount int, numCount int, spaceCount int, otherCount int) {
//遍历统计字符串,需要转换为rune切片,进行挨个判断,如果是某一个类型,计数器就加一
utfChars := []rune(str)
for i := 0; i < len(utfChars); i++ {
if utfChars[i] >= 'a' && utfChars[i] <= 'z' || utfChars[i] >= 'A' && utfChars[i] <= 'Z' {
charCount++
continue
} if utfChars[i] >= '0' && utfChars[i] <= '9' {
numCount++
continue
} if utfChars[i] == ' ' {
spaceCount++
continue
} otherCount++
}
return
}
func main() {
var str string = "我爱北京天安门 10000年"
charCount, numCount, spCount, other := calc(str)
fmt.Printf("char count:%d | num count:%d | sp count:%d | other:%d\n", charCount, numCount, spCount, other)
}
插入排序
//插入排序
func insert_sort(a [8]int)[8]int{
for i:=1;i<len(a);i++{
for j:=i;j>0;j--{
if a[j]<a[j-1]{
a[j],a[j-1]=a[j-1],a[j]
}else {
break
}
}
}
return a
}
选择排序
func select_sort(a [8]int)[8]int{
for i:=0;i<len(a);i++{
for j:=i+1;j<len(a);j++{
if a[j]<a[i]{
a[i],a[j]=a[j],a[i]
}
}
}
return a
}
冒泡排序
func bubble_sort(a [8]int) [8]int {
for i := 0; i < len(a); i++ {
for j := 0; j < len(a)-i-1; j++ {
if a[j] > a[j+1] {
a[j], a[j+1] = a[j+1], a[j]
}
}
}
return a
}
求数组所有元素之和
//求数组所有元素之和
func sumArray(r [10]int) int {
var sum int
for _, v := range r {
sum += v
}
return sum
} //随机生成一个长度10的数组
func testArray() {
//通过随机数种子生成值,否则rand.Intn总是一个固定的随机数
rand.Seed(time.Now().Unix())
var b [10]int
for i := 0; i < len(b); i++ {
b[i] = rand.Intn(100)
}
fmt.Println(b)
sum := sumArray(b)
fmt.Println(sum)
} func main() {
testArray()
}
判断如下结果的输出信息
func main() {
var sa = make([]string, 5, 10)
fmt.Println(sa) //默认有5个空元素的切片
//循环写入十个元素,sa切片自动扩容
for i := 0; i < 10; i++ {
//追加是从第六个元素追加
sa = append(sa, fmt.Sprintf("%v", i))
fmt.Printf("长度%d,容量%d 内容%v\n", len(sa), cap(sa), sa)
}
fmt.Println(sa)
}
结果
yugoMBP:lesson1 yuchao$ go run main.go
[ ]
长度6,容量10 内容[ 0]
长度7,容量10 内容[ 0 1]
长度8,容量10 内容[ 0 1 2]
长度9,容量10 内容[ 0 1 2 3]
长度10,容量10 内容[ 0 1 2 3 4]
长度11,容量20 内容[ 0 1 2 3 4 5]
长度12,容量20 内容[ 0 1 2 3 4 5 6]
长度13,容量20 内容[ 0 1 2 3 4 5 6 7]
长度14,容量20 内容[ 0 1 2 3 4 5 6 7 8]
长度15,容量20 内容[ 0 1 2 3 4 5 6 7 8 9]
[ 0 1 2 3 4 5 6 7 8 9]
用golangsort包对数组排序
func pkgSort() {
// s1 := []int{3, 6, 5, 7, 8, 1} //声明初始化切片
var a [5]int = [5]int{5, 4, 3, 2, 1}
sort.Ints(a[:])
fmt.Println("a:", a) var b [5]string = [5]string{"ac", "ec", "be", "fa", "ii"}
sort.Strings(b[:])
fmt.Println("b:", b) var c [5]float64 = [5]float64{29.38, 22.32, 0.8, 99191.2}
sort.Float64s(c[:]) fmt.Println("c:", c)
}
实现⼀一个密码⽣生成⼯工具,支持以下功能 用户可以通过-l指定⽣生成密码的⻓长度 提示:可以⽤用标准包 “flag”解析命令⾏行行参数
用户可以通过-t指定⽣生成密码的字符集,⽐比如 -t num⽣生成全数字的密码 -t char ⽣生成包含全英⽂文字符的密码, -t mix包含⽣生成数字和英⽂文的密码, -t advance ⽣生成包含数字、英⽂文以及特殊字符的密码
package main import (
"flag"
"fmt"
"math/rand"
"time"
) var (
length int
charset string
) //密码策略,数字字母,特殊符号
const (
NumStr = "0123456789"
CharStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
SpecStr = "+=-@#~,.[]()!%^*$"
) //解析用户输入
func parseArgs() {
//传入整数,参数密码长度,参数名字,参数长度默认值,帮助信息
flag.IntVar(&length, "l", 16, "-l 生成密码的长度")
//传入的是字符串,解析哪些参数
// 注意``用法,保证字符串原样输出
flag.StringVar(&charset, "t", "num",
`-t 制定密码生成的字符集,
num:只使用数字[0-9],
char:只使用英文字母[a-zA-Z],
mix: 使用数字和字母,
advance:使用数字、字母以及特殊字符`)
//指定选项之后,确认解析
flag.Parse()
} func test1() {
for i := 0; i < len(CharStr); i++ {
//如果字符串不为空,就输出信息
if CharStr[i] != ' ' {
fmt.Printf("%c", CharStr[i])
}
} } //生成密码 函数
func generatePasswd() string {
//初始化密码,存为切片,字符是byte,因此是[]byte,容量是用户指定的
var passwd []byte = make([]byte, length, length)
var sourceStr string
//如果类型是num,返回数字常量,密码就是一堆数字
if charset == "num" {
sourceStr = NumStr
//或者是一个字符
} else if charset == "char" {
sourceStr = CharStr
//或者是混合型的
} else if charset == "mix" {
sourceStr = fmt.Sprintf("%s%s", NumStr, CharStr)
//如果是高级的,数字,字母,特殊符号
} else if charset == "advance" {
sourceStr = fmt.Sprintf("%s%s%s", NumStr, CharStr, SpecStr)
//如果用户输入错了,则默认返回数字密码
} else {
sourceStr = NumStr
}
//打印原始字符信息
// fmt.Println("source:", sourceStr)
//判断用户输入参数 -l
for i := 0; i < length; i++ {
//循环取得随机数
index := rand.Intn(len(sourceStr))
//将随机数写入到密码切片中
passwd[i] = sourceStr[index]
}
return string(passwd)
} func main() {
//随机数种子
rand.Seed(time.Now().UnixNano())
//解析用户输入的参数
parseArgs()
//什么都不加,显示默认参数
// fmt.Printf("length:%d charset:%s\n", length, charset)
//生成随机数密码
passwd := generatePasswd()
fmt.Println(passwd)
}
写⼀一个函数,传⼊入⼀一个int类型的指针,并在函数中修改所指向的值
func testPtr(n *int) {
*n = 666
}
func main() {
n := 200
testPtr(&n)
fmt.Println(n)
}
写⼀一个程序,统计⼀一个字符串串每个单词出现的次数。⽐比如: s = “how do you do” 输出 how = 1 do = 2 you = 1
//单词次数统计,返回map类型,key=单词,value=次数
func wordCount(str string) map[string]int {
//初始化map,存放结果
var result = make(map[string]int, 128)
//对用户的输入,通过空格分割,区分单词,返回值是个切片
words := strings.Split(str, " ")
//遍历切片
for _, v := range words {
//ok是对map中的数据判断,count是map的值,也就是统计单词的次数
count, ok := result[v]
//如果不存在,添加一次统计
if !ok {
result[v] = 1 } else {
//如果已经存在了,value的数值+1
result[v] = count + 1
}
}
return result
}
func main() {
str := "I am a boy. I have a apple."
result := wordCount(str)
//%v 输出默认值 %#v 输出完全的go语法格式
fmt.Printf("result:%#v\n", result)
}
写⼀一个程序,实现学⽣生信息的存储,学⽣生有id、年年龄、分数等信息。需要⾮非常⽅方 便便的通过id查找到对应学⽣生的信息。
func testInterface() {
//空接口可以接受任意值
var a interface{}
var b int = 100
var c float32 = 1.2
var d string = "hello" a = b
fmt.Printf("a=%#v %T\n", a, a) a = c
fmt.Printf("a=%#v %T\n", a, a) a = d
fmt.Printf("a=%#v %T\n", a, a)
} //写⼀一个程序,实现学⽣生信息的存储,学⽣生有id、年年龄、分数等信息。需要⾮非常⽅方 便便的通过id查找到对应学⽣生的信息。
func studentStore() {
/*声明map类型,用它存储k-v形式数据 最合适不过
格式
学号id [年纪:18 id:1 名字:阿狗 socre:99.9]
转化为map
*/
//有一处map的类型是interface{},可以存储任何类型值,如int,string,float
//初始化第一层的map,注意内层map还需继续初始化方可使用
var stuMap = make(map[int]map[string]interface{}, 16)
// //创建一条学生信息
// id := 1
// name := "阿狗"
// score := 88.9
// age := 18
// //插入第一个学生的数据,如果学生不存在,就插入数据,必须得初始化方可使用
// value, ok := stuMap[id]
// //如果插入失败,是因为要对map进行初始化才能使用
// if !ok {
// value = make(map[string]interface{}, 8)
// }
// value["name"] = name
// value["id"] = id
// value["score"] = score
// value["age"] = age
// //设置第一条数据
// stuMap[id] = value
// fmt.Printf("stuMap: %v\n", stuMap) //循环十条记录写入
for i := 0; i < 10; i++ {
value, ok := stuMap[i]
if !ok {
//如果值不存在,必须要初始化
value = make(map[string]interface{}, 8)
}
//Sprintf接收格式化输出,返回字符串
value["name"] = fmt.Sprintf("stu%d", i)
value["id"] = i
//返回随机的浮点数据
value["score"] = rand.Float32() * 100.0
value["age"] = rand.Intn(100) //随机返回100以内的年纪数字
stuMap[i] = value
}
fmt.Println()
//遍历取出所有学生成绩
for k, v := range stuMap {
fmt.Printf("学生id=%d 学生信息=%v\n", k, v)
}
//学生6号的信息
info, ok := stuMap[6]
if ok {
fmt.Printf("学生%d号的 姓名:%s 成绩:%f 年纪:%d", info["id"], info["name"], info["score"], info["age"])
}
fmt.Println()
} func main() {
//testInterface()
studentStore() //所有学生成绩
//取出学生成绩
}
你有50枚⾦金金币,需要分配给以下⼏几个⼈人:Matthew, Sarah, Augustus, Heidi, Emilie,Peter, Giana, Adriano, Aaron, Elizabeth。
分配规则如下所示: a. 名字中包含’a’或’A’: 1枚⾦金金币 b. 名字中包含’e’或’E’: 1枚⾦金金币 c. 名字中包含 ‘i’或’I’: 2枚⾦金金币 d. 名字中包含’o’或’O’: 3枚⾦金金币 e. 名字中包含’u’或’U’: 5枚⾦金金币 写⼀一个程序,计算每个⽤用户分到了了多少⾦金金币,以及最后剩余多少⾦金金币?
package main import "fmt" //定义50个金币
var (
coins = 50
//用户信息存入一个切片,声明且初始化
users = []string{
"Matthew", "Sarah", "Augustus", "Heidi", "Emilie",
"Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
}
//分配distribution,根据用户个数分配
distribution = make(map[string]int, len(users))
) //计算金币,参数用户名字,计算个人的金币数量
func calcCoin(username string) int {
var sum int = 0
for _, char := range username {
switch char {
case 'a', 'A':
sum++
case 'e', 'E':
sum++
case 'i', 'I':
sum += 2
case 'o', 'O':
sum += 3
case 'u', 'U':
sum += 5
}
}
return sum
} //分配金币
func dispathchCoin() int {
var left = coins //定义剩余金币数
//遍历users切片,计算金币
for _, username := range users {
allCoin := calcCoin(username)
//计算剩余金币
left -= allCoin
value, ok := distribution[username]
if !ok {
distribution[username] = allCoin
} else {
distribution[username] = value + allCoin
}
}
return left
} func main() {
left := dispathchCoin() //剩余金币数
//遍历map
for username, coin := range distribution {
fmt.Printf("用户:\t%s\t拥有\t%d\t金币\n", username, coin)
}
fmt.Printf("剩余金币总数:%d\n", left)
}
Go作用域的坑,请说出如下输出
package main import (
"fmt"
) //全局变量
var (
Ga int = 99
) const (
v int = 199
) func GetGa() func() int { if Ga := 55; Ga < 60 {
fmt.Println("GetGa if 中:", Ga)
} for Ga := 2; ; {
fmt.Println("GetGa循环中:", Ga)
break
}
//这里用全局变量
fmt.Println("GetGa函数中:", Ga)
//闭包函数,匿名函数func()对全局Ga的引用,第一次调用是99+1,第二次是100+1,第三次是101+1,第四次是102+1
return func() int {
Ga += 1
return Ga
}
} func main() {
Ga := "string"
fmt.Println("main函数中:", Ga) b := GetGa()
fmt.Println("main函数中:", b(), b(), b(), b()) v := 1 //main函数体中局部变量
//隐式代码块,有自己局部作用域
{
v := 2
fmt.Println(v)
{
v := 3
fmt.Println(v)
}
}
fmt.Println(v)
}
结果
yugoMBP:golesson yuchao$ go run main.go
main函数中: string
GetGa if 中: 55
GetGa循环中: 2
GetGa函数中: 99
main函数中: 100 101 102 103
2
3
1
解释
Ga作为全局变量纯在是int类型,值为99;而在main()中时,Ga通过简式声明 := 操作,是string类型,值为string。在main()中,v很典型地体现了在“{}”花括号中的作用域问题,每一层花括号,都是对上一层的屏蔽。而闭包函数,GetGa()返回的匿名函数,赋值给b,每次执行b(),Ga的值都被记忆在内存中,下次执行b()的时候,取b()上次执行后Ga的值,而不是全局变量Ga的值,这就是闭包函数可以使用包含它的函数内的变量,因为作为代码块一直存在,所以每次执行都是在上次基础上运行。
简单总结如下:
有花括号"{ }"一般都存在作用域的划分;
:= 简式声明会屏蔽所有上层代码块中的变量(常量),建议使用规则来规范,如对常量使用全部大写,而变量尽量小写;
在if等语句中存在隐式代码块,需要注意;
闭包函数可以理解为一个代码块,并且他可使用包含它的函数内的变量; 注意,简式变量只能在函数内部声明使用,但是它可能会覆盖函数外全局同名变量。而且你不能在一个单独的声明中重复声明一个变量,但在多变量声明中这是允许的,而且其中至少要有一个新的声明变量。重复变量需要在相同的代码块内,否则你将得到一个隐藏变量。
如果你在代码块中犯了这个错误,将不会出现编译错误,但应用运行结果可能不是你所期望。所以尽可能避免和全局变量同名。
13.2 Go练习题答案的更多相关文章
- 珍藏的数据库SQL基础练习题答案
自己珍藏的数据库SQL基础练习题答案 一,基本表的定义与删除. 题1: 用SQL语句创建如下三张表:学生(Student),课程表(Course),和学生选课表(SC),这三张表的结构如表1-1到表1 ...
- C++PRIMER第五版练习题答案第一章
C++PRIMER第五版练习题答案第一章 应该有很多小伙伴和我一样,闲来无事买了本C++的书自己啃,课后的练习题做的很揪心,这里我分享下我写的答案,希望能帮助到你,提供源码,就不跑了哈,毕竟现在是第一 ...
- sqlzoo练习题答案
title: SQL-Learning date: 2019-03-12 20:37:21 tags: SQL --- 这是关于在一个SQL学习网站的练习题答案记录:SQL教程 SQL基础 由一些简单 ...
- 13.1 Go练习题
13.1 Go练习题 创建一个goroutine与主线程按顺序相互发送信息若干次 且打印 slice在自动扩容后,内存地址变化 goroutine与闭包的坑 练习题汇总 package main fu ...
- mysql 练习题答案
一 题目 1.查询所有的课程的名称以及对应的任课老师姓名 2.查询学生表中男女生各有多少人 3.查询物理成绩等于100的学生的姓名 4.查询平均成绩大于八十分的同学的姓名和平均成绩 5.查询所有学生的 ...
- 算法设计与分析(李春保)练习题答案v1
1.1第1 章─概论 1.1.1练习题 1.下列关于算法的说法中正确的有(). Ⅰ.求解某一类问题的算法是唯一的 Ⅱ.算法必须在有限步操作之后停止 Ⅲ.算法的每一步操作必须是明确的,不能有歧义或含义模 ...
- Java编程思想第四版第二章练习题答案
练习1:创建一个类,它包含一个int域和一个char域,它们都没有被初始化.将他们的值打印出来,以验证Java执行了默认初始化 public class JavaThinking { private ...
- Python For嵌套循环 图形打印X型 nested loop - 练习题答案
上一篇:Python For嵌套循环 图形打印X型 nested loop - 练习题 上一篇留的Python For嵌套循环 图形打印X型练习题的答案. 由于网上很多嵌套循环都是C++语言写的,用P ...
- 【图文+视频新手也友好】Java一维数组详细讲解(内含练习题答案+详解彩蛋喔~)
目录 视频讲解: 一.数组的概述 二.一维数组的使用 三.Arrays工具类中的sort方法(sort方法用的多,我们具体讲一下) 四.数组中的常见异常 五.一维数组练习题 六.彩蛋(本期视频使用的P ...
随机推荐
- 2019-2020-1 20199326《Linux内核原理与分析》第六周作业
本周学习了庖丁解牛Linux内核分析第五章:系统调用的三层机制(下),是上一章的延续 实验内容:使用gdb跟踪分析一个系统调用内核函数 上周实验我选择的getpid这个系统系统调用,这次准备使用gdb ...
- DDOS攻击攻击种类和原理
DoS攻击.DDoS攻击和DRDoS攻击相信大家已经早有耳闻了吧!DoS是Denial of Service的简写,就是拒绝服务,而DDoS就是Distributed Denial of Servic ...
- ERC20 Short Address Attack
ERC20 Short Address Attack 什么是ERC20 Application Binary Interface(ABI) ERC20 Short Address Attack 开始攻 ...
- Linux系统管理第三次作业 账号管理 权限及归属管理
1.创建/guanli 目录,在/guanli下创建zonghe 和 jishu 两个目录(一条命令) [root@localhost ~]# mkdir /guanli [root@localhos ...
- 网络传输 socket
一.Socket语法及相关 前言:osi七层模型: 第七层:应用层. 各种应用程序协议,如HTTP,FTP,SMTP,POP3. 第六层:表示层. 信息的语法语义以及它们的关联,如加密 ...
- 【已解决】React项目中按需引入ant-design报错TypeError: injectBabelPlugin is not a function
react项目中ant-design按需加载,使用react-app-rewired的时候报错 运行npm start或者yarn start报如下错误: TypeError: injectBabel ...
- ElementUI表单验证攻略:解决表单项启用和禁用验证的切换,以及动态表单验证的综合性问题
试想一种比较复杂的业务场景: 表格(el-table)的每一行数据的第一列是勾选框,最后一列是输入框.当某一行的勾选框勾上时,启用该行的输入框,并开启该行输入框的表单验证:取消该行的勾选框,则禁用该行 ...
- Vue 结合 echarts 原生 html5 实现拖拽排版报表系统
前言 不知道各位 coder 有没有碰到过许多重复的业务需求,比如排版相类似的报表,只不过是顺序稍微换了一下,就是一个新的页面,虽然基于模板思想来写的话也能减少不少代码,但是相对的不那么方便,笔者最近 ...
- mac OS 安装 Subversion JavaHL 客户端
JavaHL原来官网 http://subclipse.tigris.org/wiki/JavaHL 目前已经全部转移到github 官方说明很详细 https://github.com/subcl ...
- 在Jetson TX2上捕获、显示摄像头视频
参考文章:How to Capture and Display Camera Video with Python on Jetson TX2 与参考文章大部分都是相似的,如果不习惯看英文,可以看看我下 ...