锐客网

  1. 首页 > 睿知 > it技术 > >

go语言反引号 go struct 反引号

字符串IT技术

在go语言中，如何在反引号中调用变量的值而不是变量名//orFilter.setPredicates(new NodeFilter[] { spanFilter,tableFilter });
nodeList = nodeList.extractAllNodesThatMatch(orFilter,true);
Node[] nodeArray = nodeList.toNodeArray();
for(Node node : nodeArray ){
Span sp=(Span)node;
String spanId = span.getAttribute("id");
if("title".equals(spanId))){
parser.setInputHTML(tag.toHtml());
String tempStr = getHtmlAsNoTag(parser);
基础知识 - Golang 中的格式化输入输出 【格式化输出】
// 格式化输出：将 arg 列表中的 arg 转换为字符串输出
// 使用动词 v 格式化 arg 列表，非字符串元素之间添加空格
Print(arg列表)
// 使用动词 v 格式化 arg 列表，所有元素之间添加空格，结尾添加换行符
Println(arg列表)
// 使用格式字符串格式化 arg 列表
Printf(格式字符串, arg列表)
// Print 类函数会返回已处理的 arg 数量和遇到的错误信息 。
【格式字符串】
格式字符串由普通字符和占位符组成 ， 例如：
"abc%#8.3[3]vdef"
其中 abc 和 def 是普通字符 ， 其它部分是占位符 ， 占位符以 % 开头（注：%% 将被转义为一个普通的 % 符号，这个不算开头），以动词结尾，格式如下：
%[旗标][宽度][.精度][arg索引]动词
方括号中的内容可以省略 。
【旗标】
旗标有以下几种：
空格：对于数值类型的正数，保留一个空白的符号位（其它用法在动词部分说明） 。
0：用 0 进行宽度填充而不用空格，对于数值类型，符号将被移到所有 0 的前面 。
其中 "0" 和 "-" 不能同时使用，优先使用 "-" 而忽略 "0" 。
【宽度和精度】
“宽度”和“精度”都可以写成以下三种形式：
数值 | * | arg索引*
其中“数值”表示使用指定的数值作为宽度值或精度值 ， “ ”表示使用当前正在处理的 arg 的值作为宽度值或精度值 ， 如果这样的话，要格式化的 arg 将自动跳转到下一个 。“arg索引 ”表示使用指定 arg 的值作为宽度值或精度值，如果这样的话，要格式化的 arg 将自动跳转到指定 arg 的下一个 。
宽度值：用于设置最小宽度 。
精度值：对于浮点型，用于控制小数位数 ， 对于字符串或字节数组，用于控制字符数量（不是字节数量） 。
对于浮点型而言，动词 g/G 的精度值比较特殊 ， 在适当的情况下，g/G 会设置总有效数字，而不是小数位数 。
【arg 索引】
“arg索引”由中括号和 arg 序号组成（就像上面示例中的 [3]） ， 用于指定当前要处理的 arg 的序号，序号从 1 开始：
'['arg序号']'
【动词】
“动词”不能省略，不同的数据类型支持的动词不一样 。
[通用动词]
v：默认格式，不同类型的默认格式如下：
布尔型：t
整　型：d
浮点型：g
复数型：g
字符串：s
通　道：p
指　针：p
无符号整型：x
T：输出 arg 的类型而不是值（使用 Go 语法格式） 。
[布尔型]
t：输出 true 或 false 字符串 。
[整型]
b/o/d：输出 2/8/10 进制格式
x/X：输出 16 进制格式（小写/大写）
c：输出数值所表示的 Unicode 字符
q：输出数值所表示的 Unicode 字符（带单引号） 。对于无法显示的字符 ， 将输出其转义字符 。
U：输出 Unicode 码点（例如 U 1234，等同于字符串 "U X" 的显示结果）
对于 o/x/X：
如果使用 "#" 旗标，则会添加前导 0 或 0x 。
对于 U：
如果使用 "#" 旗标，则会在 Unicode 码点后面添加相应的 '字符'（前提是该字符必须可显示）
[浮点型和复数型]
b：科学计数法（以 2为底）
e/E：科学计数法（以 10 为底，小写 e/大写 E）
f/F：普通小数格式（两者无区别）
g/G：大指数（指数 = 6）使用 %e/%E，其它情况使用 %f/%F
[字符串或字节切片]
s：普通字符串
q：双引号引起来的 Go 语法字符串
x/X：十六进制编码（小写/大写，以字节为元素进行编码，而不是字符）
对于 q：
如果使用了 " " 旗标，则将所有非 ASCII 字符都进行转义处理 。
如果使用了 "#" 旗标，则输出反引号引起来的字符串（前提是
字符串中不包含任何制表符以外的控制字符，否则忽略 # 旗标）
对于 x/X：
如果使用了 " " 旗标 ， 则在每个元素之间添加空格 。
如果使用了 "#" 旗标，则在十六进制格式之前添加 0x 前缀 。
[指针类型]
p ：带 0x 前缀的十六进制地址值 。
[符合类型]
复合类型将使用不同的格式输出 ， 格式如下：
结　构　体：{字段1 字段2 ...}
数组或切片：[元素0 元素1 ...]
映　射：map[键1:值1 键2:值2 ...]
指向符合元素的指针：{}, [], map[]
复合类型本身没有动词，动词将应用到复合类型的元素上 。
结构体可以使用 " v" 同时输出字段名 。
【注意】
1、如果 arg 是一个反射值，则该 arg 将被它所持有的具体值所取代 。
2、如果 arg 实现了 Formatter 接口，将调用它的 Format 方法完成格式化 。
3、如果 v 动词使用了 # 旗标（%#v），并且 arg 实现了 GoStringer 接口，将调用它的 GoString 方法完成格式化 。
如果格式化操作指定了字符串相关的动词（比如 %s、%q、%v、%x、%X） ， 接下来的两条规则将适用：
4 。如果 arg 实现了 error 接口，将调用它的 Error 方法完成格式化 。
5 。如果 arg 实现了 string 接口 ， 将调用它的 String 方法完成格式化 。
在实现格式化相关接口的时候，要避免无限递归的情况，比如：
type X string
func (x X) String() string {
return Sprintf("%s", x)
}
在格式化之前，要先转换数据类型，这样就可以避免无限递归：
func (x X) String() string {
return Sprintf("%s", string(x))
}
无限递归也可能发生在自引用数据类型上面 ， 比如一个切片的元素引用了切片自身 。这种情况比较罕见，比如：
a := make([]interface{}, 1)
a[0] = a
fmt.Println(a)
【格式化输入】
// 格式化输入：从输入端读取字符串（以空白分隔的值的序列），
// 并解析为具体的值存入相应的 arg 中，arg 必须是变量地址 。
// 字符串中的连续空白视为单个空白，换行符根据不同情况处理 。
// \r\n 被当做 \n 处理 。
// 以动词 v 解析字符串 ， 换行视为空白
Scan(arg列表)
// 以动词 v 解析字符串，换行结束解析
Scanln(arg列表)
// 根据格式字符串中指定的格式解析字符串
// 格式字符串中的换行符必须和输入端的换行符相匹配 。
Scanf(格式字符串, arg列表)
// Scan 类函数会返回已处理的 arg 数量和遇到的错误信息 。
【格式字符串】
格式字符串类似于 Printf 中的格式字符串，但下面的动词和旗标例外：
p：无效
T：无效
e/E/f/F/g/G：功能相同，都是扫描浮点数或复数
s/v：对字符串而言，扫描一个被空白分隔的子串
对于整型 arg 而言 ， v 动词可以扫描带有前导 0 或 0x 的八进制或十六进制数值 。
宽度被用来指定最大扫描宽度（不会跨越空格） ， 精度不被支持 。
如果 arg 实现了 Scanner 接口，将调用它的 Scan 方法扫描相应数据 。只有基础类型和实现了 Scanner 接口的类型可以使用 Scan 类方法进行扫描 。
【注意】
连续调用 FScan 可能会丢失数据 ， 因为 FScan 中使用了 UnreadRune 对读取的数据进行撤销，而参数 io.Reader 只有 Read 方法 ， 不支持撤销 。比如：
golang获取到string和直接赋值strimg不一样1、 string的定义
Golang中的string的定义在reflect包下的value.go中，定义如下：
StringHeader 是字符串的运行时表示，其中包含了两个字段，分别是指向数据数组的指针和数组的长度 。
// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
Data uintptr
Lenint
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
2、string不可变
Golang中的字符串是不可变的，不能通过索引下标的方式修改字符串中的数据：
在这里插入图片描述
运行代码，可以看到编译器报错，string是不可变的
在这里插入图片描述
但是能不能进行一些骚操作来改变元素的值呢？
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
b := a[6:]
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println(a)
fmt.Println(b)
*(*byte)(unsafe.Pointer(bptr.Data)) = '.'
fmt.Println(a)
fmt.Println(b)
}
// 运行结果
hello,world
world
unexpected fault address 0x49d7e3
fatal error: fault
[signal 0xc0000005 code=0x1 addr=0x49d7e3 pc=0x4779fa]
goroutine 1 [running]:
runtime.throw(0x49c948, 0x5)
C:/Program Files/Go/src/runtime/panic.go:11170x79 fp=0xc0000dbe90 sp=0xc0000dbe60 pc=0x405fd9
runtime.sigpanic()
C:/Program Files/Go/src/runtime/signal_windows.go:2450x2d6 fp=0xc0000dbee8 sp=0xc0000dbe90 pc=0x4189f6
main.main()
F:/go_workspace/src/code/string_test/main.go:200x13a fp=0xc0000dbf88 sp=0xc0000dbee8 pc=0x4779fa
runtime.main()
C:/Program Files/Go/src/runtime/proc.go:2250x256 fp=0xc0000dbfe0 sp=0xc0000dbf88 pc=0x4087f6
runtime.goexit()
C:/Program Files/Go/src/runtime/asm_amd64.s:13710x1 fp=0xc0000dbfe8 sp=0xc0000dbfe0 pc=0x435da1
Process finished with the exit code 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
【go语言反引号 go struct 反引号】46
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
在上面的代码中 ， 因为在go语言中不能进行指针的加减运算，因此取切片 ， 让b的Data指针指向’,'所在的位置 。然后把"hello,world"中的逗号改为点，但是发现还是不行，程序直接崩溃了 。看来go语言中的指针得到了大大的限制，设计者并不想让程序员过度使用指针来写出一些不安全的代码 。
3、使用string给另一个string赋值
Golang中的字符串的赋值并不是拷贝底层的字符串数组，而是数组指针和长度字段的拷贝 。例如：当我们定义了一个字符串 a := “hello,world” 然后定义了 b := a 底层所做的操作只是创建了两个StringHeader的结构体，它们的Data字段都指向同一段数据，如下图：
在这里插入图片描述
我们可以利用代码来证实这一点：
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
b := a
fmt.Println(a)
fmt.Println(b)
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}
// 运行结果
hello, world
hello, world
a ptr: 0x6bdb76
b ptr: 0x6bdb76
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
在上面的代码中，将a和b转换为StringHeader类型的指针 ， 然后分别打印出，a和b的Data指针的值，发现是相同的
那么如果对a做切片赋值给b呢？
func main() {
a := "hello,world"
b := a[6:]
fmt.Println(a)
fmt.Println(b)
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(b))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}
// 运行结果
hello,world
world
a ptr: 0xd4d849
b ptr: 0xd4d84f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
0xd4d849 - 0xd4d84f = 0x000006
显然，也没有分配新的数组并拷贝数据 ， 而是将原字符数组的指针的偏移赋给了b的StringHeader的Data
4、string重新赋值
如果对一个已经赋值的字符串重新赋值 ， 也不会修改原内存空间 ， 而是申请了新的内存空间，对其赋值，并指向新的内存空间 。如下图：
在这里插入图片描述
也可以使用代码来证实一下：
package main
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
a := "hello,world"
aptr := (*reflect.StringHeader) (unsafe.Pointer(a))
fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("a len", aptr.Len)
a = "hello,golang"
newAPtr := (*reflect.StringHeader) (unsafe.Pointer(a))
fmt.Println("b ptr:", unsafe.Pointer(newAPtr.Data))
fmt.Println("b len:", newAPtr.Len)
}
// 运行结果
a ptr: 0x3ed7f4
a len 11
b ptr: 0x3edb2c
b len: 12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
文章知识点与官方知识档案匹配
Go技能树九阴真经字符串
2043 人正在系统学习中
点击阅读全文
打开CSDN APP，看更多技术内容
Golang底层原理剖析之string类型与字符编码_cheems~的博客_g...
string类型 string结构 go语言中默认使用的是UTF-8编码 string由两部分组成,一部分是指向字符串起始地址的指针,另一部分是字节个数len注意不是字符个数,是字节个数!这个数据类型占用16B空间,指向字符串起始地址的指针和存在字节个数的整...
继续访问
...底层系列二(基础)_GoGo在努力的博客_golang string底层
1、 string的定义 Golang中的string的定义在reflect包下的value.go中,定义如下: StringHeader 是字符串的运行时表示,其中包含了两个字段,分别是指向数据数组的指针和数组的长度 。// StringHeader is the runtime representation of a...
继续访问
最新发布 Golang: []string 和 ...string
… 参数语法形成了可变参数的参数 。它将接受零个或多个string参数，并将它们作为切片引用
继续访问
常用的Golang字符串（string）操作
文章目录Golang中常用的字符串操作一、标准库相关的Package二、常用字符串操作判断是否为空字符串 正文 Golang中常用的字符串操作 一、标准库相关的Package 二、常用字符串操作 判断是否为空字符串 思路：直接判断是否等于""空字符串，由于golang中字符串不能为nil，且为值类型，所以直接与空字符串比较即可 举例： str := "" if str == ""{...
继续访问
golang中的string_xiaodongdonga的博客_golang ...string
golang中的string 在golang中,string其实是个结构体,如图 ,在这个结构体中有两个值,一个是指向字符数组的指针str,另一个是这个字符串的长度len 。另外在golang中用的是UFT8边长编码,里面字母是用一个字节,西方的文字使用两个字节,...
继续访问
Golang中对字符串string的相关操作_Codex_97的博客_go 字符...
golang中拥有string的内置类型,可以使用与普通slice类型相似的性质 。1.简介 strings包提供了很多操作字符串的简单函数,通常一般的字符串操作都可以在这个包中找到 。strconv 包提供了基本数据类型和字符串之间的转换 。在Go 中,没有隐式...
继续访问
go-string-set:一种在GoLang中创建字符串集的方法
概述 通过字符串设置方法 。用法 go get github.com/wojnosystems/go-string-set package main import ( "github.com/wojnosystems/go-string-set/string_set" "strings" ) func main () { myPeople := string_set . New () myPeople . Add ( "Bob" ) myPeople . Add ( "Jane" ) myPeople . Add ( "Gary" ) myPeople . Add ( "Bob" ) if myPeople . Exists ( "Bob" ) { // Bob exists in myPeople, so this code block execute
Golang：strings包和字符串操作
strings包 string类型值是不可变的，如果想要获得一个不一样的字符串，就只能基于原字符串进行剪裁，拼接等操作，然后将得到的新字符串存放到一块联系内存中 。string值包含了指向底层字节数组头部的指针值，以及该字节数组的长度 。在string值上做切片，就相当于在其底层字节数组做切片 。而字符串拼接时（使用 ） ， 会把所有被拼接的字符串依次拷贝到一个崭新且足够大的连续内存空间中，并把持有新...
继续访问
golang中的strings.SplitN_盼盼编程的博客_strings.splitn
golang中的字符串操作strings.SplitN package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "hello world hello world" //str := "wo" //以str为分隔符,将s切分成多个子串,结果中**不包含*...
继续访问
Golang_String常用操作_itzhuzhu.的博客_golang strings
func main() { var x string = "ITzhuzhu" var y string = "itzhuzhu" fmt.Println(strings.EqualFold(x, y)) //true fmt.Println(x == y) //false } 1 2 3 4 5 6 返回子串在字符串第一次出现的索引,如果没有则...
继续访问
Golang类型的String()方法
作用 用于定制fmt.Println(x)、fmt.Printf("%v", x)、fmt.Print(x)时输出的内容 。示例 package main import "fmt" type Couple struct { Husband string Wife string } func (self Couple) String() string { return "(husband:"self.Husband", wife:"self.Wife
继续访问
golang的string
golang中的string是不可变的字节序列，零值是空字符串，默认是UTF-8编码 。golang中使用字符串最需要注意的是，golang中的字符串是字节序列 ， string == []byte，由于一个字符占用的字节数不确定 ， 所以无法通过下标[i]的方式稳定地获取对应位置的字符 。也就意味着字符串的第i个字节，不一定就是第i个字符，原因请参考 unicode与UTF-8 文字符号在golang中被称为rune ， 发音为/ru:n/，意思是符号 。由于utf-8最多使用4个字节来编码 ， 所以rune类型是int3
继续访问
golang中的strings.Trim_盼盼编程的博客_strings.trim
golang中的字符串操作strings.Trim package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "world" //var s = []string{"11","22","33"} //删除s首尾...
继续访问
Golang 字符串
Go语言的代码是由Unicode字符组成的，它们都必须由Unicode编码规范中的UTF-8编码格式进行编码并存储 ， Unicode编码规范中的编码格式定义的是字符与字节序列之间的转换方式 。其中的UTF-8是一种可变宽的编码方案，它会用一个或多个字节的二进制数来表示某个字符，最多使用四个字节 。Go语言中的一个string类型值会由若干个Unicode字符组成 ， 每个Unicode字符都可以由一个rune类型的值来承载 。stringforrange 。...
继续访问
golang字符串[]string(slice)去重
1、现实代码 // []string 去重 func RemoveDuplicate(list []string) []string { // 这个排序很关键 sort.Strings(list) i := 0 var newlist = []string{""} for j := 0; jlen(list); j{ if strings.Compare(newlist[i], list[j]) == -1 { newlist = append(newlist, lis
继续访问
深入理解golang string
golang string string的定义 // string is the set of all strings of 8-bit bytes, conventionally but not // necessarily representing UTF-8-encoded text. A string may be empty, but // not nil. Values of string type are immutable. type string string string里存储的是字符
继续访问
golang中string包
对于基本类型来说，字符串所需要执行的操作会比较复杂 ， 所以一般语言都会额外封装一些方法用于处理字符串，go语言标准库中也存在这样一个名为strings的库 包含判断，判断一个字符中是否有相应的某个子字符串是经常遇到的一种字符串操作，再go语言中可以使用strings包中的两个方法判断 ...
继续访问
golang中的strings.TrimLeft
golang中的字符串操作strings.TrimLeft package main import ( "fmt" "strings" ) //golang字符串操作 func main(){ s := "Hello world hello world" str := "Hello" //var s = []string{"11","22","33"} //删除s头部连续的包含在str中的字符串 .
继续访问
golang入门time与string转换, time加减时间, 两个时间差
package mainimport ( "fmt" "time")var timeLayoutStr = "2006-01-02 15:04:05" //go中的时间格式化必须是这个时间//var timeLayoutStr = 2006/01/02 03:04:05 //合法, 格式可以改变//var timeLayoutStr = 2019/01/02 15:04:05 /...
继续访问
Golang——string
1.string结构体底层 由两部分组成：指向底层[ ]byte数组的指针；长度（类似切片结构体） 2.相同的string常量不会重复存储 //由s1、s2的指针指向一块相同的只读内存，这段内存以utf-8编码存放hello数组 s1 := "hello" s2 := "hello" 3.string常量会在编译期分配到只读段 ， 对应数据地址不可写入，故string不支持修改 。要修改必须转[]byte，string和[]byte转换，会将这段只读内存的数据复制到堆/栈上 。//wrong s := "he
继续访问
热门推荐 golang -----------字符串（rune,string,type）
一、内存布局 字符串在Go语言内存模型中用一个2字长的数据结构表示 。它包含一个指向字符串存储数据的指针和一个长度数据 。因为string类型是不可变的，对于多字符串共享同一个存储数据是安全的 。切分操作str[i:j]会得到一个新的2字长结构，一个可能不同的但仍指向同一个字节序列(即上文说的存储数据)的指针和长度数据 。这意味着字符串切分可以在不涉及内存分配或复制操作 。这使得字符串切分的效率等同于...
继续访问
Golang string 常用方法
strings.Compare(p1, p2) 判断p1是否大于p2，大于:1,小于:-1,等于:0 。2.strings.LastIndex(p1,p2) p2在p1中最后一次出现的位置,未出现返回-1 。1.strings.Replace(p1,p2,p3,n) 将p1中的p2替换成p3，最多替换n个 。1.strings.Index(p1,p2) p2在p1中第一次出现的位置,未出现返回-1 。2.strings.ReplaceAll(p1,p2,p3) 将p1中的所有p2替换成p3 。
继续访问
golang中的字符串
在go中rune是一个unicode编码点 。我们都知道UTF-8将字符编码为1-4个字节，比如我们常用的汉字 ， UTF-8编码为3个字节 。所以rune也是int32的别名 。
继续访问
golang之字符串
Go语言的字符有两种类型： 一种是byte型，或者叫uint8类型，代表了ASCII码的一个字符 。一种是rune类型 ， 或者叫int32类型，代表一个UTF-8字符 ， 当需要处理中文、日文等unicode字符时 ， 则需要用到rune类型 。...
继续访问
Golang的 string 类型
一点睛 字符串就是一串固定长度的字符连接起来的字符序列 。Go 的字符串是由单个字节连接起来的 。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本 。二 string 使用注意事项和细节 1 Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员 。2 字符串一旦赋值了，字符串就不能修改了，在 Go 中字符串是不可变的 。3 字符串的两种表示形式 。a 双引号——会识别转义字符 .
继续访问
Golang Strings 官方包常用方法，学会这些够用了
1.判断是否以某字符串打头/结尾 2.字符串分割 3.返回子串索引 4.字符串连接 5.字符串转化为大小写 6.统计某个字符在字符串出现的次数 7.判断字符串的包含关系 8.字符串替换
没有类，C语言有结构体，那么Go的结构体有什么特别之处？ Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念 。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性 。
自定义类型
在Go语言中有一些基本的数据类型 ， 如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型 。
自定义类型是定义了一个全新的类型 。我们可以基于内置的基本类型定义，也可以通过struct定义 。例如：
通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性 。
类型别名
类型别名是Go1.9版本添加的新功能 。
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型 。就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人 。
type TypeAlias = Type
我们之前见过的rune和byte就是类型别名 ， 他们的定义如下：
类型定义和类型别名的区别
类型别名与类型定义表面上看只有一个等号的差异 ， 我们通过下面的这段代码来理解它们之间的区别 。
结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型 。b的类型是int 。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型 。
Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct 。也就是我们可以通过struct来定义自己的类型了 。
Go语言中通过struct来实现面向对象 。
结构体的定义
使用type和struct关键字来定义结构体，具体代码格式如下：
其中：
举个例子，我们定义一个Person（人）结构体，代码如下：
同样类型的字段也可以写在一行，
这样我们就拥有了一个person的自定义类型，它有name、city、age三个字段，分别表示姓名、城市和年龄 。这样我们使用这个person结构体就能够很方便的在程序中表示和存储人信息了 。
语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的 。比如一个人有名字、年龄和居住城市等，本质上是一种聚合型的数据类型
结构体实例化
只有当结构体实例化时，才会真正地分配内存 。也就是必须实例化后才能使用结构体的字段 。
基本实例化
举个例子：
我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等 。
匿名结构体
在定义一些临时数据结构等场景下还可以使用匿名结构体 。
创建指针类型结构体
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址 。格式如下：
从打印的结果中我们可以看出p2是一个结构体指针 。
需要注意的是在Go语言中支持对结构体指针直接使用.来访问结构体的成员 。
取结构体的地址实例化
使用对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作 。
p3.name = "七米"其实在底层是(*p3).name = "七米"，这是Go语言帮我们实现的语法糖 。
结构体初始化
没有初始化的结构体，其成员变量都是对应其类型的零值 。
使用键值对初始化
使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值 。
也可以对结构体指针进行键值对初始化，例如：
当某些字段没有初始值的时候，该字段可以不写 。此时，没有指定初始值的字段的值就是该字段类型的零值 。
使用值的列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
使用这种格式初始化时 ， 需要注意：
结构体内存布局
结构体占用一块连续的内存 。
输出：
【进阶知识点】关于Go语言中的内存对齐推荐阅读:在 Go 中恰到好处的内存对齐
面试题
请问下面代码的执行结果是什么？
构造函数
Go语言的结构体没有构造函数 ， 我们可以自己实现 。例如，下方的代码就实现了一个person的构造函数 。因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大 ， 所以该构造函数返回的是结构体指针类型 。
调用构造函数
方法和接收者
Go语言中的方法（Method）是一种作用于特定类型变量的函数 。这种特定类型变量叫做接收者（Receiver） 。接收者的概念就类似于其他语言中的this或者 self 。
方法的定义格式如下：
其中，
举个例子：
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型 。
指针类型的接收者
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的 。这种方式就十分接近于其他语言中面向对象中的this或者self 。例如我们为Person添加一个SetAge方法，来修改实例变量的年龄 。
调用该方法：
值类型的接收者
当方法作用于值类型接收者时 ， Go语言会在代码运行时将接收者的值复制一份 。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身 。
什么时候应该使用指针类型接收者
任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法 。举个例子 ， 我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法 。
注意事项：非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法 。
结构体的匿名字段
匿名字段默认采用类型名作为字段名 ， 结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个 。
嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针 。
嵌套匿名结构体
当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找 。
嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名 。这个时候为了避免歧义需要指定具体的内嵌结构体的字段 。
结构体的“继承”
Go语言中使用结构体也可以实现其他编程语言中面向对象的继承 。
结构体字段的可见性
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问） 。
结构体与JSON序列化
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式 。易于人阅读和编写 。同时也易于机器解析和生成 。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔 ， 然后紧接着值；多个键值之间使用英文,分隔 。
结构体标签（Tag）
Tag是结构体的元信息 ， 可以在运行的时候通过反射的机制读取出来 。Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
`key1:"value1" key2:"value2"`
结构体标签由一个或多个键值对组成 。键与值使用冒号分隔，值用双引号括起来 。键值对之间使用一个空格分隔 。注意事项：为结构体编写Tag时 ， 必须严格遵守键值对的规则 。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误 ， 通过反射也无法正确取值 。例如不要在key和value之间添加空格 。
例如我们为Student结构体的每个字段定义json序列化时使用的Tag：
golang依次替换字符串中相同的值不是的，分情况 。
golang支持两种类型的字符串字面量：解释型字符串：双引号括起来的字符串(““)，转义字符（如\n\r等）会被替换掉 。
非解释型字符串：用反引号(键盘左上角上的)括起来的字符串，转义字符不会被解释且可跨行（原样输出）
写命令行应用程序什么不可或缺？Go可以这样处理命令行参数 Go语言内置的flag包实现了命令行参数的解析 ， flag包使得开发命令行工具更为简单 。
如果你只是简单的想要获取命令行参数，可以像下面的代码示例一样使用os.Args来获取命令行参数 。
将上面的代码执行go build -o "args_demo"编译之后，执行：
os.Args是一个存储命令行参数的字符串切片 ， 它的第一个元素是执行文件的名称 。
本文介绍了flag包的常用函数和基本用法，更详细的内容请查看官方文档 。
flag包支持的命令行参数类型有bool、int、int64、uint、uint64、float float64、string、duration 。
有以下两种常用的定义命令行flag参数的方法 。
基本格式如下：
flag.Type(flag名, 默认值, 帮助信息)*Type 例如我们要定义姓名、年龄、婚否三个命令行参数，我们可以按如下方式定义：
需要注意的是，此时name、age、married、delay均为对应类型的指针 。
基本格式如下： flag.TypeVar(Type指针, flag名, 默认值, 帮助信息) 例如我们要定义姓名、年龄、婚否三个命令行参数，我们可以按如下方式定义：
通过以上两种方法定义好命令行flag参数后 ， 需要通过调用flag.Parse()来对命令行参数进行解析 。
支持的命令行参数格式有以下几种：
其中，布尔类型的参数必须使用等号的方式指定 。
Flag解析在第一个非flag参数（单个”-“不是flag参数）之前停止，或者在终止符”–“之后停止 。
定义
使用
命令行参数使用提示：
$ ./flag_demo -help
Usage of ./flag_demo:
-age int
年龄 (default 18)
-d duration
时间间隔
-married
婚否
-name string
姓名 (default "张三")
正常使用命令行flag参数：
使用非flag命令行参数：
原文链接：
关于go语言反引号和go struct 反引号的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：如何更换坏掉的etc服务器 etc服务器坏了怎么换

    下一篇：如何在腾讯云服务器上搭建项目？ 腾讯云服务器怎么搭建项目