8、数据结构-字符串、编码集

news2024/10/6 2:23:59

编码表

中文编码表

​ 数字到中文单一字符的映射，汉字只能使用多字节的2字节，总有65535种状态。常见的中文编码有GB2312 、GBK 、GB18030 、BIG 5。

​ 所有编码表都兼容单字节的ASCII表。

UNICODE

​ 多字节，一张编码表解决全球多数字符对应问题

​ 表示汉字多数使用2个字节

​ Go中’x’方式，保存int32 rune整数值，%c打印通过Unicode编码表找到字符输出

​ 因为字符是int32 rune类型，所以是4字节，但是汉字只占2个字节

func main() {
	var s1 = 'x'
	fmt.Println(s1)
	fmt.Printf("%c", s1)

}
120
x

UTF-8

​ 多字节

​ 汉字转化为3个字节

​ utf8mb4

​ 字符串，字符序列，每个汉字就是utf8编码的，也就是汉字是3个字节

乱码问题：编码和解码用得不是一套编码表

ASCII

在这里插入图片描述

ascii码总有有 128位，用来表示常用的字符。

在这里插入图片描述

注意：这里的1指的是字符1，不是数字1

UTF-8、GBK都兼容了ASCII

"a\x09b\x0ac \x31\x20\x41\x61" 表示什么？
"a	b
c 1 Aa"

'A' > 'a'  谁大？字符比较
	if 'A' > 'a' {
		fmt.Println("A大")
	} else {
		fmt.Println("a大")
	}
a大		本质比较的是在ascii中A和a对应的编码值

"a" > "A"  谁大？字符串比较 同上
"AA" > "Aa" 谁大？先比较第一位，第一位相同在比较第二位

字符

​ 本质上来说，计算机中一切都是字节的，字符串也是多个字节组合而成，就是多个字节形成的有序序列。但是对于多字节编码的中文来说，用一个字节描述不了，需要多个字节表示一个字符，Go提供了rune类型。

  • byte：兼容ASCII码的字符，是byte类型，即uint8别名，占用1个字节
  • rune： 汉字等字符，unicode编码，是rune类型，即int32别名，占用4个字节
  • 一个字符字面量使用单引号引起来

字符串与字节序列的转换

func main() {
	s1 := "abc"
	s2 := "测试"
	fmt.Println(len(s1), len(s2))
}
3 6 
//结论：在字符串中，中文一个汉字占3个字节

// 强制类型转换 string => []byte; string => []rune
// 注意[]byte表示字节序列；[]rune表示rune序列
func main() {
	s1 := "abc"
	 s2 := "测试"
	fmt.Println([]byte(s1))
	fmt.Println([]rune(s1))
}
[97 98 99]
[97 98 99]


func main() {
	s2 := "测试" 
	fmt.Println([]byte(s2))		 // utf-8 bytes，长度为6即6个字节
	fmt.Println([]rune(s2))		// unicode切片，长度为2，每个元素4字节
}
[230 181 139 232 175 149]
[27979 35797]
//结论：汉字转字节  在字符串中，一个汉字对应3个字节 所以测试是6个字节

func main() {
	fmt.Printf("%x, %x\n", 27979, 35797) //转16进制
	fmt.Printf("%c%c\n", 27979, 35797)

}
6d4b, 8bd5   
测试

// []byte => string
func main() {
	fmt.Println(string([]byte{49, 65, 97}))
}
1Aa 
//结论：在ASCII中查询对应的值

// []rune => string
测试
//结论：rune使用unicode，但是字符串内部使用utf-8

重点 

func main() {
	var s2 = "测试"
	fmt.Println(s2[0], s2[1], s2[2])
}
230 181 139
//结论：是按照字节的形式取出来的

string(一个整数)，强制类型转换一个整数，相当于把整数当unicode码，去查一个字符，最后返回
字符串
string(整数序列)，强制类型转换一个整数序列，也是转成字符串

字符串

  • 字面常量，只读，不可变
  • 线性数据结构，可以索引
  • 值类型
  • utf-8编码

长度

​ 使用内建函数len，返回字符串占用的字节数。时间复杂度为O(1)，字符串是字面常量，定义时已经知道长度，记录下来即可

索引

​ 不支持负索引，索引范围[0, len(s)-1]。

​ 即使是有中文，索引指的是按照 字节的偏移量。

​ 时间复杂度O(1)，使用索引计算该字符相对开头的偏移量即可。

​ 对于顺序表来说，使用索引效率查找效率是最高的。

​ s[i] 获取索引i处的UTF-8编码的一个字节。

遍历

C风格使用索引遍历，相当于字节遍历

func main() {
	s := "ZFL努力学习编程"
	for i := 0; i < len(s); i++ {
		fmt.Printf("%d, %T, %[2]d %[2]c\n", i, s[i])
	}
}
0, uint8, 90 Z
1, uint8, 70 F
2, uint8, 76 L
3, uint8, 229 å
4, uint8, 138 Š
5, uint8, 170 ª
6, uint8, 229 å
7, uint8, 138 Š
8, uint8, 155 ›
9, uint8, 229 å
10, uint8, 173 ­
11, uint8, 166 ¦
12, uint8, 228 ä
13, uint8, 185 ¹
14, uint8, 160  
15, uint8, 231 ç
16, uint8, 188 ¼
17, uint8, 150 –
18, uint8, 231 ç
19, uint8, 168 ¨
20, uint8, 139 ‹
//这是以字节遍历的 因为汉字是3个字节 所以后面的%c会看不懂

func main() {
	s := "ZFL努力学习编程"
	for i, v := range s {
		fmt.Printf("%d: %[3]d %[3]c\n", i, s[i], v)
	}
}
0: 90 Z
1: 70 F
2: 76 L
3: 21162 努
6: 21147 力
9: 23398 学
12: 20064 习
15: 32534 编
18: 31243 程
//结论：高级for循环是遍历字符的。   因为字符是rune类型，所以查找表，将对应的值输出来

strings库

字符串是字面常量，不可修改，很多操作都是返回新的字符串

拼接

常用的四种：

  • join：使用间隔符拼接字符串切片
  • Builder：多次拼接，推荐
  • fmt.Sprintf：方便快捷，推荐
  • 直接通过+来拼接
func main() {
	s0 := "zfl"
	s1 := "努力学习编程"
	s2 := s0 + s1
	fmt.Println(s2)
}
zfl努力学习编程

func main() {
	s0 := "zfl"
	s1 := "努力学习编程"
	s3 := strings.Join([]string{s0, s1}, "")
	fmt.Println(s3)
}
zfl努力学习编程

func main() {
	s0 := "zfl"
	s1 := "努力学习编程"
	s4 := fmt.Sprintf("%s%s\n", s0, s1)
	fmt.Println(s4)
}
zfl努力学习编程

//多次拼接
func main() {
	s0 := "zfl"
	s1 := "努力学习编程"
	var b strings.Builder
	b.WriteString(s0)
	b.WriteByte('-')
	b.WriteString(s1)
	s5 := b.String()
	fmt.Println(s5)
}
zfl-努力学习编程

结论：简单拼接字符串常用+、fmt.Sprintf。如果手里正好有字符串的序列，可以考虑Join。如果反复多次拼接，strings.Builder是推荐的方式。

查询

  • Index：从左至右搜索，返回子串第一次出现的字节索引位置。未找到，返回-1。子串为空，也返回0。
  • LastIndex：从右至左搜索，返回子串第一次出现的字节索引位置。未找到，返回-1。
  • IndexByte、IndexRune与Index类似；LastIndexByte与LastIndex类似。
  • IndexAny：从左至右搜索，找到给定的字符集字符串中任意一个字符就返回索引位置。未找到返回-1。
  • Contains方法本质上就是Index方法，只不过返回bool值，方便使用bool值时使用。
  • LastIndexAny与IndexAny搜索方向相反。
  • Count：从左至右搜索子串，返回子串出现的次数

时间复杂度是O(n)，效率不高，该用则用，但要少用。>

//Index：从左至右搜索，返回子串第一次出现的字节索引位置。未找到，返回-1。子串为空，也返回0。
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.Index(s0, "学"))

}
9
结论：一个汉字三个字节，所以为9
​~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~``
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.Index(s0, "学"))
	fmt.Println(strings.Index(s0, "龙"))
}
-1
​~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~``
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.Index(s0, "学"))
	fmt.Println(strings.Index(s0, ""))
}
0

//LastIndex：从右至左搜索，返回子串第一次出现的字节索引位置。未找到，返回-1。
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.LastIndex(s0, "学"))
	fmt.Println(strings.LastIndex(s0, "龙"))
}
9
-1
结论：索引号是不变的 虽然从右到左，但是也仍旧是左到右的索引

//IndexByte、IndexRune与Index类似；LastIndexByte与LastIndex类似。
//IndexAny：从左至右搜索，找到给定的字符集字符串中任意一个字符就返回索引位置。未找到返回-1
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.IndexAny(s0, "学l"))
}
2
结论：只要找到学或者l任意的一个 直接就返回索引值 先找到谁直接返回  不在继续找

func main() {
	s0 := "zfl努力学习编程"
	fmt.Println([]byte("学"))
	fmt.Println([]rune("学"))
	fmt.Println(strings.IndexByte(s0, 173))
	fmt.Println(strings.IndexRune(s0, 23398))
}
[229 173 166]
[23398]
10
9
结论：从做到右通过码点来找

//Contains*方法本质上就是Index*方法，只不过返回bool值，方便使用bool值时使用。
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.Contains(s0, "习"))
}
true
​~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
func main() {
	s0 := "zfl努力学习编程"
	fmt.Println(strings.Contains(s0, "了"))
}
false

//Count：从左至右搜索子串，返回子串出现的次数
func main() {
	s0 := "zfl好好努力学习编程"
	fmt.Println(strings.Count(s0, "学"))
	fmt.Println(strings.Count(s0, "好"))
}
1
2

大小写

  • ToLower：转换为小写
  • ToUpper：转换为大写

func main() {
	s0 := "ZFL"
	s1 := "hello world"
	fmt.Println(strings.ToLower(s0))
	fmt.Println(strings.ToUpper(s1))
}
zfl
HELLO WORLD

前后缀

  • HasPrefix：是否以子串开头
  • HasSuffix：是否以子串结尾
func main() {
	s0 := "zfl好好学习xyz"
	fmt.Println(strings.HasPrefix(s0, "zfl"))
	fmt.Println(strings.HasPrefix(s0, "zflxx"))
	fmt.Println("~~~~~~~~~~~~~~")
	fmt.Println(strings.HasSuffix(s0, "xyz"))
}
true
false
​~~~~~~~~~~~~~~
true

移除

  • TrimSpace：去除字符串两端的空白字符。
  • TrimPrefix、TrimSuffix：如果开头或结尾匹配，则去除。否则，返回原字符串的副本。
  • TrimLeft：字符串开头的字符如果在字符集中，则全部移除，直到碰到第一个不在字符集中的字符为止。
  • TrimRight：字符串结尾的字符如果在字符集中，则全部移除，直到碰到第一个不在字符集中的字符为止。
  • Trim：字符串两头的字符如果在字符集中，则全部移除，直到左或右都碰到第一个不在字符集中的字符为止。
//TrimSpace：去除字符串两端的空白字符。
func main() {
	s0 := "\v\n\r \tabc\txyz\t \v\r\n"
	fmt.Println(strings.TrimSpace(s0))
}
abc	xyz
结论：字符串两端的空白字符取掉，中间的不取


//TrimPrefix、TrimSuffix：如果开头或结尾匹配，则去除。否则，返回原字符串的副本。
func main() {
	s0 := "zfl好好学习xyz"
	fmt.Println(strings.TrimPrefix(s0, "zfl"))
	fmt.Println(strings.TrimSuffix(s0, "xyz"))
}
好好学习xyz
zfl好好学习

//TrimLeft：字符串开头的字符如果在字符集中，则全部移除，直到碰到第一个不在字符集中的字符为止。
//TrimRight：字符串结尾的字符如果在字符集中，则全部移除，直到碰到第一个不在字符集中的字符为止。
func main() {
	s0 := "abcdddeabeccc"
	fmt.Println(strings.TrimLeft(s0, "abcd"))
	fmt.Println(strings.TrimRight(s0, "abcd"))
}
eabeccc
abcdddeabe

//Trim：字符串两头的字符如果在字符集中，则全部移除，直到左或右都碰到第一个不在字符集中的字符为止。
func main() {
	s0 := "abcdddeabeccc"
	fmt.Println(strings.Trim(s0, "abcd"))
}
eabe

分割

  • Split：按照给定的分割子串去分割，返回切割后的字符串切片。
    • 切割字符串是被切掉的，不会出现在结果中
    • 没有切到，也会返回一个元素的切片，元素就是被切的字符串
    • 分割字符串为空串，那么返回将被切割字符串按照每个rune字符分解后转成string存入切片返回
  • SplitN(s, sep string, n int) []string ，n表示最终切片中有几个元素
    • n == 0，返回空切片，切成0个子串
    • n > 0，返回切片元素的个数
      • n == 1，返回一个元素切片，元素为s，相当于Split的没有切到
      • n > 1，按照sep切割。返回多个元素的切片。按照sep切成的段数最多有x段，当n < x
        时，会有部分剩余字符串未切；n == x时，字符串s正好从头到尾切完，返回所有段的切片；n > x时，和n == x一样。n表示切割出来的子串的上限，即至多切片里面有n个元素
      • n < 0，等价Split，能切多少切出多少
  • SplitAfter和Split相似，就是不把sep切掉
  • SplitAfterN和SplitN相似，也不把sep切掉
  • Cut(s, sep string) (before, after string, found bool)
    • 内部使用Index找sep，所以是从左至右搜索切割点。可以认为就是切一刀，一刀两段
    • 没有切到，返回 s, “”, false
    • 切到了，匹配切割符的部分要切掉，返回 切割符前部分，切割符后部分, true
func main() {
	s := "www.itzfl.com-好好学习"
	var s1 = strings.Split(s, ".")   //声明以·切割
	fmt.Println(s1)
	fmt.Println(s1[0])
}
[www itzfl com-好好学习]
www

//没有切到，也会返回一个元素的切片，元素就是被切的字符串
	s := "www.itzfl.com-好好学习"
	var s1 = strings.Split(s, "=")
[www.itzfl.com-好好学习]


//分割字符串为空串，那么返回将被切割字符串按照每个rune字符分解后转成string存入切片返回
func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.Split(s, ""))
}
[w w w . i t z f l . c o m - 好 好 学 习]

//- SplitAfter和Split相似，就是不把sep切掉
//- SplitAfterN和SplitN相似，也不把sep切掉
func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.SplitAfter(s, "."))
	fmt.Println(strings.SplitAfter(s, "="))
	fmt.Println(strings.SplitAfter(s, ""))
}
[www. itzfl. com-好好学习]
[www.itzfl.com-好好学习]
[w w w . i t z f l . c o m - 好 好 学 习]
//结论：就是将切割符保留

//SplitN(s, sep string, n int) []string ，n表示最终切片中有几个元素
func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.SplitN(s, ".", 1))      // 返回的切片只能有1个元素
	fmt.Println(strings.SplitN(s, ".", 2))      // 返回的切片只能有2个元素
	fmt.Println(strings.SplitAfterN(s, ".", 2)) // 返回的切片只能有2个元素
}
[www.itzfl.com-好好学习]
[www itzfl.com-好好学习]
[www. itzfl.com-好好学习]

//Cut(s, sep string) (before, after string, found bool)
func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.Cut(s, "."))
}
www itzfl.com-好好学习 true

替换

  • Replace(s, old, new string, n int) string
    • n < 0，等价ReplaceAll，全部替换
    • n == 0，或old == new，就返回s
    • n > 0，至多替换n次，如果n超过找到old子串的次数x，也就只能替换x次了
    • 未找到替换处，就返回s
func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.Replace(s, "w", "l", 2))
	fmt.Println(strings.Replace(s, "w", "l", 0)) //n == 0，或old == new，就返回s
	fmt.Println(strings.Replace(s, "w", "l", 5)) //n > 0，至多替换n次，如果n超过找到old子串的次数x，也就只能替换x次了
	fmt.Println(strings.Replace(s, "w", "l", -1)) //n < 0，等价ReplaceAll，全部替换
}
llw.itzfl.com-好好学习
www.itzfl.com-好好学习
lll.itzfl.com-好好学习
lll.itzfl.com-好好学习

其他

Repeat：使用给定的字符串重复n次拼接成一个新字符串。

Map：按照给定处理每个rune字符的函数依次处理每个字符后，拼接成字符串返回。注意Map是
一对一的映射，不能减少元素个数。

func main() {
	s := "www.itzfl.com-好好学习"
	fmt.Println(strings.Map(func(r rune) rune {
		if 'a' <= r && r <= 'z' {
			return r - 0x20 // 请问这是干什么？
		}
		return r
	}, s))
    WWW.ITZFL.COM-好好学习

类型转换

数值类型转换

  • 低精度向高精度转换可以，高精度向低精度转换会损失精度
  • 无符号向有符号转换，最高位是符号位
  • byte和int可以互相转换
  • float和int可以相互转换，float到int会丢失精度
  • bool和int不能相互转换
  • 不同长度的int和float之间可以互相转换
func main() {
	var i int8 = -1
	var j uint8 = uint8(i)
	fmt.Println(i, j) // 请问j是多少
}
-1 255



func main() {
	fmt.Println(int(3.14))  // 错误，不允许无类型float常量转到int
	var a = 3.14             // 定义有类型变量转换就没有问题
	fmt.Printf("%T: %[1]v => %T %[2]d\n", a, int(a)) // float64: 3.14 => int 3
}

func main() {
	// byte rune本质上就是整数和无类型常量可以直接计算，自动转换
	b := 'a'
	c := b + 1
	fmt.Printf("%T %[1]c %[1]d", c) // 请问c显示什么，什么类型}
}
int32 b 98

类型别名和类型定义

var a byte = 'C'
var b uint8 = 49
fmt.Println(a, b, a+b) // 为什么类型不同，可以相加？
原因是在源码中定义了 type byte = uint8 ，byte是uint8的别名。
别名说明就是uint8的另外一个名字，和uint8是一回事

type myByte uint8
var c myByte = 50
fmt.Println(a, c, a + c) // 可以吗？为什么？
答案是不可以。原因就是Go原因不允许不同类型随便运算。就算我们眼睛看到可以，也不行，必须强制
类型转换，
type myByte uint8 // 类型定义
type byte = uint8 // 类型别名

func main() {
	type myByte = uint8
	var a byte = 'C'

	var c myByte = 50
	fmt.Println(a, c, a+c)
}
67 50 117

}


~~~go
func main() {
	// byte rune本质上就是整数和无类型常量可以直接计算，自动转换
	b := 'a'
	c := b + 1
	fmt.Printf("%T %[1]c %[1]d", c) // 请问c显示什么，什么类型}
}
int32 b 98

类型别名和类型定义

var a byte = 'C'
var b uint8 = 49
fmt.Println(a, b, a+b) // 为什么类型不同，可以相加？
原因是在源码中定义了 type byte = uint8 ，byte是uint8的别名。
别名说明就是uint8的另外一个名字，和uint8是一回事

type myByte uint8
var c myByte = 50
fmt.Println(a, c, a + c) // 可以吗？为什么？
答案是不可以。原因就是Go原因不允许不同类型随便运算。就算我们眼睛看到可以，也不行，必须强制
类型转换，
type myByte uint8 // 类型定义
type byte = uint8 // 类型别名

func main() {
	type myByte = uint8
	var a byte = 'C'

	var c myByte = 50
	fmt.Println(a, c, a+c)
}
67 50 117

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

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

相关文章

02-学成在线内容管理模块基础环境搭建

02-学成在线内容管理模块基础环境搭建

内容管理模块 需求分析 需求分析就是要搞清楚问题域即用户的需求&#xff0c;从而确定软件要为用户解决什么问题&#xff0c;实现哪些业务功能&#xff0c;满足什么样的性能要求 首先确认用户需求: 产品人员根据用户需求会绘制界面原型&#xff0c;通过界面原型再和用户确认…
阅读更多...
【QT系列教程】之一安装配置

【QT系列教程】之一安装配置

文章目录 一、qt简介二、qt下载2.1、官网地址&#xff1a;https://www.qt.io/2.2、下载2.3、https://download.qt.io/official_releases/online_installers/ 三、qt安装3.1、登录账号&#xff0c;没有账号自己注册3.2、我是个人安装&#xff0c;如果是公司填写公司名字3.3、欢迎…
阅读更多...
语聚AI助力微信客服系统与企业知识库的API连接，提升电商平台用户运营效果

语聚AI助力微信客服系统与企业知识库的API连接，提升电商平台用户运营效果

建立连接&#xff1a;语聚AI与微信客服系统的API集成 在现代电商运营中&#xff0c;智能客服系统已经成为一种必备的工具。而在这方面&#xff0c;微信客服系统因其广泛的用户基础和便捷的操作方式&#xff0c;成为了业界广泛采用的工具。但是&#xff0c;为了更好地满足用户需…
阅读更多...
SA实战 ·《SpringCloud Alibaba实战》第13章-服务网关：项目整合SpringCloud Gateway网关

SA实战 ·《SpringCloud Alibaba实战》第13章-服务网关：项目整合SpringCloud Gateway网关

大家好，我是冰河~~ 一不小心[SpringCloud Alibaba实战》专栏都更新到第13章了，再不上车就跟不上了，小伙伴们快跟上啊！ 在《SpringCloud Alibaba实战》专栏前面的文章中，我们实现了用户微服务、商品微服务和订单微服务之间的远程调用，并且实现了服务调用的负载均衡。也基于…
阅读更多...
小黑子—springMVC：第二章 拦截器、全注解开发和异常处理机制

小黑子—springMVC：第二章 拦截器、全注解开发和异常处理机制

springMVC入门2.0 4、小黑子的springMVC拦截器4.1 Interceptor简介4.2 拦截器快速入门4.3 拦截器执行顺序4.4 拦截器执行原理 5、小黑子的springMVC全注解开发5.1 spring-mvc.xml中组件转化为注解形式5.1.1 消除spring-mvc.xml一二三 5.1.2 消除web.xml 6、小黑子的springMVC组…
阅读更多...
【ARL灯塔搭建详细教程】

【ARL灯塔搭建详细教程】

文章目录 前言一、前期准备二、安装docker及docker-compose三、安装ARL灯塔四、登录ARL灯塔 前言 ARL&#xff08;Asset Reconnaissance Lighthouse&#xff09;资产侦查灯塔旨在快速发现并整理企业外网资产并为资产构建基础数据库&#xff0c;无需登录凭证或特殊访问即可主动…
阅读更多...
MTK Camera2 的OPEN API流程认知

MTK Camera2 的OPEN API流程认知

MTK的设计架构 再了解Camera的open api调用之前我们&#xff0c;需要了解Camera的架构&#xff0c;这样才能提高阅读代码的效率。 代码跟读&#xff1a; 在这个图中大致介绍了OpenCamera的具体调用&#xff0c;下面我们逐步分析Camera的open调用流程。 逐步分析 一、 我们抛…
阅读更多...
觉非科技发布【轻地图高速NOA智驾方案】|地平线,觉非科技,MobileDrive超捷生态协作实现技术落地

觉非科技发布【轻地图高速NOA智驾方案】|地平线,觉非科技,MobileDrive超捷生态协作实现技术落地

11月10日&#xff0c;2023世界新汽车技术合作生态展期间&#xff0c;觉非科技正式发布了基于地平线征程系列以及MobileDrive超捷规控系统的【轻地图高速NOA智驾解决方案】。该方案首次实现了从芯片能力输出、到数据闭环建设、再到规控部署的产业生态链协作与打通&#xff0c;为…
阅读更多...
使用gitflow时如何合并hotfix

使用gitflow时如何合并hotfix

前言 在使用 git flow 流程时, 对于项目型的部署项目经常会遇到一个问题, 就是现场项目在使用历史版本时发现的一些问题需要修复, 但升级可能会有很大的风险或客户不愿意升级, 这时就要求基于历史版本进行 hotfix 修复. 基于历史发布版本的缺陷修复方式不同于最新发布版本的补…
阅读更多...
绩效管理系统有哪些？

绩效管理系统有哪些？

绩效管理系统有哪些&#xff1f; 把绩效管理系统按照两大指标分类—— 按地域划分&#xff08;主要看兼容性和稳定性&#xff09;按照功能性质划分&#xff08;主要看实用性和拓展性&#xff09; 按照以上两个维度&#xff0c;我们可以简单把绩效管理系统分为4大不同类型——…
阅读更多...
Java系列之 超时任务处理方法

Java系列之 超时任务处理方法

文章底部有个人公众号&#xff1a;热爱技术的小郑。主要分享开发知识、学习资料、毕业设计指导等。有兴趣的可以关注一下。为何分享&#xff1f; 踩过的坑没必要让别人在再踩&#xff0c;自己复盘也能加深记忆。利己利人、所谓双赢。 前言 调用一些方法&#xff0c;进行一些比…
阅读更多...
MySQL数据库入门到大牛_基础_07__单行函数

MySQL数据库入门到大牛_基础_07__单行函数

文章目录 1. 函数的理解1.1 什么是函数1.2 不同DBMS函数的差异1.3 MySQL的内置函数及分类 2. 数值函数2.1 基本函数2.2 角度与弧度互换函数2.3 三角函数2.4 指数与对数2.5 进制间的转换 3. 字符串函数4. 日期和时间函数4.1 获取日期、时间4.2 日期与时间戳的转换4.3 获取月份、…
阅读更多...
【Amazon】云上探索实验室—了解 AI 编程助手 Amazon Codewhisperer

【Amazon】云上探索实验室—了解 AI 编程助手 Amazon Codewhisperer

文章目录 一、前言&#x1f4e2;二、关于云上探索实验室&#x1f579;️三、领学员需要做什么&#xff1f;✴️四、领学员能获得什么&#xff1f;&#x1f523;五、学课通道入口&#x1f447;1️⃣CSDN平台2️⃣网易云课堂3️⃣Skill Builder 平台 六、活动详情链接 一、前言&a…
阅读更多...
万亿数字新消费赛道，央企纷纷借力破冰

万亿数字新消费赛道，央企纷纷借力破冰

配图来自Canva可画 当前&#xff0c;消费已经成为经济增长的第一拉动力。2023年上半年&#xff0c;最终消费支出对经济增长的贡献率达到77.2%&#xff0c;消费继续保持经济增长的第一拉动力。 消费对经济增长的作用日益突出&#xff0c;恢复消费、提振消费、扩大消费&#xf…
阅读更多...
map与set使用方法总结

map与set使用方法总结

一&#xff0c;map与set简介 map与set本质上便是一个关联容器&#xff0c;它们的底层都是一个叫做红黑树的数据结构。当然&#xff0c;所谓的红黑树又是一个二叉搜索树。所以追根溯源&#xff0c;map和set都是用二叉搜索树&#xff08;红黑树&#xff09;实现的容器。 在C中&am…
阅读更多...
内衣洗衣机和手洗哪个干净？好用的内衣洗衣机推荐

内衣洗衣机和手洗哪个干净？好用的内衣洗衣机推荐

在日常生活中&#xff0c;我们的衣服不可避免地会沾染上各种细菌、毛发和污渍&#xff0c;将它们与贴身衣物混合清洗&#xff0c;很容易发生交叉感染&#xff0c;而被感染后&#xff0c;贴身衣物也有可能导致我们人体引起皮肤病。这也是为什么大部分人都喜欢用手洗的原因&#…
阅读更多...
Python机器学习基础（三）---数据预处理

Python机器学习基础（三）---数据预处理

一.数据预处理作用 数据预处理会将选定的数据转换为我们可以使用的形式或可以提供给ML算法的形式&#xff0c;以使其符合机器学习算法的期望。 二.数据处理的常用方法 1.规范化 数据规范化是使属性数据按比例缩放&#xff0c;这样就将原来的数值映射到一个新的特定区域中&#…
阅读更多...
揭秘拍卖竞价源码：10个必知的关键细节

揭秘拍卖竞价源码：10个必知的关键细节

拍卖竞价源码作为数字化时代中的一大亮点&#xff0c;不仅在技术领域引起了高度关注&#xff0c;并且在商业应用中展现出巨大潜力。在本文中&#xff0c;我们将揭秘拍卖竞价源码中的10个关键细节&#xff0c;助你一窥这一领域的深入内涵。 1. 拍卖竞价源码的由来 拍卖竞价源码…
阅读更多...
侧击雷如何检测预防

侧击雷如何检测预防

侧击雷是一种雷击的形式&#xff0c;指的是雷电从建筑物的侧面打来的直接雷击。侧击雷对高层建筑物的防雷保护提出了更高的要求&#xff0c;因为一般的避雷带或避雷针不能完全保护住建筑物的侧面。侧击雷可能会对建筑物的结构、设备和人员造成严重的损害&#xff0c;甚至引发火…
阅读更多...
ninja 编译介绍

ninja 编译介绍

首先献上官方链接 https://ninja-build.org/manual.html Ninja 何以存在&#xff1f; 从官方文档看出&#xff0c;编译很快&#xff01;怎么实现的呢&#xff1f;&#xff1f;所以&#xff0c;还是值得了解一下的&#xff0c;继续~ 编译优势 项目中使用 具体语法&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023