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练习题答案的更多相关文章

  1. 珍藏的数据库SQL基础练习题答案

    自己珍藏的数据库SQL基础练习题答案 一,基本表的定义与删除. 题1: 用SQL语句创建如下三张表:学生(Student),课程表(Course),和学生选课表(SC),这三张表的结构如表1-1到表1 ...

  2. C++PRIMER第五版练习题答案第一章

    C++PRIMER第五版练习题答案第一章 应该有很多小伙伴和我一样,闲来无事买了本C++的书自己啃,课后的练习题做的很揪心,这里我分享下我写的答案,希望能帮助到你,提供源码,就不跑了哈,毕竟现在是第一 ...

  3. sqlzoo练习题答案

    title: SQL-Learning date: 2019-03-12 20:37:21 tags: SQL --- 这是关于在一个SQL学习网站的练习题答案记录:SQL教程 SQL基础 由一些简单 ...

  4. 13.1 Go练习题

    13.1 Go练习题 创建一个goroutine与主线程按顺序相互发送信息若干次 且打印 slice在自动扩容后,内存地址变化 goroutine与闭包的坑 练习题汇总 package main fu ...

  5. mysql 练习题答案

    一 题目 1.查询所有的课程的名称以及对应的任课老师姓名 2.查询学生表中男女生各有多少人 3.查询物理成绩等于100的学生的姓名 4.查询平均成绩大于八十分的同学的姓名和平均成绩 5.查询所有学生的 ...

  6. 算法设计与分析(李春保)练习题答案v1

    1.1第1 章─概论 1.1.1练习题 1.下列关于算法的说法中正确的有(). Ⅰ.求解某一类问题的算法是唯一的 Ⅱ.算法必须在有限步操作之后停止 Ⅲ.算法的每一步操作必须是明确的,不能有歧义或含义模 ...

  7. Java编程思想第四版第二章练习题答案

    练习1:创建一个类,它包含一个int域和一个char域,它们都没有被初始化.将他们的值打印出来,以验证Java执行了默认初始化 public class JavaThinking { private ...

  8. Python For嵌套循环 图形打印X型 nested loop - 练习题答案

    上一篇:Python For嵌套循环 图形打印X型 nested loop - 练习题 上一篇留的Python For嵌套循环 图形打印X型练习题的答案. 由于网上很多嵌套循环都是C++语言写的,用P ...

  9. 【图文+视频新手也友好】Java一维数组详细讲解(内含练习题答案+详解彩蛋喔~)

    目录 视频讲解: 一.数组的概述 二.一维数组的使用 三.Arrays工具类中的sort方法(sort方法用的多,我们具体讲一下) 四.数组中的常见异常 五.一维数组练习题 六.彩蛋(本期视频使用的P ...

随机推荐

  1. 2019-2020-1 20199326《Linux内核原理与分析》第六周作业

    本周学习了庖丁解牛Linux内核分析第五章:系统调用的三层机制(下),是上一章的延续 实验内容:使用gdb跟踪分析一个系统调用内核函数 上周实验我选择的getpid这个系统系统调用,这次准备使用gdb ...

  2. DDOS攻击攻击种类和原理

    DoS攻击.DDoS攻击和DRDoS攻击相信大家已经早有耳闻了吧!DoS是Denial of Service的简写,就是拒绝服务,而DDoS就是Distributed Denial of Servic ...

  3. ERC20 Short Address Attack

    ERC20 Short Address Attack 什么是ERC20 Application Binary Interface(ABI) ERC20 Short Address Attack 开始攻 ...

  4. Linux系统管理第三次作业 账号管理 权限及归属管理

    1.创建/guanli 目录,在/guanli下创建zonghe 和 jishu 两个目录(一条命令) [root@localhost ~]# mkdir /guanli [root@localhos ...

  5. 网络传输 socket

    一.Socket语法及相关 前言:osi七层模型: 第七层:应用层.     各种应用程序协议,如HTTP,FTP,SMTP,POP3. 第六层:表示层.     信息的语法语义以及它们的关联,如加密 ...

  6. 【已解决】React项目中按需引入ant-design报错TypeError: injectBabelPlugin is not a function

    react项目中ant-design按需加载,使用react-app-rewired的时候报错 运行npm start或者yarn start报如下错误: TypeError: injectBabel ...

  7. ElementUI表单验证攻略:解决表单项启用和禁用验证的切换,以及动态表单验证的综合性问题

    试想一种比较复杂的业务场景: 表格(el-table)的每一行数据的第一列是勾选框,最后一列是输入框.当某一行的勾选框勾上时,启用该行的输入框,并开启该行输入框的表单验证:取消该行的勾选框,则禁用该行 ...

  8. Vue 结合 echarts 原生 html5 实现拖拽排版报表系统

    前言 不知道各位 coder 有没有碰到过许多重复的业务需求,比如排版相类似的报表,只不过是顺序稍微换了一下,就是一个新的页面,虽然基于模板思想来写的话也能减少不少代码,但是相对的不那么方便,笔者最近 ...

  9. mac OS 安装 Subversion JavaHL 客户端

    JavaHL原来官网  http://subclipse.tigris.org/wiki/JavaHL 目前已经全部转移到github 官方说明很详细 https://github.com/subcl ...

  10. 在Jetson TX2上捕获、显示摄像头视频

    参考文章:How to Capture and Display Camera Video with Python on Jetson TX2 与参考文章大部分都是相似的,如果不习惯看英文,可以看看我下 ...