【Go语言】Go语言的数据类型

news2024/11/24 1:30:01

GO 语言的数据类型

Go 语言内置对以下这些基本数据类型的支持：

  • 布尔类型：bool

  • 整型：int8、byte、int16、int、uint、uintptr 等

  • 浮点类型：float32、float64

  • 复数类型：complex64、complex128

  • 字符串：string

  • 字符类型：rune

  • 错误类型：error

GO 语言也支持以下复合类型：

  • 指针（pointer）

  • 数组（array）

  • 切片（slice）

  • 字典（map）

  • 通道（chan）

  • 结构体（struct）

  • 接口（interface）

与其他静态语言相比，Go语言新增了通道类型，该类型主要用于并发编程时不同协程间的通信。

结构体类似于面向对象编程中的类（class），Go语言沿用了C语言的该语法，Go语言还把接口单独作为一个类型提取出来。

1 布尔类型

布尔类型的关键字为bool，可赋值且只可以赋值为预定义常量true和false，示例代码如下：

var v1 bool
v1 = true
v2 := (1 == 2) // v2 也会被推导为 bool 类型
fmt.Println("布尔类型初始化打印===")
fmt.Println(v1, v2)

代码运行测试

Go语言是强类型语言，变量类型一旦确定，就不能够将其他类型的值赋值给该变量，因此，布尔类型不能接受其它类型的赋值，也不支持自动或强制的类型转换。以下操作会导致Go语言的编译错误：

var b bool
b = 1
b = boo1(1)

Go 语言中，不同类型的值不能使用 == 或 != 运算符进行比较，在编译期就会报错，示例代码如下：

b := (false == 0)

在编译期报错：

2 整型和运算符

2.1 整型

整型是所有编程语言中最基础的数据类型，Go语言默认支持如下整型类型：

类型长度（单位：字节）说明值范围默认值
int81带符号8位整型-128~1270
uint81无符号8位整型，与 byte 类型等价0~2550
int162带符号16位整型-32768~327670
uint162无符号16位整型0~655350
int324带符号32位整型，与 rune 类型等价-2147483648~21474836470
uint324无符号32位整型0~42949672950
int648带符号64位整型-9223372036854775808~92233720368547758070
uint648无符号64位整型0~184467440737095516150
int32位或64位与具体平台相关与具体平台相关0
uint32位或64位与具体平台相关与具体平台相关0
uintptr与对应指针相同无符号整型，足以存储指针值的未解释位32位平台下为4字节，64位平台下为8字节0

Go语言针对整型类型划分较多，可以根据需要选择适合的类型以节省内存开支。

注：

  • 如未注明整型的类型，Go语言默认设置

  • Go语言中，这些整型都是不同的数据类型，例如 int 和 int32 在Go语言中被认为是不同的数据类型，编译器也不会自动进行类型转换，如下类似的操作就会报错：

var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 := 8
intValue1 = intValue2 // 编译错误，intValue1是int8类型，intValue2是int类型

编译运行报错

使用强制类型转换可以解决这个编译错误：

var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 := 8
intValue1 = int8(intValue2)

这里出现了一个错误 intValue1 declared and not used，如果出现该错误，建议在赋值语句前添加 _ 来忽略这个报错。

var intValue1 int8
intValue2 := 8 // Go语言会将未声明的数字默认为int类型
// intValue1 = intValue2       // 编译错误，intValue1是int8类型，intValue2是int类型
_ = intValue1 //忽略 declared and not used 错误
intValue1 = int8(intValue2) // 正确，将intValue2转换为int8类型
fmt.Printf("intValue1:%d, intValue2:%d\n", intValue1, intValue2)

我们还可以通过 intValue := uint8(intValue2) 这种方式同时完成类型转化和赋值操作。

2.2 运算符

2.2.1 算术运算符

GO 语言支持所有常规的整数四则运算：+、-、*、/ 和 %（取余只能用于整数），由于 GO 语言是强类型语言，不同类型的整型值不能够直接进行运算，否则会报错。

intValue3 := intValue1 + intValue2 // int + int8

intValue3 := int(intValue1) + intValue2 // 使用强类型进行转换

此外，也需要注意整型的溢出

var intValue1 int8
intValue1 = 128 // int8 可取值的范围在 -128~127

Go 语言中也支持自增/自减运算符，即 ++、--，是只能作为语句，不能作为表达式，且只能用作后缀，不能放到变量前面：

intValue1 := 10
intValue1++ // 有效，intValue1 的值变成 11
intValue1-- // 有效，intValue1 的值变成 10
intValue1 = intValue1++ // 无效，编译报错
--intValue1  // 无效，编译报错

同样支持+=、-=、*=、/=、%= 这种快捷写法：

intValue1, intValue2 := 10, 20
intValue1 += intValue2
intValue1 -= intValue2
intValue1 *= intValue2
intValue1 /= intValue2
intValue1 %= 3

2.2.2 比较运算符

Go 语言支持以下几种常见的比较运算符： >、<、==、>=、<= 和 !=，比较运算符运行的结果是布尔值。

intValue1, intValue2 := 10, 20
    if intValue1 <= intValue2 {
        fmt.Println("intValue1 <= intValue2")
    }

需要注意，不同的整型类型同样不能够使用比较运算符，但所有的比较运算都可以直接和数字进行比较。

var intValue3 int8 = 10
if intValue3 == 10 {
    fmt.Println("intValue3 == 10")
}
// 需要注意溢出的问题，这里的直接比较是编译自动进行的转换
// 编译报错：128 (untyped int constant) overflows int8
if intValue3 == 128 {
    fmt.Println("intValue3 == 128")
}
2.2.3 位运算符

Go 语言支持以下这几种位运算符：

运算符含义结果
x & y按位与把 x 和 y 都为 1 的位设为 1
x | y按位或把 x 或 y 为 1 的位设为 1
x ^ y按位异或把 x 和 y 一个为 1 一个为 0 的位设为 1
^x按位取反把 x 中为 0 的位设为 1，为 1 的位设为 0
x << y左移把 x 中的位向左移动 y 次，每次移动相当于乘以 2
x >> y右移把 x 中的位向右移动 y 次，每次移动相当于除以 2

位运算符代码测试：

var intValue1 uint8
var intValue2 uint8
intValue1 = 255                                            // 1111 1111
intValue2 = 0                                              // 0000 0000
fmt.Println("intValue1 & intValue2:", intValue1&intValue2) // 按位与，0
fmt.Println("intValue1 | intValue2:", intValue1|intValue2) // 按位或，255
fmt.Println("intValue1 ^ intValue2:", intValue1^intValue2) // 按位异或，255
fmt.Println("^intValue1:", ^intValue1)                     // 按位取反 0
fmt.Println("intValue1 << 1:", intValue1<<1)               // 左移1位，254
fmt.Println("intValue1 >> 1:", intValue1>>1)               // 右移1位，127

2.2.3 逻辑运算符

Go语言支持以下逻辑运算符：

运算符含义结果
x && y逻辑与运算符（AND）如果 x 和 y 都是 true，则结果为 true，否则结果为 false
x || y逻辑或运算符（OR）如果 x 或 y 是 true，则结果为 true，否则结果为 false
!x逻辑非运算符（NOT）如果 x 为 true，则结果为 false，否则结果为 true

代码运行测试：

intValue1, intValue2 := 10, 20
if intValue1 > 0 && intValue2 > 0 {
    fmt.Println("intValue1 > 0 && intValue2 > 0")
}
​
if intValue1 > 15 || intValue2 > 15 {
    fmt.Println("intValue1 > 15 || intValue2 > 15")
}
​
fmt.Println("!(intValue1 > 15):", !(intValue1 > 15))

2.2.3 运算符优先级
// 优先级自高向低进行排列
^（按位取反） !
*  /  %  <<  >>  &  &^
+  -  |  ^（按位异或）
==  !=  <  <=  >  >=
&&
||

3 浮点型与复数类型

3.1 浮点型

3.1.1 浮点型的表示

浮点型也叫浮点数，用于表示包含小数点的数据，比如 3.14、1.00 都是浮点型数据。

Go语言中的浮点数采用 IEEE-754 标准的表达式，定义了两个类型：float32 和 float64，其中float32是单精度浮点数，可以精确到小数点后7位（类似于PHP、Java等语言的float类型），float64是双精度浮点数，可以精确到小数点后15位（类似于PHP、Java等语言的double类型）。

Go语言中，定义一个浮点型变量的代码如下：

var floatValue1 float32
floatValue1 = 10
floatValue2 := 10.0 // 如果不加小数点，floatValue2 会被推导为整型而不是浮点型
floatValue3 := 1.1e-10

对于浮点类型需要被自动推导的变量，其类型将被自动设置为 float64，而不管赋值给它的数字是否是用 32 位长度表示的。因此，对于以上的例子，下面的赋值将导致编译错误：

floatValue1 = floatValue2

floatValue1 = float32(floatValue2)  // 不同浮点类型的赋值，必须要进行类型强制转换

在实际的开发中，应该尽可能地使用 float64 类型，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。

3.1.2 浮点数的精度

浮点数不是一种精确的表达方式，因为二进制无法精确表示所有十进制小数，比如 0.1、0.7 这种，如下代码进行演示：

floatValue4 := 0.1
floatValue5 := 0.7
floatValue6 := floatValue4 + floatValue5 // 浮点数的操作同样严格规范类型，float32 和 float64不能够直接进行计算

0.1 + 0.7 输出结果并不是我们所想的0.8，这是因为计算机底层将十进制的 0.1 和 0.7 转化为二进制表示时，会丢失精度，因此在实践中，通常会建议避免直接比较浮点数是否相等，而是使用一个小的容忍度（epsilon）来检查它们是否足够接近。

floatValue4 := 0.1
    floatValue5 := 0.7
    floatValue6 := floatValue4 + floatValue5
​
    epsilon := 1e-10
    sum := 0.8
    if math.Abs(sum-floatValue6) < epsilon {
        fmt.Println("sum and c are approximately equal")
    } else {
        fmt.Println("sum and c are not equal")
    }

3.1.3 浮点数的比较

浮点数支持通过算术运算符进行四则运算，也支持通过比较运算符进行比较（前提是运算符两边的操作数类型一致），但是涉及到相等的比较除外，因为我们上面提到，看起来相等的两个十进制浮点数，在底层转化为二进制时会丢失精度，因此不能被表象蒙蔽。

如果一定要判断浮点数的相等，除去上面提到的精度，也可以使用 math.Dim() 方法：

floatValue1 := 0.1
floatValue2 := 0.1
p := 0.00001
// 判断 floatValue1 与 floatValue2 是否相等
if math.Dim(float64(floatValue1), floatValue2) < p {
    fmt.Println("floatValue1 和 floatValue2 相等")
}

因此判断两个浮点数是否相同，在Go语言中是通过判断两者相差的精度值，其他语言中的浮点数判断也是如此。

3.2 复数类型

除了整型和浮点型之外，Go 语言还支持复数类型，与复数相对，我们可以把整型和浮点型这种日常比较常见的数字称为实数，复数是实数的延伸，可以通过两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag），常见的表达形式如下：

z = a + bi

其中 a、b 均为实数，i 称为虚数单位，当 b = 0 时，z 就是常见的实数，当 a = 0 而 b ≠ 0 时，将 z 称之为纯虚数。

在 Go 语言中，复数支持两种类型：complex64（32 位实部和虚部） 和 complex128（64 位实部与虚部），对应的示例如下，和数学概念中的复数表示形式一致：

var complexValue1 complex64        
complexValue1 = 1.10 + 10i          // 由两个 float32 实数构成的复数类型
complexValue2 := 1.10 + 10i         // 和浮点型一样，默认自动推导的实数类型是 float64，所以 complexValue2 是 complex128 类型
complexValue3 := complex(1.10, 10)  // 与 complexValue2 等价

对于一个复数 z = complex(x, y)，就可以通过 Go 语言内置函数 real(z) 获得该复数的实部，也就是 x，通过 imag(z) 获得该复数的虚部，也就是 y。

real := real(complexValue1) // 获取复数的实部
imag := imag(complexValue1) // 获取复数的虚部

复数支持和其它数字类型一样的算术运算符。当你使用 == 或者 != 对复数进行比较运算时，由于构成复数的实数部分也是浮点型，需要注意对精度的把握。

更多关于复数的函数，请查阅 math/cmplx 标准库的文档。如果你对内存的要求不是特别高，最好使用 complex128 作为计算类型，因为相关函数大都使用这个类型的参数。

4 字符串及底层字符类型

4.1 字符串

在 Go 语言中，字符串是一种基本类型，默认是通过 UTF-8 编码的字符序列，当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，比如中文编码通常需要 3 个字节。

4.1.1 声明和初始化：
var str string         // 声明字符串变量
str = "Hello World"    // 变量初始化
str2 := "Hello World"  // 也可以同时进行声明和初始化

也能够对这些字符串进行格式化输出：

fmt.Printf("The length of \"%s\" is %d \n", str, len(str))

如下表格是格式化所使用的一些参数

动词功能
%v按值的本来值输出
%+v在 % v 基础上，对结构体字段名和值进行展开
%#v输出 Go 语言语法格式的值
%T输出 Go 语言语法格式的类型和值
%%输出 % 本体
%b整型以二进制方式显示
%o整型以八进制方式显示
%d整型以十进制方式显示
%x整型以十六进制方式显示
%X整型以十六进制、字母大写方式显示
%UUnicode 字符
%f浮点数
%p指针，十六进制方式显示

虽然可以通过下标访问字符串中的字符，但是和数组不同，在Go语言中，字符串一旦初始化之后，不允许被修改。

注意，这里只是字符串中的字符不能被修改，你可以整体修改字符串。

4.1.2 转义字符

Go 语言的字符串不支持单引号，只能通过双引号定义字符串字面值，如果要对特定字符进行转义，可以通过 \ 实现，就像我们上面在字符串中转义双引号和换行符那样，常见的需要转义的字符如下所示：

  • \n ：换行符

  • \r ：回车符

  • \t ：tab 键

  • \u 或 \U ：Unicode 字符

  • \\ ：反斜杠自身

此外，也可以通过如下方法在字符串中包含引号。

label := `'Search' results for "Golang":`

多行字符串，也可以通过``构建。

results := `Search results for "Golang":
    - Go
    - Golang
    - Golang Programming
    `
fmt.Println(results)

也可以使用 + 进行字符串的拼接

results = "Search results for \"Golang\":\n" +
        "- Go\n" +
        "- Golang\n" +
        "- Golang Programming\n"
fmt.Printf("%s", results)

4.1.3 字符串操作

字符串连接

Go 内置提供了丰富的字符串函数，常见的操作包含连接、获取长度和指定字符，获取长度和指定字符前面已经介绍过，字符串连接只需要通过 + 连接符即可：

str := "Hello"
str = str + ", World"
str += ", World"  // 上述语句也可以简写为这样，效果完全一样

此外，字符串可能过长，会出现换行的情况，+务必保证出现在上一行。

str = str + 
    ", World"

字符串切片

在 Go 语言中，可以通过字符串切片实现获取子串的功能。

str := "hello, world"
str1 := str[:5]  // 获取索引5（不含）之前的子串
str2 := str[7:]  // 获取索引7（含）之后的子串
str3 := str[0:5]  // 获取从索引0（含）到索引5（不含）之间的子串
fmt.Println("str1:", str1)
fmt.Println("str2:", str2)
fmt.Println("str3:", str3)

字符串遍历

Go 语言支持两种方式遍历字符串。

// 方式一：字节数组遍历
str := "Hello, 世界" 
n := len(str) 
for i := 0; i < n; i++ {
    ch := str[i]    // 依据下标取字符串中的字符，ch 类型为 byte
    fmt.Println(i, ch) 
}
// 方式二：unicode字符遍历
str := "Hello, 世界" 
for i, ch := range str { 
    fmt.Println(i, ch)    // ch 的类型为 rune 
}

可以看出，这个字符串长度为 13，尽管从直观上来说，这个字符串应该只有 9 个字符。这是因为每个中文字符在 UTF-8 中占 3 个字节，而不是 1 个字节。

这个时候，打印的就是 9 个字符了，因为以 Unicode 字符方式遍历时，每个字符的类型是 rune，而不是 byte。

这里的 rune 和 byte 也即Go语言底层字符类型。

  • byte，代表 UTF-8 编码中单个字节的值（它也是 uint8 类型的别名，两者是等价的，因为正好占据 1 个字节的内存空间）；

  • rune，代表单个 Unicode 字符（它也是 int32 类型的别名，因为正好占据 4 个字节的内存空间）。

5 基本数据类型之间的转化

5.1 整型之间的转化

在进行类型转化时只需要调用要转化的数据类型对应的函数即可：

v1 := uint(16)   // 初始化 v1 类型为 unit
v2 := int8(v1)   // 将 v1 转化为 int8 类型并赋值给 v2
v3 := uint16(v2) // 将 v2 转化为 uint16 类型并赋值给 v3

由高向低转换时，需要注意整数的溢出

v1 := uint(-255) // uint 是无符号整型，在编译时这里会产生溢出

v4 := int16(-255) // 这里也要注意溢出，如这里是int8(-255)就会报错

5.2 整型和浮点数之间的转化

v1 := 99.99
v2 := int(v1)  // 浮点数转化为整型，小数点后的数字直接被抛弃
​
v3 := 99
v4 := float64(v3) // 整型转化为浮点数，直接调取对应的类型即可

5.3 数值和浮点数的转换

目前 Go 语言不支持将数值类型转化为布尔型，需要自己根据需求去实现类似的转化。

5.4 字符串和其他基本类型之间的转化

5.4.1 整型转化成字符串

整型数据可以通过 Unicode 字符集转化为对应的 UTF-8 编码的字符串：

v1 := 65
v2 := string(v1)  // v2 = A
v3 := 30028
v4 := string(v3)

5.4.2 strconv 包

Go 语言默认不支持将字符串类型强制转化为数值类型，即使字符串中包含数字也不行。

如果要实现更强大的基本数据类型与字符串之间的转化，可以使用 Go 官方 strconv 包提供的函数：

v1 := "100"
v2, _ := strconv.Atoi(v1) // 将字符串转化为整型，v2 = 100
v3 := 100
v4 := strconv.Itoa(v3) // 将整型转化为字符串, v4 = "100"
v5 := "true"
v6, _ := strconv.ParseBool(v5) // 将字符串转化为布尔型
v5 = strconv.FormatBool(v6)    // 将布尔值转化为字符串
v7 := "100"
v8, _ := strconv.ParseInt(v7, 10, 64)  // 将字符串转化为整型，第二个参数表示进制，第三个参数表示最大位数
v7 = strconv.FormatInt(v8, 10)         // 将整型转化为字符串，第二个参数表示进制
v9, _ := strconv.ParseUint(v7, 10, 64) // 将字符串转化为无符号整型，参数含义同 ParseInt
v7 = strconv.FormatUint(v9, 10)        // 将无符号整数型转化为字符串，参数含义同 FormatInt
v10 := "99.99"
v11, _ := strconv.ParseFloat(v10, 64) // 将字符串转化为浮点型，第二个参数表示精度
v10 = strconv.FormatFloat(v11, 'E', -1, 64)
q := strconv.Quote("Hello, 世界")       // 为字符串加引号
q = strconv.QuoteToASCII("Hello, 世界") // 将字符串转化为 ASCII 编码

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

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

相关文章

嵌入式学习 Day21

嵌入式学习 Day21

一. 文件IO: 1. lseek off_t lseek(int fd, off_t offset, int whence); 功能: 重新设定文件描述符的偏移量 参数: fd:文件描述符 offset:偏移量 whence: SEEK_SET 文件开头 …
阅读更多...
基于STM32F407的coreJSON使用教程

基于STM32F407的coreJSON使用教程

目录 概述 工程建立 代码集成 函数介绍 使用示例 概述 coreJSON是FreeRTOS中的一个组件库&#xff0c;支持key查找的解析器&#xff0c;他只是一个解析器&#xff0c;不能生成json数据。同时严格执行 ECMA-404 JSON 标准。该库用 C 语言编写&#xff0c;设计符合 ISO C90…
阅读更多...
杨氏矩阵和杨辉三角

杨氏矩阵和杨辉三角

杨氏矩阵 有一个数字矩阵&#xff0c;矩阵的每行从左到右是递增的&#xff0c;矩阵从上到下是递增的&#xff0c;请编写程序在这样的矩阵中查找某个数字是否存在。 要求&#xff1a;时间复杂度小于O(N); 分析 若要满足要求时间复杂度小于O(N)&#xff0c;就不能每一行一个个…
阅读更多...
机器学习基础（一）理解机器学习的本质

机器学习基础（一）理解机器学习的本质

导读&#xff1a;在本文中&#xff0c;将深入探索机器学习的根本原理&#xff0c;包括基本概念、分类及如何通过构建预测模型来应用这些理论。 目录 机器学习 机器学习概念 相关概念 机器学习根本&#xff1a;模型 数据的语言&#xff1a;特征与标签 训练与测试&#xf…
阅读更多...
elementui 中 el-date-picker 控制选择当前年之前或者之后的年份

elementui 中 el-date-picker 控制选择当前年之前或者之后的年份

文章目录 需求分析 需求 对 el-date-picker控件做出判断控制 分析 给 el-date-picker 组件添加 picker-options 属性&#xff0c;并绑定对应数据 pickerOptions html <el-form-item label"雨量年份&#xff1a;" prop"date"><el-date-picker …
阅读更多...
正整数A+B（PTA团体天题练习题）细节题刨析

正整数A+B（PTA团体天题练习题）细节题刨析

哎呀&#xff0c;又是看似简单的AB模型&#xff0c;这题确实也是AB&#xff0c;不过这个题让我debug1个多小时才找出来问题所在&#xff0c;服了&#xff0c;真是所谓细节决定成败&#xff0c;这题也挺值得记录下来的&#xff0c;话不多嗦&#xff0c;看题 题的目标很简单&…
阅读更多...
[ansible] playbook运用

[ansible] playbook运用

一、复习playbook剧本 --- - name: first play for install nginx #设置play的名称gather_facts: false #设置不收集facts信息hosts: webservers:dbservers #指定执行此play的远程主机组remote_user: root #指定执行此play的用…
阅读更多...
css3的var()函数

css3的var()函数

css3的var()函数 变量要以两个连字符--(横杆)(减号)为开头 变量可以在:root{}中定义, :root可以在css中创建全局样式变量。通过 :root本身写的样式&#xff0c;相当于 html&#xff0c;但优先级比后者高。 在CSS3中&#xff0c;var()函数是一个用于插入CSS自定义属性&#xff…
阅读更多...
如何创建WordPress付款表单(简单方法)

如何创建WordPress付款表单(简单方法)

您是否正在寻找一种简单的方法来创建付款功能WordPress表单&#xff1f; 小企业主通常需要创建一种简单的方法来在其网站上接受付款&#xff0c;而无需设置复杂的购物车。简单的付款表格使您可以轻松接受自定义付款金额、设置定期付款并收集自定义详细信息。 在本文中&#x…
阅读更多...
QT编写工具基本流程(自用)

QT编写工具基本流程(自用)

以后有人让你写工具的时候&#xff0c;可以方便用这个模版及时提高工作效率&#xff0c;可以争取早点下班。包含库目录&#xff0c;头文件目录&#xff0c;输出目录以及翻译和部署&#xff0c;基本上都全了&#xff0c;也可以做收藏用用。 文章目录 1、创建项目Dialog Widget都…
阅读更多...
Vue | （三）使用Vue脚手架（上） | 尚硅谷Vue2.0+Vue3.0全套教程

Vue | （三）使用Vue脚手架（上） | 尚硅谷Vue2.0+Vue3.0全套教程

文章目录 &#x1f4da;初始化脚手架&#x1f407;创建初体验&#x1f407;分析脚手架结构&#x1f407;关于render&#x1f407;查看默认配置 &#x1f4da;ref与props&#x1f407;ref属性&#x1f407;props配置项 &#x1f4da;混入&#x1f4da;插件&#x1f4da;scoped样…
阅读更多...
element-plus日期选择器2次封装

element-plus日期选择器2次封装

预期效果 官网默认样式&#xff1a; 修改后的样式&#xff1a; 代码实现 DatePicker.vue <template><div class"date-picker-container"><el-date-picker v-model"date" change"handleChange" type"date" value-for…
阅读更多...
TypeScript中的Omit、Pick、Partial、Required类型

TypeScript中的Omit、Pick、Partial、Required类型

首先有这么个人员接口 interface IInfo {name: string; // 姓名age: number; // 年龄height: string; // 身高phone: string; // 联系电话email: string; // 邮箱 } 1. Omit Omit类型可以从一个对象类型中 忽略某些属性 假设我们使用IInfo接口&#xff0c;但是不想要其中p…
阅读更多...
OpenAI文生视频物理世界模型——Sora降世，AI视频领域降维打击令五大行业一夜变天！

OpenAI文生视频物理世界模型——Sora降世，AI视频领域降维打击令五大行业一夜变天！

年初六&#xff0c;OpenAI发布了“文生视频”的工具&#xff0c;Sora。AI技术变革又一次震撼了整个世界。或许你又开始担心&#xff0c;AI发展那么快&#xff0c;将会取代自己。但请记住&#xff0c;危机时代也是变革时代&#xff0c;变革就是机会。开工第一天&#xff0c;相信…
阅读更多...
搜狗的workflow的简单使用

搜狗的workflow的简单使用

workflow是一个网络库&#xff0c;是一个基于C在在线服务引擎 GitHub官网 运行hello world 1,创建一个server&#xff0c;构造函数入参传入一个入参是task的lamda函数&#xff0c;函数的内容会拿到response&#xff0c;并且可以在response中写body 2、server启动&#xff0c;…
阅读更多...
Vue中$root的使用方法

Vue中$root的使用方法

查看本专栏目录 关于作者 还是大剑师兰特&#xff1a;曾是美国某知名大学计算机专业研究生&#xff0c;现为航空航海领域高级前端工程师&#xff1b;CSDN知名博主&#xff0c;GIS领域优质创作者&#xff0c;深耕openlayers、leaflet、mapbox、cesium&#xff0c;canvas&#x…
阅读更多...
XR行业首家｜李未可科技通过深度合成服务算法备案

XR行业首家｜李未可科技通过深度合成服务算法备案

2月18日&#xff0c;国家网信办发布第四批深度合成服务算法备案。 根据《互联网信息服务深度合成管理规定》第十九条规定&#xff0c;具有舆论属性或者社会动员能力的深度合成服务提供者&#xff0c;应当按照《互联网信息服务算法推荐管理规定》履行备案和变更、注销备案手续。…
阅读更多...
探索海洋世界，基于YOLOv5全系列【n/s/m/l/x】参数模型开发构建海洋场景下海洋生物检测识别分析系统

探索海洋世界，基于YOLOv5全系列【n/s/m/l/x】参数模型开发构建海洋场景下海洋生物检测识别分析系统

前面的博文中&#xff0c;开发实践过海底相关生物检测识别的项目&#xff0c;对于海洋场景下的海洋生物检测则很少有所涉及&#xff0c;这里本文的主要目的就是想要开发构建基于YOLOv5的海洋场景下的海洋生物检测识别系统。 前文相关的开发实践如下&#xff0c;感兴趣的话可以…
阅读更多...
【DDD】学习笔记-应用服务

【DDD】学习笔记-应用服务

Eric Evans 为运用领域驱动设计的系统架构划定了层次&#xff0c;在领域层和展现层之间引入了应用层&#xff08;Application Layer&#xff09;&#xff1a;“应用层要尽量简单&#xff0c;不包含业务规则或者知识&#xff0c;而只为下一层&#xff08;指领域层&#xff09;中…
阅读更多...
左右联动布局效果

左右联动布局效果

效果图&#xff1a; <template><el-dialog :modelValue"modelValue" :before-close"close" fullscreen :close-on-click-modal"false"><div class"farmer_detail"><div class"info_content"><di…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023