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开发实战技巧…
阅读更多...
树莓派学习：socket获取客户端IP地址

树莓派学习：socket获取客户端IP地址

定义 int s_fd;//服务器套接字描述符int c_fd;//客户端套接字描述符int clensizeof(struct sockaddr_in);//地址结构体的大小struct sockaddr_in s_addr;//服务端socket地址结构体memset(&s_addr,0,clen);struct sockaddr_in c_addr;//客户端socket地址结构体memset(&c…
阅读更多...
数据分析基础之《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;布尔数据类型可以表示逻…
阅读更多...
十一.图像处理与光学之图像缩放方式

十一.图像处理与光学之图像缩放方式

十一.图像处理与光学之图像缩放方式(sensor binning模式/ skipping 模式/SOC resize) 文章目录 十一.图像处理与光学之图像缩放方式(sensor binning模式/ skipping 模式/SOC resize)11.1 sensor binning模式11.1.1 2:2 Binning模式11.1.2 Binning用途---**在环境光照低的情况下…
阅读更多...
生信数据分析高效Python代码

生信数据分析高效Python代码

1. Pandas glob获取指定目录下的文件列表 import pandas as pd import globdata_dir "/public/data/" # 获取文件后缀为.txt的文件列表 df_all pd.concat([pd.read_csv(f, sep\t) for f in glob.glob(data_dir *.txt)]) print(df_all)2. 使用 enumerate 函数获取…
阅读更多...
基于Spring Boot和微信小程序开发的点餐系统

基于Spring Boot和微信小程序开发的点餐系统

文章目录 项目介绍主要功能截图：部分代码展示设计总结项目获取方式🍅 作者主页：超级无敌暴龙战士塔塔开 🍅 简介：Java领域优质创作者🏆、 简历模板、学习资料、面试题库【关注我，都给你】 🍅文末获取源码联系🍅 项目介绍 基于Spring Boot和微信小程序开发的点餐…
阅读更多...
每日一练：插入排序

每日一练：插入排序

1. 概念及原理 插入排序是一种简单直观的排序算法&#xff0c;其基本思想是将一个元素插入到已经排序好的部分&#xff0c;然后不断地重复这个过程&#xff0c;直到整个数组有序。下面是插入排序的算法原理&#xff1a; 初始状态&#xff1a; 数组被分为已排序和未排序两个部分…
阅读更多...
GORM 自定义数据类型json-切片（数组）

GORM 自定义数据类型json-切片（数组）

文章目录 自定义数据类型自定义json结构体定义Scaner和Valuer接口的实现插入数据&查询数据 自定义切片存储切片json形式存储字符串存储 创建&查询数据 gorm官方文档&#xff1a;自定义数据类型 自定义数据类型 数据空中很多情况下数据是多变的&#xff0c;我们这篇文章…
阅读更多...
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
阅读更多...
在Go中导入软件包

在Go中导入软件包

引言 对于任何广泛使用的编程语言，乃至整个开源社区来说，在不同项目之间借用和共享代码的能力都是基础。借用代码使程序员能够将大部分时间花在针对自己的需求编写代码上，而且通常他们的一些新代码最终会对其他人有用。然后他们可能决定将这些可重用的部分组织成一个单元，…
阅读更多...
在c和c++中‘-＞‘是什么意思？

在c和c++中‘-＞‘是什么意思？

1.->是什么 箭头符号 -> 通常用于 C、C 和类似的编程语言中&#xff0c;表示指向结构体或类的指针成员的访问。这个符号是一个简写形式&#xff0c;可以看作是两个操作的组合&#xff1a; 解引用&#xff08;dereferencing&#xff09;&#xff1a;通过一个指针来访问它…
阅读更多...
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;}}}}…
阅读更多...
关于如何实现图片懒加载

关于如何实现图片懒加载

图片懒加载的原理&#xff1a; 通过延迟加载图片&#xff0c;只有当图片即将进入可视区域时再进行加载&#xff0c;以优化网页加载速度和性能。 具体的实现步骤如下&#xff1a; 将待加载的图片的 src 属性设置为空或者一个占位符&#xff0c;而不是真实的图片链接。监…
阅读更多...
要求CHATGPT高质量回答的艺术：提示工程技术的完整指南—第 19 章：聚类提示

要求CHATGPT高质量回答的艺术：提示工程技术的完整指南—第 19 章：聚类提示

要求CHATGPT高质量回答的艺术&#xff1a;提示工程技术的完整指南—第 19 章&#xff1a;聚类提示 聚类提示是一种允许模型根据某些特征或特性将相似数据点分组的技术。 具体做法是向模型提供一组数据点&#xff0c;并要求它根据某些特征或特性将这些数据点分组。 这种技术适…
阅读更多...
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编…
阅读更多...
最新文章

Copyright @ 2022~2023