网站建设制作视频教程,2023年8月份新冠,网站建设 中企动力长沙,扁平化色块风格的网站#x1f60b; 大家好#xff0c;我是YAy_17#xff0c;是一枚爱好网安的小白。
本人水平有限#xff0c;欢迎各位师傅指点#xff0c;欢迎关注 #x1f601;#xff0c;一起学习 #x1f497; #xff0c;一起进步 ⭐ 。
⭐ 此后如竟没有炬火#xff0c;我便是唯一的… 大家好我是YAy_17是一枚爱好网安的小白。
本人水平有限欢迎各位师傅指点欢迎关注 一起学习 一起进步 ⭐ 。
⭐ 此后如竟没有炬火我便是唯一的光。 ⭐Go语言中的指针Go语言中的函数传参都是值传递当我们想要修改某个变量的时候我们可以创建一个指向该变量地址的指针变量传递数据使用指针而无需拷贝数据。类型指针不能进行偏移和运算。Go语言中的指针操作非常简单只需要记住两个符号(取地址)和*根据地址取值指针地址和指针类型每个变量在运行时都拥有一个地址这个地址代表变量在内存中的位置。Go语言中使用字符放在变量前面对变量进行取地址操作。Go语言中的值类型(int、float、bool、string、array、struct都有对应的指针类型如: *int、 *int64、*string等。指针的语法一个指针变量指向了一个值的内存地址。(也就是我们声明了一个指针之后可以像变量赋值一样把一个值的内存地址放入到指针当中。)类似于变量和常量在使用指针前你需要声明指针。指针声明格式如下:var var _name *var_typevar_type :为指针类型 var_name :为指针变量名 *:用于指定变量是作为一个指针。package mainimport fmtfunc main() {var p *intfmt.Printf(p: %v\n, p)fmt.Printf(p: %T\n, p)var a int 100p afmt.Printf(p: %v\n, *p)var str *stringfmt.Printf(str: %v\n, str)fmt.Printf(str: %T\n, str)s : Y4y17str sfmt.Printf(str: %v\n, *str)var bl *boolfmt.Printf(bl: %v\n, bl)fmt.Printf(bl: %T\n, bl)var b bool truebl bfmt.Printf(bl: %v\n, *bl)
}输出结果为指向数组的指针定义语法var ptr [MAX]*int //表示数组里面的元素的类型是指针类型package mainimport fmtfunc main() {a : [3]int{1, 2, 3}var p [3]*intfmt.Printf(p: %v\n, p)for i : 0; i len(a); i {p[i] a[i]fmt.Printf(p[i]: %v\n, *p[i])}
}输出结果为Go语言中的类型定义和类型别名Go语言类型定义type Newtype Typepackage main
import fmtfunc main() {type Myint intvar i Myint 100fmt.Printf(i: %T,%v\n, i, i)
}输出结果如下i: main.Myint,100Go语言类型别名type NewtypeTypepackage main
import fmt
func main() {type Myint intvar i Myint 100fmt.Printf(i: %T,%v\n, i, i)
}
i: int,100Go语言中的类型定义和类型别名的区别类型定义相当于定义了一个全新的类型与之前的类型不同;但是类型别名并没有定义一个新的类型而是使用一个别名来替换之前的类型类型别名只会在代码中存在在编译完成之后并不会存在该别名因为类型别名和原来的类型是一致的所以原来类型所拥有的方法类型别名中也可以调用但是如果是重新定义的一个类型那么不可以调用之前的任何方法Go语言中的结构体在使用结构体之前我们需要定义一个结构体类型之后通过定义的这个结构体类型在去定义结构体变量语法结构如下type struct_variable_type struct{
member definition;
member definition;
......
member definition;
} type:结构体定义关键字struct_variable_type:结构体类型名称member definition成员定义package mainimport fmtfunc main() {type person struct {name stringage intsex string}var tom personfmt.Printf(tom: %v\n, tom)tom.name tomtom.sex mantom.age 20fmt.Printf(tom: %v\n, tom)fmt.Printf(tom.name: %v\n, tom.name)
}输出的结果如下匿名结构体package mainimport fmtfunc main() {var tom struct { //匿名结构体在定义的时候不再使用type 而是varname stringage intsex string}tom.name tomtom.sex mantom.age 20fmt.Printf(tom: %v\n, tom)fmt.Printf(tom.name: %v\n, tom.name)
}结构体的初始化package mainimport fmtfunc main() {type person struct {name, email stringage, id int}//第一种初始化的方法键值对的方式var tom persontom person{name: tom,email: tomgmail.com,age: 20,id: 111,}fmt.Printf(tom: %v\n, tom)//第二种初始化的方法列表的方式var Y4y17 personY4y17 person{//这种初始化的方法必须按照结构体成员定义的顺序进行初始化Y4y17,Y4y17gmail.com,20,16,}fmt.Printf(Y4y17: %v\n, Y4y17)//第三种初始化的方法支持短变量赋值Mary : person{//部分赋值也是可以的name: Mary,id: 22,}fmt.Printf(Mary: %v\n, Mary)
}
输出结果如下
tom: {tom tomgmail.com 20 111}
Y4y17: {Y4y17 Y4y17gmail.com 20 16}
Mary: {Mary 0 22}结构体指针package mainimport (fmt
)
//普通的指针变量
func test1() {var name string Y4y17var nm *stringnm namefmt.Printf(name: %v\n, name)fmt.Printf(nm: %v\n, nm)fmt.Printf(nm: %v\n, *nm)
}
//结构体指针
func test2() {type person struct {name stringage intid int}var p_struct *person//这里存在3种赋值的方式//第一种方式p_struct person{name: Y4y17,age: 20,id: 17,}fmt.Printf(p_struct: %v\n, *p_struct)//第二种方式var tom person person{tom, 20, 17}var p_struct1 *personp_struct1 tomfmt.Printf(p_struct1: %v\n, *p_struct1)//第三种方式var p_struct2 new(person)p_struct2.age 22p_struct2.name Maryfmt.Printf(p_struct2: %v\n, *p_struct2)
}func main() {test2()
}
输出结构如下
p_struct: {Y4y17 20 17}
p_struct1: {tom 20 17}
p_struct2: {Mary 22 0}结构体作为函数的参数package mainimport fmttype person struct {name stringage intid int
}func show_person(per person) {per.name Y4y17per.age 24per.id 17fmt.Printf(per: %v\n, per)
}
func main() {Mary : person{name: Mary,age: 23,id: 99,}fmt.Printf(Mary: %v\n, Mary)fmt.Printf(--------------------------\n)show_person(Mary)fmt.Printf(Mary: %v\n, Mary)
}
Mary: {Mary 23 99}
--------------------------
per: {Y4y17 24 17}
Mary: {Mary 23 99}package mainimport fmttype person struct {name stringage intid int
}func show_person(per *person) {per.name Y4y17per.age 24per.id 17fmt.Printf(per: %v\n, *per)
}
func main() {Mary : person{name: Mary,age: 23,id: 99,}fmt.Printf(Mary: %v\n, Mary)fmt.Printf(--------------------------\n)show_person(Mary)fmt.Printf(Mary: %v\n, Mary)
}修改一下代码使得变成传递地址的方式
Mary: {Mary 23 99}
--------------------------
per: {Y4y17 24 17}
Mary: {Y4y17 24 17}结构体的嵌套package mainimport fmttype person struct {name stringage intid intcat cat //结构体中嵌套着一个cat结构体
}type cat struct {name stringage intcolor string
}func main() {cat : cat{name: 敢敢,age: 1,color: grey,}Y4y17 : person{name: Y4y17,age: 23,id: 17,cat: cat,}fmt.Printf(Y4y17: %v\n, Y4y17)fmt.Printf(Y4y17.cat.name: %v\n, Y4y17.cat.name)
}
Y4y17: {Y4y17 23 17 {敢敢 1 grey}}
Y4y17.cat.name: 敢敢Go语言中的方法go语言没有面向对象的特性也没有类对象的概念。但是可以使用结构体来模拟这些特性我们都知道面向;象里面有类方法等概念。我们也可以声明一些方法属于某个结构体。Go语言方法的语法Go中的方法是一种特殊的函数定义于struct之上(与struct关联、绑定)被称为struct的接受者(receiver)。通俗的讲方法就是有接收者的函数。语法格式如下
type mytype struct{}
func (recv mytype) my_method( para) return_type {}
func (recv *mytype) my_method(para) return_type {}
mytype :定义一个结构体
recv∶接受该方法的结构体(receiver)my_method:方法名称
para :参数列表
return_type :返回值类型从语法格式可以看出一个方法和一个函数非常相似多了一个接受类型。package mainimport fmttype person struct {name string
}func (per person) eat() {fmt.Printf(%v eating...\n, per.name)
}
func (per person) sleep() {fmt.Printf(%v sleeping...\n, per.name)
}
func main() {var tom persontom.name tomtom.eat()tom.sleep()
}
package mainimport fmttype customer struct {name string
}func (cus customer) login(name string, pwd string) bool {if name tom pwd 123 {return true} else {return false}
}
func main() {cus : customer{name: tom,}b : cus.login(tom, 123)fmt.Printf(b: %v\n, b)
}Go语言方法的注意事项方法的receiver type并非一定要是struct类型type定义的类型别名、slice、map、channel、func类型等都可以。struct结合它的方法就等价于面向对象中的类。只不过struct可以和它的方法分开并非一定要属于同一个文件但必须属于同一个包。方法有两种接收类型: (T Type)和(T *Type)它们之间有区别。方法就是函数所以Go中没有方法重载(overload)的说法也就是说同一个类型中的所有方法名必须都唯一。如果receiver是一个指针类型则会自动解除引用。方法和type是分开的意味着实例的行为(behavior)和数据存储(field)是分开的但是它们通过receiver建立起关联关系。Go语言方法接收者类型分为值类型和指针类型package mainimport fmttype customer struct {name string
}//传值
func (cus customer) test1() {cus.name Y4y17
}//传递指针
func (cus *customer) test2() {cus.name Y4y17
}
func main() {cus : customer{name: tom,}cus.test1()fmt.Printf(cus: %v\n, cus) //cus: {tom}cus.test2()fmt.Printf(cus: %v\n, cus) //cus: {Y4y17}}
