go的两大测试方法- 官网推荐

go的两大测试方法- 官网推荐

  • go的两大测试方法- 官网推荐
  • 常见的不正规测试方法
    • main方法个例测试验证 - 不正规
      • 1. 提供一个函数：`Reverse(input string)`进行测试
      • 2. 直接在函数下创建`main`函数下进行个例测试
      • 3. 测试发现，`Reverse`方法不支持某些汉字，因为汉字不是单字节！所以使用rune来装字符，所以增加了多一个方法`Reverse1`
      • 4. 再次在`main`中测试
      • 5. 经过测试后个例反转的效果是正确。但是个例毕竟还是个例。官网里面存在测试的使用教程。下面继续吧。
  • go官方推荐测试方式一
    • 单元unit 测试
      • 1. 新建一个go文件，要求文件命名为 待测试文件名 + _test.go
      • 2. 进行测试验证
      • 3. unit单元测试局限性：
      • 4. unit单元测试的优点
    • fuzz模糊测试
      • 1. 在fuzzingToLearn_test文件中添加模糊测试的代码 - 两个方法测试
      • 2. 终端运行测试
        • 1. 使用终端先使用run test验证是否通过
        • 2. 使用fuzz模糊测试验证，查看任何随机生成的字符串输入是否会导致失败
        • 3. 使用fuzz模糊测试FuzzReverse1方法，代码改动
        • 4. 使用fuzz验证
          • 诊断代码
  • end
    • 所有的代码：

go的两大测试方法- 官网推荐

常见的不正规测试方法

main方法个例测试验证 - 不正规

1. 提供一个函数：Reverse(input string)进行测试

2. 直接在函数下创建main函数下进行个例测试

package mainimport ("fmt"
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes := []byte(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}func main() {input := "hello, world , java页, go bigdata"firstRev := Reverse(input)secondRev := Reverse(firstRev)fmt.Printf("原始数据: %q\n", input)fmt.Printf("第一次反转的数据: %q\n", firstRev)fmt.Printf("反转数据再次反转的数据: %q\n", secondRev)
}

3. 测试发现，Reverse方法不支持某些汉字，因为汉字不是单字节！所以使用rune来装字符，所以增加了多一个方法Reverse1

// Reverse1 字符(学习之前以为万事大吉，但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes := []rune(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}

4. 再次在main中测试

package mainimport ("fmt"
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes := []byte(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}// Reverse1 字符(学习之前以为万事大吉，但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes := []rune(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}func main() {input := "hello, world , java页, go bigdata"firstRev := Reverse(input)secondRev := Reverse(firstRev)fmt.Printf("原始数据: %q\n", input)fmt.Printf("第一次反转的数据: %q\n", firstRev)fmt.Printf("反转数据再次反转的数据: %q\n", secondRev)firstRev1 := Reverse1(input)secondRev1 := Reverse1(firstRev1)fmt.Printf("第一次反转的数据: %q\n", firstRev1)fmt.Printf("反转数据再次反转的数据: %q\n", secondRev1)
}

5. 经过测试后个例反转的效果是正确。但是个例毕竟还是个例。官网里面存在测试的使用教程。下面继续吧。

go官方推荐测试方式一

单元unit 测试

1. 新建一个go文件，要求文件命名为 待测试文件名 + _test.go

  • 我待测试文件名为fuzzingToLearn.go， 所以要新建的文件名为：fuzzingToLearn_test.go
  • 文件存在两个函数需要待验证，所以这里也编写了两个函数
  • 注意事项：
    • 测试方法名字规范: Test$functionName
    • 其中 f u n c t i o n N a m e 的首字母要改写为大写 ! 这里的 functionName的首字母要改写为大写!这里的 functionName的首字母要改写为大写!这里的functionName没有局限名字，保证首字母大写即可
package mainimport ("testing""unicode/utf8"
)// 测试字节反转
func TestReverse(t *testing.T) {testcases := []struct {in, want string}{{"Hello, world", "dlrow ,olleH"},{" ", " "},{"!123456", "654321!"},}for _, tc := range testcases {rev := Reverse(tc.in)if rev != tc.want {t.Errorf("Reverse: %q, want %q", rev, tc.want)}}
}// 测试字符反转
func TestReverse1(t *testing.T) {testcases := []struct {in, want string}{{"页Hello, world", "dlrow ,olleH页"},{" ", " "},{"!123456", "654321!"},}for _, tc := range testcases {rev := Reverse1(tc.in)if rev != tc.want {t.Errorf("Reverse: %q, want %q", rev, tc.want)}}
}

2. 进行测试验证

  • 切换到对应路径，在终端上运行go test -v命令；这个命令是测试所有的方法的，也有测试单个方法的：go test -v -test.run $测试方法名
  • Windows的cmd和powershell都可以运行，其它操作系统的就不说了
  • 结果展示
PS D:\codes\go\goland-setting\test\fuzzing> ls目录: D:\codes\go\goland-setting\test\fuzzingMode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         2023/12/6     22:37           1661 fuzzingToLearn.go
-a----         2023/12/6     23:01           2197 fuzzingToLearn_test.goPS D:\codes\go\goland-setting\test\fuzzing> go test -v
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
=== RUN   TestReverse
--- PASS: TestReverse (0.00s)
=== RUN   TestReverse1
--- PASS: TestReverse1 (0.00s)
PASS
ok      goland-setting/test/fuzzing     0.043s

3. unit单元测试局限性：

  • 每个输入必须由开发人员添加到测试中

4. unit单元测试的优点

  • 可以在线测试！！不像在main方法中进行测试的方式，需要停止程序，然后还要进行注释原有的代码
  • 官方是推荐的，但是这个不够精确！需要精确就使用fuzz测试吧

fuzz模糊测试

  • fuzz测试函数以Fuzz开头而不是Test开头

  • 方法参数和unit单元测试也不同，fuzz模糊测试为:f *testing.F

  • 为了方便，fuzz模糊测试直接在fuzzingToLearn_test.go文件进行

1. 在fuzzingToLearn_test文件中添加模糊测试的代码 - 两个方法测试

// FuzzReverse fuzz测试 字节-字符串反转
func FuzzReverse(f *testing.F) {testcases := []string{"Hello, world", " ", "!123456"}for _, tc := range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//对于字符会出错f.Fuzz(func(t *testing.T, orig string) {rev := Reverse(orig)doubleRev := Reverse(rev)if orig != doubleRev {t.Errorf("Before: %q, after: %q", orig, doubleRev)}if utf8.ValidString(orig) && !utf8.ValidString(rev) {t.Errorf("Reverse produced invalid UTF-8 string %q", rev)}})
}// FuzzReverse1 fuzz测试 字符-字符串反转
func FuzzReverse1(f *testing.F) {testcases := []string{"Hello, world", " ", "!123456"}for _, tc := range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//非utf-8会出错f.Fuzz(func(t *testing.T, orig string) {rev := Reverse1(orig)doubleRev := Reverse1(rev)t.Logf("Number of runes: orig=%d, rev=%d, doubleRev=%d", utf8.RuneCountInString(orig),utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))if orig != doubleRev {t.Errorf("Before: %q, after: %q", orig, doubleRev)}if utf8.ValidString(orig) && !utf8.ValidString(rev) {t.Errorf("Reverse produced invalid UTF-8 string %q", rev)}})
}

2. 终端运行测试

  • 注意事项：
    • 使用fuzz模糊化时，你不能预测预期的输出，因为你不能控制输入
1. 使用终端先使用run test验证是否通过
PS D:\codes\go\goland-setting\test\fuzzing> go test
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
PASS
ok      goland-setting/test/fuzzing     0.041s
2. 使用fuzz模糊测试验证，查看任何随机生成的字符串输入是否会导致失败
# 第一次出错
PS D:\codes\go\goland-setting\test\fuzzing> go test -fuzz=Fuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
testing: will not fuzz, -fuzz matches more than one fuzz test: [FuzzReverse FuzzReverse1]
FAIL
exit status 1
FAIL    goland-setting/test/fuzzing     0.041s# 原因是一个文件只能有一个fuzz的测试例子。注释FuzzReverse1方法测试PS D:\codes\go\goland-setting\test\fuzzing> go test -fuzz=Fuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/58 completed
failure while testing seed corpus entry: FuzzReverse/34d11aca3c8d1e0d
fuzz: elapsed: 0s, gathering baseline coverage: 2/58 completed
--- FAIL: FuzzReverse (0.09s)--- FAIL: FuzzReverse (0.00s)fuzzingToLearn_test.go:54: Reverse produced invalid UTF-8 string "\xab\xb0\xe7"FAIL
exit status 1
FAIL    goland-setting/test/fuzzing     0.134s
# 结果是不通过，即测试失败

  • 结果：测试不通过，即有bug

  • 查看文件同目录产生了新的文件

    在这里插入图片描述

  • 文件内容为：

    go test fuzz v1
string("簫")

  • 这里指的是簫不通过方法的测试。但是我们知道这个方法对于汉字就是有bug，我们先跳过，看一下第二个方法是否可行。

  • testdata目录可以删除的。但建议等完全测试后再删除

3. 使用fuzz模糊测试FuzzReverse1方法，代码改动
  • 由于一个文件不能存在多个fuzz方法，所以先注释上面的FuzzReverse函数的代码,打开FuzzReverse1函数的方法
// FuzzReverse1 fuzz测试 字符-字符串反转
func FuzzReverse1(f *testing.F) {testcases := []string{"Hello, world", " ", "!123456"}for _, tc := range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}//非utf-8会出错f.Fuzz(func(t *testing.T, orig string) {rev := Reverse1(orig)doubleRev := Reverse1(rev)t.Logf("Number of runes: orig=%d, rev=%d, doubleRev=%d", utf8.RuneCountInString(orig),utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))if orig != doubleRev {t.Errorf("Before: %q, after: %q", orig, doubleRev)}if utf8.ValidString(orig) && !utf8.ValidString(rev) {t.Errorf("Reverse produced invalid UTF-8 string %q", rev)}})
}
4. 使用fuzz验证
PS D:\codes\go\goland-setting\test\fuzzing> go test -fuzz=Fuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed
fuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 16 workers
fuzz: minimizing 42-byte failing input file
fuzz: elapsed: 0s, minimizing
--- FAIL: FuzzReverse1 (0.15s)--- FAIL: FuzzReverse1 (0.00s)fuzzingToLearn_test.go:70: Number of runes: orig=1, rev=1, doubleRev=1fuzzingToLearn_test.go:73: Before: "\x86", after: "�"Failing input written to testdata\fuzz\FuzzReverse1\0cca6a19caba34b5To re-run:go test -run=FuzzReverse1/0cca6a19caba34b5
FAIL
exit status 1
FAIL    goland-setting/test/fuzzing     0.525s
# 还是出错了。而且前后两个值不同！！！

  • 同样的还是生成了文件

    在这里插入图片描述

  • 说明FuzzReverse1函数也有bug

诊断代码

  • 经过了解：

    • 在Go语言中，字符串是一个只读的字节片，可以包含非UTF-8有效的字节。原始字符串是一个字节切片，其中有一个字节， '\x86' 。当输入字符串被设置为 []rune 时，Go语言将字节切片编码为UTF-8，并将字节替换为UTF-8字符。当我们将替换UTF-8字符与输入字节片进行比较时，它们显然不相等。

  • 所以，我们需要修改我们的函数代码。但是此处为了保留之前的代码，就直接增加一个函数即可。添加到fuzzingToLearn.go文件，然后再再进行测试该方法即可。

  1. 增加函数Reverse2,内容如下
// Reverse2 排除不是utf-8字符
func Reverse2(input string) (string, error) {if !utf8.ValidString(input) {return input, errors.New("input is not valid UTF-8")}runes := []rune(input)for i, j := 0, len(runes)-1; i < len(runes)/2; i, j = i+1, j-1 {runes[i], runes[j] = runes[j], runes[i]}return string(runes), nil
}
  1. fuzzingToLearn_test.go文件添加对应的fuzz模糊测试函数FuzzReverse2
// 注释FuzzReverse1(f *testing.F)方法，增加下面内容
// fuzz测试 字符串反转 字符，排除非utf-8字符
func FuzzReverse2(f *testing.F) {testcases := []string{"Hello, world", " ", "!123456"}for _, tc := range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}f.Fuzz(func(t *testing.T, orig string) {rev, err1 := Reverse2(orig)if err1 != nil {return // 可以调用 t.Skip()}doubleRev, err2 := Reverse2(rev)if err2 != nil {return // 可以调用 t.Skip()}if orig != doubleRev {t.Errorf("Before: %q, after: %q", orig, doubleRev)}if utf8.ValidString(orig) && !utf8.ValidString(rev) {t.Errorf("Reverse produced invalid UTF-8 string %q", rev)}})
}

  1. 这里就跳过了前面所介绍的两种测试验证，直接进行fuzz模糊测试

  2. 这里是只先验证错误的情况，即新增加的testdata目录下的文件内容情况。使用go test -run命令

PS D:\codes\go\goland-setting\test\fuzzing> go test -run=FuzzReverse1/0cca6a19caba34b5
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
testing: warning: no tests to run
PASS
ok      goland-setting/test/fuzzing     0.357s
# success
  1. 再次运行go test -fuzz=Fuzz
PS D:\codes\go\goland-setting\test\fuzzing> go test -fuzz=Fuzz
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed
fuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 1212471 (404034/sec), new interesting: 32 (total: 35)
fuzz: elapsed: 6s, execs: 2590247 (458435/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 9s, execs: 3933396 (448061/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 12s, execs: 5262110 (442525/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 15s, execs: 6555446 (431581/sec), new interesting: 35 (total: 38)
fuzz: elapsed: 18s, execs: 7789113 (411424/sec), new interesting: 36 (total: 39)
fuzz: elapsed: 21s, execs: 9042454 (416817/sec), new interesting: 36 (total: 39)
fuzz: elapsed: 22s, execs: 9511996 (407607/sec), new interesting: 36 (total: 39)
PASS
ok      goland-setting/test/fuzzing     22.581s
  1. go test -fuzz=Fuzz不会自动停止，需要CTRL + c来停止；或者运行go test -fuzz=Fuzz -fuzztime 20s来指定20s后结束
PS D:\codes\go\goland-setting\test\fuzzing> go test -fuzz=Fuzz -fuzztime 20s
warning: GOPATH set to GOROOT (D:\install\go_install) has no effect
fuzz: elapsed: 0s, gathering baseline coverage: 0/43 completed
fuzz: elapsed: 0s, gathering baseline coverage: 43/43 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 1332436 (442300/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 6s, execs: 2701841 (458040/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 9s, execs: 4096713 (463975/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 12s, execs: 5449685 (451464/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 15s, execs: 6755971 (435062/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 18s, execs: 8075349 (439717/sec), new interesting: 0 (total: 43)
fuzz: elapsed: 20s, execs: 8927301 (403763/sec), new interesting: 0 (total: 43)
PASS
ok      goland-setting/test/fuzzing     20.214s

end

所有的代码：

  • fuzzingToLearn.go
package mainimport ("errors""fmt""unicode/utf8"
)// Reverse 字节 反转字符串
func Reverse(input string) string {bytes := []byte(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}// Reverse1 字符(学习之前以为万事大吉，但是实际上这里仅限于utf-8的字符)
func Reverse1(input string) string {bytes := []rune(input)for i, j := 0, len(bytes)-1; i < len(bytes)/2; i, j = i+1, j-1 {bytes[i], bytes[j] = bytes[j], bytes[i]}return string(bytes)
}// Reverse2 排除不是utf-8字符
func Reverse2(input string) (string, error) {if !utf8.ValidString(input) {return input, errors.New("input is not valid UTF-8")}runes := []rune(input)for i, j := 0, len(runes)-1; i < len(runes)/2; i, j = i+1, j-1 {runes[i], runes[j] = runes[j], runes[i]}return string(runes), nil
}func main() {input := "hello, world , java页, go bigdata"firstRev := Reverse(input)secondRev := Reverse(firstRev)fmt.Printf("原始数据: %q\n", input)fmt.Printf("第一次反转的数据: %q\n", firstRev)fmt.Printf("反转数据再次反转的数据: %q\n", secondRev)firstRev1 := Reverse1(input)secondRev1 := Reverse1(firstRev1)fmt.Printf("第一次反转的数据: %q\n", firstRev1)fmt.Printf("反转数据再次反转的数据: %q\n", secondRev1)firstRev2, firstRev2Err := Reverse2(input)secondRev2, secondRevErr := Reverse2(firstRev2)fmt.Printf("第一次反转的数据: %q, err: %v\n", firstRev2, firstRev2Err)fmt.Printf("反转数据再次反转的数据: %q, err: %v\n", secondRev2, secondRevErr)
}
  • fuzzingToLearn_test.go
package mainimport ("testing""unicode/utf8"
)func TestReverse(t *testing.T) {testcases := []struct {in, want string}{{"Hello, world", "dlrow ,olleH"},{" ", " "},{"!123456", "654321!"},}for _, tc := range testcases {rev := Reverse(tc.in)if rev != tc.want {t.Errorf("Reverse: %q, want %q", rev, tc.want)}}
}func TestReverse1(t *testing.T) {testcases := []struct {in, want string}{{"页Hello, world", "dlrow ,olleH页"},{" ", " "},{"!123456", "654321!"},}for _, tc := range testcases {rev := Reverse1(tc.in)if rev != tc.want {t.Errorf("Reverse: %q, want %q", rev, tc.want)}}
}// FuzzReverse fuzz测试 字节-字符串反转
//func FuzzReverse(f *testing.F) {
//	testcases := []string{"Hello, world", " ", "!123456"}
//	for _, tc := range testcases {
//		f.Add(tc) // Use f.Add to provide a seed corpus
//	}
//	//对于字符会出错
//	f.Fuzz(func(t *testing.T, orig string) {
//		rev := Reverse(orig)
//		doubleRev := Reverse(rev)
//		if orig != doubleRev {
//			t.Errorf("Before: %q, after: %q", orig, doubleRev)
//		}
//		if utf8.ValidString(orig) && !utf8.ValidString(rev) {
//			t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
//		}
//	})
//}// FuzzReverse1 fuzz测试 字符-字符串反转
//func FuzzReverse1(f *testing.F) {
//	testcases := []string{"Hello, world", " ", "!123456"}
//	for _, tc := range testcases {
//		f.Add(tc) // Use f.Add to provide a seed corpus
//	}
//
//	//非utf-8会出错
//	f.Fuzz(func(t *testing.T, orig string) {
//		rev := Reverse1(orig)
//		doubleRev := Reverse1(rev)
//		t.Logf("Number of runes: orig=%d, rev=%d, doubleRev=%d", utf8.RuneCountInString(orig),
//			utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))
//		if orig != doubleRev {
//			t.Errorf("Before: %q, after: %q", orig, doubleRev)
//		}
//		if utf8.ValidString(orig) && !utf8.ValidString(rev) {
//			t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
//		}
//	})
//
//}// fuzz测试 字符串反转 字符，排除非utf-8字符
func FuzzReverse2(f *testing.F) {testcases := []string{"Hello, world", " ", "!123456"}for _, tc := range testcases {f.Add(tc) // Use f.Add to provide a seed corpus}f.Fuzz(func(t *testing.T, orig string) {rev, err1 := Reverse2(orig)if err1 != nil {return // 可以调用 t.Skip()}doubleRev, err2 := Reverse2(rev)if err2 != nil {return // 可以调用 t.Skip()}if orig != doubleRev {t.Errorf("Before: %q, after: %q", orig, doubleRev)}if utf8.ValidString(orig) && !utf8.ValidString(rev) {t.Errorf("Reverse produced invalid UTF-8 string %q", rev)}})
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/205686.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【SQL开发实战技巧】系列（四十九）：Oracle12C常用新特性☞表分区部分索引(Partial Indexes)

【SQL开发实战技巧】系列（四十九）：Oracle12C常用新特性☞表分区部分索引(Partial Indexes)

系列文章目录 【SQL开发实战技巧】系列&#xff08;一&#xff09;:关于SQL不得不说的那些事 【SQL开发实战技巧】系列&#xff08;二&#xff09;&#xff1a;简单单表查询 【SQL开发实战技巧】系列&#xff08;三&#xff09;&#xff1a;SQL排序的那些事 【SQL开发实战技巧…
阅读更多...
数据分析基础之《matplotlib（4）—柱状图》

数据分析基础之《matplotlib（4）—柱状图》

一、柱状图绘制 1、柱状图要素 有类别 2、需求&#xff1a;对比每部电影的票房收入 电影数据如下图所示&#xff1a; 3、matplotlib.pyplot.bar(x, height, width0.8, bottomNone, *, aligncenter, dataNone, **kwargs) 说明&#xff1a; x&#xff1a;有几个类别 height&am…
阅读更多...
玩转Sass：掌握数据类型！

玩转Sass：掌握数据类型！

当我们在进行前端开发的时候&#xff0c;有时候需要使用一些不同的数据类型来处理样式&#xff0c;Sass 提供的这些数据类型可以帮助我们更高效地进行样式开发&#xff0c;本篇文章将为您详细介绍 Sass 中的数据类型。 布尔类型 在 Sass 中&#xff0c;布尔数据类型可以表示逻…
阅读更多...
每日一练：插入排序

每日一练：插入排序

1. 概念及原理 插入排序是一种简单直观的排序算法&#xff0c;其基本思想是将一个元素插入到已经排序好的部分&#xff0c;然后不断地重复这个过程&#xff0c;直到整个数组有序。下面是插入排序的算法原理&#xff1a; 初始状态&#xff1a; 数组被分为已排序和未排序两个部分…
阅读更多...
Qt::UniqueConnection和lambda一块用无效

Qt::UniqueConnection和lambda一块用无效

如果槽函数是lambda。 那么用了Qt::UniqueConnection也会出现槽函数被多次调用的问题。 原因&#xff1a; 参考官方文档&#xff1a; QObject Class | Qt Core 5.15.16https://doc.qt.io/qt-5/qobject.html#connect
阅读更多...
k8s-service 7

k8s-service 7

由控制器来完成集群的工作负载&#xff0c;service&#xff08;微服务&#xff09;是将工作负载的应用暴露出去&#xff0c;从而解决访问问题 作用&#xff1a;无论是在集群内还是集群外&#xff0c;都可以访问pod上的应用&#xff0c;其实现对集群内的应用pod自动发现和负载均…
阅读更多...
jQuery ajax读取本地json文件 三级联动下拉框

jQuery ajax读取本地json文件 三级联动下拉框

步骤 1&#xff1a;创建本地JSON文件 {"departments": [{"name": "会计学院","code": "052"},{"name": "金融学院","code": "053"},{"name": "财税学院",&qu…
阅读更多...
【c】小红的漂亮串

【c】小红的漂亮串

#include<stdio.h> #include<string.h> int main() {char arr[1000];int count0;gets(arr);//在数组中输入字符串int lenstrlen(arr);//求字符串长度printf("%d\n",len);for(int i0;i<len;i){if(arr[i]r){if(arr[i1]e){if(arr[i2]d){countcount1;}}}}…
阅读更多...
ChatGPT可能即将发布新版本，带有debug功能：支持下载原始对话、可视化对话分支等

ChatGPT可能即将发布新版本，带有debug功能：支持下载原始对话、可视化对话分支等

本文原文来自DataLearnerAI官方网站&#xff1a;ChatGPT内置隐藏debug功能&#xff1a;支持下载原始对话、可视化对话分支等 | 数据学习者官方网站(Datalearner) AIPRM的工作人员最近发现ChatGPT的客户端隐藏内置了一个新的debug特性&#xff0c;可以提高ChatGPT对话的问题调试…
阅读更多...
AZURE==SQL managed instances

AZURE==SQL managed instances

创建资源 创建DB 创建完成后&#xff0c;拿着刚才的账号密码依然连接不上 远程连接 需要开启公网访问和开放相关端口 参考Configure public endpoint - Azure SQL Managed Instance | Microsoft Learn 连接成功
阅读更多...
Python源码分享10：使用海龟画图turtle画哆啦A梦

Python源码分享10：使用海龟画图turtle画哆啦A梦

turtle模块是一个Python的标准库之一&#xff0c;它提供了一个基于Turtle graphics的绘图库。Turtle graphics是一种流行的绘图方式&#xff0c;它通过控制一个小海龟在屏幕上移动来绘制图形。 turtle模块可以让您轻松地创建和控制海龟图形&#xff0c;从而帮助您学习Python编…
阅读更多...
使用xshell连接虚拟机（服务器）

使用xshell连接虚拟机（服务器）

作者&#xff1a;余小小 Xshell Xshell [1] 是一个强大的安全终端模拟软件&#xff0c;它支持SSH1, SSH2, 以及Microsoft Windows 平台的TELNET 协议。Xshell 通过互联网到远程主机的安全连接以及它创新性的设计和特色帮助用户在复杂的网络环境中享受他们的工作。 Xshell可以…
阅读更多...
SpringDataJPA基础

SpringDataJPA基础

简介 Spring Data为数据访问层提供了熟悉且一致的Spring编程模版&#xff0c;对于每种持久性存储&#xff0c;业务代码通常需要提供不同存储库提供对不同CURD持久化操作。Spring Data为这些持久性存储以及特定实现提供了通用的接口和模版。其目的是统一简化对不同类型持久性存储…
阅读更多...
华清远见嵌入式学习——QT——作业1

华清远见嵌入式学习——QT——作业1

作业要求&#xff1a; 代码&#xff1a; ①&#xff1a;头文件 #ifndef LOGIN_H #define LOGIN_H#include <QWidget> #include <QLineEdit> //行编辑器类 #include <QPushButton> //按钮类 #include <QLabel> //标签类 #include <QM…
阅读更多...
图像处理之把模糊的图片变清晰

图像处理之把模糊的图片变清晰

1.图片如果是有雾化效果的对图像产生影响的,要先进行图形增强,Retinex是基于深度神经网络了,我在之前图形处理的文章一路从神经网络(概率统计)—>积卷神经网络(对区域进行概率统计,对图片进行切割多个识别对象)–>深度积卷神经网络(RetinexNet也是模拟人脑的处理过程,增加…
阅读更多...
css弹窗动画效果，示例弹窗从底部弹出

css弹窗动画效果，示例弹窗从底部弹出

从底部弹出来&#xff0c;有过渡动画效果 用max-height可以自适应内容的高度&#xff0c;当内容会超过最大高度时可以在弹窗里加个scroll-view 弹窗不能用v-if来隐藏&#xff0c;不然transition没效果&#xff0c;transition只能对已有dom元素起效果&#xff0c;所以用透明和v…
阅读更多...
软件测试入门：静态测试

软件测试入门：静态测试

什么是静态测试 顾名思义&#xff0c;这里的静态是指程序的状态&#xff0c;即在不执行代码的情况下检查软件应用程序中的缺陷。进行静态测试是为了仅早在开发的早期阶段发现程序缺陷&#xff0c;因为这样可以更快速地识别缺陷并低成本解决缺陷&#xff0c;它还有助于查找动态测…
阅读更多...
Elasticsearch从入门到精通

Elasticsearch从入门到精通

Elasticsearch简介 应用开发中一个比较常见的功能是搜索&#xff0c;传统应用的解决方案&#xff1a;数据库的模糊查询。 模糊查询存在的问题&#xff1a; 海量数据下效率低下功能不够丰富&#xff1a;不够智能、不能高亮 Elasticsearch 是一个分布式、RESTful 风格的搜索和数据…
阅读更多...
鸿蒙原生应用/元服务开发-Stage模型能力接口（一）

鸿蒙原生应用/元服务开发-Stage模型能力接口（一）

ohos.app.ability.Ability (Ability基类)一、说明 UIAbility和ExtensionAbility的基类&#xff0c;提供系统配置更新回调和系统内存调整回调。本模块首批接口从API version 9 开始支持。后续版本的新增接口&#xff0c;采用上角标单独标记接口的起始版本。本模块接口仅可在Stag…
阅读更多...
flex布局的flex为1到底是什么

flex布局的flex为1到底是什么

参考博客&#xff1a;flex:1什么意思_公孙元二的博客-CSDN博客 flex&#xff1a;1即为flex-grow&#xff1a;1&#xff0c;经常用作自适应布局&#xff0c;将父容器的display&#xff1a;flex&#xff0c;侧边栏大小固定后&#xff0c;将内容区flex&#xff1a;1&#xff0c;内…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023