Golang基本类型使用总结 Golang基础（未完待续）

最新推荐文章于 2022-12-06 13:51:41 发布
最新推荐文章于 2022-12-06 13:51:41 发布
阅读量276 收藏 1
点赞数
分类专栏： Golang 文章标签： go golang 字符串 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010834463/article/details/116904727
版权

文章目录

bool

true false

int uint

int8 uint8 (byte)

func main() {
	var x byte
	x = '1'
	fmt.Println(x)
}

int16 uint16

int32 (rune) uint32

func main() {
	var y rune
	y = '我'
	fmt.Println(y)
}

int64 uint64

float32 / float64

complex64 / complex128 TODO

uintptr TODO

array

func main() {
	array := [5]int{1, 2, 3}
	var array2 [5]int
	array2 = *new([5]int)
	array2 = [5]int{1, 2, 3}
	fmt.Println(array)
	fmt.Println(array2)
}
// [number]Type{} 类型为[number]Type，即同一类型不同长度数组是不同类型

struct

type

type的原始类型和之后的类型可以互相赋值，但结构体必须精确一致（成员变量名字、类型和顺序）。

同一原始类型的不同之后的类型不能互相赋值。

func main() {
   var a struct{ x int }
   type Node struct{ x int }
   a = Node{1}
   fmt.Println(a)
   type Node2 struct{ x, y float64 }
   type Node3 struct{ x, y float64 }
   var b Node2
   b = struct{ x, y float64 }{y: 1.1}
   fmt.Println(b)
   //b = struct{ y, x float64 }{y: 1.1}
   /*b = struct {
      y float64
      x float64
   }{y: 1.1}*/
   b = struct {
      x float64
      y float64
   }{y: 1.2}
   fmt.Println(b)
   fmt.Printf("%T\n", b)
   //b = Node3{}	
   type Int int
   var x Int
   x = 1
   fmt.Println(x)
}

D:\gopath\src\mygo>go run main.go
{1}
{0 1.1}
{0 1.2}
main.Node2
1
成员函数

成员函数不区分原始型和指针型，不能重复定义。

type Node struct {
	a int
}

func (node *Node) Output() string {
	return "{!a:" + strconv.Itoa(node.a) + "}"
}
func (node Node) Output2() string {
	return "2{!a:" + strconv.Itoa(node.a) + "}"
}
func main() {
	var node1 = Node{1}
	var node2 = Node{2}
	fmt.Println(node1.Output())
	fmt.Println(node1.Output2())
	fmt.Println(node2.Output())
	fmt.Println(node2.Output2())
}

{!a:1}
2{!a:1}
{!a:2}
2{!a:2}
修改成员变量的成员函数

必须定义为func (*Type)…

type Node struct {
	a int
}

func (node *Node) Set(x int)  {
	node.a = x
}
func (node Node) Set2(x int)  {
	node.a = x
}
func main() {
	var node = Node{1}
	node.Set(3)
	fmt.Println(node)
	node.Set2(4)
	fmt.Println(node)
	(&node).Set(5)
	fmt.Println(node)
	(&node).Set2(6)
	fmt.Println(node)
}

{3}
{3}
{5}
{5}
覆盖

通过type定义新类型重新实现成员函数，进行覆盖。成员函数只适用于本身的类型

type Node struct {
	a int
}
type Node2 Node

func (node Node) Output() string {
	return fmt.Sprint(node)
}
func (node Node) Output2() string {
	return fmt.Sprint(node)
}
func (node2 Node2) Output() string {
	return fmt.Sprint("2", node2)
}
func (node2 Node2) Output3() string {
	return fmt.Sprint("2", node2)
}
func main() {
	node := Node{1}
	node2 := Node2{1}
	fmt.Println(node.Output())
	fmt.Println(node2.Output())
	fmt.Println((Node(node2)).Output())
	fmt.Println("------")
	fmt.Println(node.Output2())
	//fmt.Println(node2.Output2())
	fmt.Println((Node(node2)).Output2())
	fmt.Println("------")
	fmt.Println((Node2(node)).Output3())
	fmt.Println(node2.Output3())
	//fmt.Println((Node(node2)).Output3())
}

D:\gopath\src\mygo>go run main.go
{1}
2{1}
{1}
------
{1}
{1}
------
2{1}
2{1}
输出

对于fmt的Println或Printf("%v %+v")，可以通过func(Type)String() string定义，调用精确匹配的此接口

type Node struct {
	a int
}

func (node *Node) String() string {
	return "{!a:" + strconv.Itoa(node.a) + "}"
}
func main() {
	var node = Node{1}
	fmt.Println(node)
	fmt.Printf("%T\n", node)
	fmt.Printf("%v\n", node)
	fmt.Printf("%+v\n", node)
	fmt.Printf("%#v\n", node)
	fmt.Printf("------")
	fmt.Println(&node)
	fmt.Printf("%T\n", &node)
	fmt.Printf("%v\n", &node)
	fmt.Printf("%+v\n", &node)
	fmt.Printf("%#v\n", &node)
}

D:\gopath\src\mygo>go run main.go
{1}
main.Node
{1}
{a:1}
main.Node{a:1}
------{!a:1}
*main.Node
{!a:1}
{!a:1}
&main.Node{a:1}

string

正确统计中文字数
func main() {
	var s string
	s = "abc啊"
	fmt.Println(len(s))
	fmt.Println(len([]byte(s)))
	fmt.Println(len([]rune(s)))
	fmt.Printf("%T\n", s[0])
	fmt.Printf("%T\n", []byte(s)[0])
	fmt.Printf("%T\n", []rune(s)[0])
}

D:\gopath\src\mygo>go run main.go
6
6
4
uint8
uint8
int32
字符串连接效率

字符串反复+和[]byte append追加效率对比

func main() {
	seed := time.Now().Unix()
	rand.Seed(seed)
	var begin time.Time
	const number = 100000
	var s string
	begin = time.Now()
	for i := 0; i < number; i++ {
		s += strconv.Itoa(rand.Intn(i + 1))
	}
	fmt.Println(len(s))
	fmt.Println(time.Now().Sub(begin).Milliseconds())

	rand.Seed(seed)
	var b []byte
	begin = time.Now()
	for i := 0; i < number; i++ {
		b = append(b, strconv.Itoa(rand.Intn(i+1))...)
	}
	fmt.Println(len(b))
	fmt.Println(time.Now().Sub(begin).Milliseconds())
}

D:\gopath\src\mygo>go run main.go
460740
3886
460740
8
字符串数字互相转换
func main() {
	fmt.Println(fmt.Sprintf("%d", 1234567890))
	fmt.Println(strconv.Itoa(1234567890))
	a, err := strconv.Atoi("1234567890")
	if err != nil {
		panic(err)
	}
	fmt.Println(a)
	a, err = strconv.Atoi("123456.7890")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println(a)
}

D:\gopath\src\mygo>go run main.go
1234567890
1234567890
1234567890
strconv.Atoi: parsing "123456.7890": invalid syntax

slice []Type

切片构造、初始化、截取、追加、删除
func output(name string, slice []int) {
	fmt.Printf("%s %v\tlen:%v\tcap:%v\t%p\n",
		name, slice, len(slice), cap(slice), &slice[0])
}

func main() {
	s := []int{1, 2, 3, 4, 5}
	output("s", s)

	a := make([]int, 3, 5)
	a = s[1:4]
	output("a", a)

	// 修改派生切片影响基础切片/数组
	fmt.Println("modify slice")
	a = append(a, 6)
	output("a", a)
	output("s", s)
	// 基础数组无法容纳将重新分配空间
	/*a = append(a, 7)
	output("a", a)
	output("s", s)*/

	// 修改基础数组/切片影响派生切片
	fmt.Println("modify base array/slice")
	s = append(s[:2], s[3:]...)
	output("a", a)
	output("s", s)
	// 基础数组无法容纳将重新分配空间
	s = append(s, 7, 8)
	output("a", a)
	output("s", s)
}

D:\gopath\src\mygo>go run main.go
s [1 2 3 4 5]   len:5   cap:5   0xc0000143c0
a [2 3 4]       len:3   cap:4   0xc0000143c8
modify slice
a [2 3 4 6]     len:4   cap:4   0xc0000143c8
s [1 2 3 4 6]   len:5   cap:5   0xc0000143c0
modify base array/slice
a [2 4 6 6]     len:4   cap:4   0xc0000143c8
s [1 2 4 6]     len:4   cap:5   0xc0000143c0
a [2 4 6 6]     len:4   cap:4   0xc0000143c8
s [1 2 4 6 7 8] len:6   cap:10  0xc000010550

map

map设置，获取，删除，遍历
func main() {
	mp := make(map[int]int)
    // set 设置键值
	mp[1] = 1
	mp[2] = 4
	mp[3] = 9
    // 遍历
	for k := range mp {
		fmt.Println(k, "=>", mp[k])
	}
    // 确保键不存在
	delete(mp, 0)
	delete(mp, 1)
    // 获取键
	v, ok := mp[1]
	fmt.Println("v", v, "ok", ok)
	v, ok = mp[2]
	fmt.Println("v", v, "ok", ok)
    // 遍历
	for k, v := range mp {
		fmt.Println(k, "=>", v)
	}
    // 直接输出
	fmt.Println(mp)
	fmt.Printf("%#v\n", mp)
}

D:\gopath\src\mygo>go run main.go
1 => 1
2 => 4
3 => 9
v 0 ok false
v 4 ok true
2 => 4
3 => 9
map[2:4 3:9]
map[int]int{2:4, 3:9}

chan

channel写入只写，读取只读，关闭只写，关闭后读取
func main() {
	go func() {
		i := 1
		for {
			time.Sleep(time.Millisecond * 300)
			fmt.Println("clock:", i)
			i++
		}
	}()
	var ch = make(chan int)
	go func(chin chan<- int) {
		// 无法输入时阻塞
		chin <- 1
		fmt.Println("input sleep")
		time.Sleep(time.Second)
		chin <- 2
	}(ch)
	go func(chout <-chan int) {
		fmt.Println("output sleep")
		time.Sleep(time.Second)
		fmt.Println("ch[1]", <-chout)
		// 无法获取时阻塞，获取成功返回(value, true)
		v, ok := <-chout
		fmt.Println("ch[2]", v, ok)
	}(ch)

	time.Sleep(time.Second * 3)

	var chin chan<- int = ch
	close(chin)
	// 关闭后返回(0, false)
	x, ok := <-ch
	fmt.Println(x, ok)
}

D:\gopath\src\mygo>go run main.go
output sleep
clock: 1
clock: 2
clock: 3
ch[1] 1
input sleep
clock: 4
clock: 5
clock: 6
ch[2] 2 true
clock: 7
clock: 8
clock: 9
0 false

interface TODO

整数字面值为int类型（实际上取值范围是int64），小数字面值为float64类型。

func

可变长度参数
// 这个函数可以传入任意数量的整型参数
func sum(nums ...int) {
	fmt.Print(nums, " ")
	total := 0
	for _, num := range nums {
		total += num
	}
	fmt.Println(total)
}

func main() {
	// 支持可变长参数的函数
	sum(1)
	sum(1, 2, 3)
	// 把切片打散传入
	nums := []int{1, 2, 3, 4}
	sum(nums...)
}

D:\gopath\src\mygo>go run main.go
[1] 1
[1 2 3] 6
[1 2 3 4] 10
函数对象，函数柯里化，参数函数
type IntSlice []int

func (base IntSlice) Map(f func(x int) int) (slice IntSlice) {
	slice = make(IntSlice, len(base))
	for i, v := range base {
		slice[i] = f(v)
	}
	return
}

func main() {
	// 函数对象
	pow := func(x, y int) (ans int) {
		ans = 1
		for y > 0 {
			y--
			ans *= x
		}
		return
	}
	// 函数柯里化
	powBaseX := func(x int) func(y int) int {
		return func(y int) int {
			return pow(x, y)
		}
	}
	// 作为参数的函数
	fmt.Println(IntSlice([]int{1, 2, 3}).Map(powBaseX(2)))
}

D:\gopath\src\mygo>go run main.go
[2 4 8]
legend_yst
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang中值类型/指针类型的变量区别总结
09-21
golang的值类型和指针类型receiver一直是大家比较混淆的地方，下面这篇文章主要给大家总结介绍了关于golang中值类型/指针类型的变量区别的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下。
go语言基本数据类型
sydnash的专栏
12-05 3603
初识GO语言go是一门新语言，他在语言级提供了并发的支持（goroutine）和通信工具channel，同时它也是一门编译型、强类型的语言，拥有内存GC机制。程序的模块通过package来组织。GO基础整数 十进制整数，使用0-9的数字表示且不以0开头。 八进制整数，以0开头，0-7的数字表示 十六进制整数，以0X或者是0x开头，0-9|A-F|a-f组成 100 123455 0100 0600
golang 获取客户端IP
成长中de大神
09-11 1668
import ( "github.com/thinkeridea/go-extend/exnet" "net" "net/http" ) // RemoteIp 返回远程客户端的 IP，如 192.168.1.1 func RemoteIp(req *http.Request) string { remoteAddr := req.RemoteAddr if ip := exnet.ClientPublicIP(req); ip != "" { remoteAddr = ip } else
golang中json.Number妙用
秋天的博客
11-27 3746
golang中json.Number妙用   最近跟某斯调试一个API接口，接口返回数据是json格式 ，按文档描述是一个整型数据，于是定义如下 type Data struct { Api int `json:"api"` } 在入参相同的情况下，第一次调用，得到的结果是： {"api":1} 然而第二次调用，得到结果却是： {"api":...
Go | 闭包的使用
heyYouU的博客
12-06 149
闭包就是 一个函数和其相关的引用环境组合的一个整体，好处就是保存引用的变量，下次继续使用，不会销毁。
Golang 笔记 1 基础、基本数据类型
weixin_34130269的博客
03-12 224
一、Go语言基础 1. 基础 Go语言中的标识符必须以字母(Unicode字母，PHP/JS可以用中文作为变量名)下划线开头。大写字母跟小写字母是不同的:Hello和hello是两个不同的名字。  Go中有25个关键字: break default func interface select case defer go map struct...
mongodb官方的golang驱动基础使用教程分享
09-09
主要给大家介绍了关于mongodb官方的golang驱动基础使用的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用mongodb具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
深入理解golang的基本类型排序与slice排序
09-21
大家都知道排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的...下面就来详细介绍golang的基本类型排序与slice排序，有需要的朋友们可以参考借鉴。
golang语言强制类型转换
01-07
文章目录前言golang强制类型转换类型断言类型转换指针类型转换总结引用 前言 golang是强类型语言，有强制类型转换，但是不同于Java语言所使用的强制类型转换。 golang强制类型转换 golang语言中分为类型转换(type ...
Golang数字类型
搬砖填坑记
03-09 5818
Golang数字类型
golang-json中的数字
流承钧的博客
06-24 2468
json中的数字类型问题 JSON 协议中没有整型和浮点型之分，都是number。Go中json字符串中的数字经过json包反序列化会成为float64类型。如： package main import ( "encoding/json" "fmt" ) type Student struct { Name string `json:"name"` Age interface{} `json:"age"` Weight float64 `json:"weight"`
GOLANG简单类型定义，在协议解析的妙用
OSSRS
05-11 3933
在协议解析中，经常需要用到转换不同的含义，比如声音的采样率，在FLV中定义和AAC中定义是不同的。在FLV中只有4中采样率5512, 11025, 22050, 44100。而在AAC中有16种采样率96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350(还有4个是保留的)。也就
golang 获取客户端真实IP地址
Me5201314You的博客
04-24 7624
【Go】获取用户真实的ip地址 用户请求到达提供服务的服务器中间有很多的环节，导致服务获取用户真实的 ip 非常困难，大多数的框架及工具库都会封装各种获取用户真实 ip 的方法，在exnet包中也封装了各种 ip 相关的操作，其中就包含获取客户端 ip 的方法，比较实用的方法如下： func ClientIP(r *http.Request) stringClientIP 尽最大努力实现...
golang中net包用法（一）
热门推荐
chenbaoke的专栏
01-16 3万+
net包对于网络I/O提供了便携式接口，包括TCP/IP,UDP，域名解析以及Unix Socket。尽管net包提供了大量访问底层的接口，但是大多数情况下，客户端仅仅只需要最基本的接口，例如Dial，LIsten，Accepte以及分配的conn连接和listener接口。 crypto/tls包使用相同的接口以及类似的Dial和Listen函数。下面对net包进行具体分析。 首先介绍其中常量
golang中net包用法
senlin1202的博客
11-30 1978
net包对于网络I/O提供了便携式接口，包括TCP/IP,UDP，域名解析以及Unix Socket。尽管net包提供了大量访问底层的接口，但是大多数情况下，客户端仅仅只需要最基本的接口，例如Dial，LIsten，Accepte以及分配的conn连接和listener接口。 crypto/tls包使用相同的接口以及类似的Dial和Listen函数。下面对net包进行具体分析。 首先介绍其中常量： const ( IPv4len = 4 IPv6len = 16 ) 很容易看出这表示ip地
Go的魅力, 函数式(柯里化, 闭包, 高阶函数), Python@装饰器, 封装
angsu1392的博客
09-28 148
Go朴实无华的代码风格是函数式的无尽魅力.函数式有3个别名, 高大上的"柯里化", 编程语言的"闭包", 数学气息的"高阶函数".Python没有Go的func匿名函数, 但是具有可爱的语法糖(@装饰器).编程语言都是相通的, 层层封装造就了灵活的风格.理解了Go的"函数式", 再理解内嵌/接口/重写(设计模式), 剩下的是各个领域的工具了, 就可以写出服务于业务的代码.感悟于函数式h...
golang函数式编程之柯里化
u012280989的博客
02-25 1605
golang柯里化实现 直接上代码 // 定义可柯里化函数形式 type function func(...interface{}) interface{} // 通用柯里化函数 func (f function) curry(i interface{}) func(...interface{}) interface{} { return func(values ...interface{})...
函数柯里化
嘿嘿
06-12 489
文章目录 1.柯里化 1.1.示例1 1.2.示例2 1.3.示例3 柯里化 在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。 这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Sc...
07-golang数字类型
hanjinjuan的博客
05-16 645
文章目录go语言数字类型实例以二进制、八进制或十六进制浮点数的格式定义数字浮点型复数 go语言数字类型 Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。 Go 也有基于架构的类型，例如：int、uint 和 uintptr。 这些类型的长度都是根据运行程序所在的操作系统类型所决定的： int 和 uint 在 32 位操作系统上，它们均使用 32 位（4 个字节），在 64 位操作系统上，它们均使用 64 位（8 个字节）。 uintptr 的长度被设定为足够存放一个指针即可。
golang基本数据类型
最新发布
07-27
引用\[1\]提供了关于Golang的四大数据类型及基本类型的介绍。其中，基本类型包括数字类型、布尔型和字符串类型。数字类型包括整型和浮点型，还有其他数字类型。布尔型的值只能是常量true或false。字符串类型分为解释...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值