当前位置 : 主页 > 编程语言 > 其它开发 >

【Golang】关于Go中一些常用的知识介绍

来源:互联网 收集:自由互联 发布时间:2022-05-30
一、哪些类型可以作为map的key ?1、可比较的类型都可以作为map key boolean 布尔值 numeric 数字 包括整型、浮点型,以及复数 string 字符串 pointer 指针 两个指针类型相等,表示两指针指向同
一、哪些类型可以作为map的key ? 1、可比较的类型都可以作为map key
  • boolean 布尔值

  • numeric 数字 包括整型、浮点型,以及复数

  • string 字符串

  • pointer 指针 两个指针类型相等,表示两指针指向同一个变量或者同为nil

  • channel 通道 两个通道类型相等,表示两个通道是被相同的make调用创建的或者同为nil

  • interface 接口 两个接口类型相等,表示两个接口类型 的动态类型 和 动态值都相等 或者 两接口类型 同为 nil

  • structs、arrays 只包含以上类型元素

2、不能作为map key 的类型包括
  • slices

  • maps

  • functions

3、下面针对几种类型的比较做举例说明
package main

import (
	"fmt"
)

type Orange struct {
	Host string
	Port int
}

func main() {
	
	// 指针
	orange1 := Orange{}
	orange2 := Orange{}

	op11 := &orange1
	op12 := &orange1
	op2 := &orange2

	fmt.Println("op11 == op12 :", op11 == op12) // true
	fmt.Println("op11 == op2 :", op11 == op2) // false

	// 通道
	ch1 := make(chan int, 1)
	ch2 := ch1
	ch3 := make(chan int, 1)

	fmt.Println("ch1 == ch2 :", ch1 == ch2) // true
	fmt.Println("ch1 == ch3 :", ch1 == ch3) // false

	// 结构体
	orange3 := Orange{}
	orange4 := Orange{}
	orange5 := Orange{"host001", 22}

	fmt.Println("orange3 == orange4 :", orange3 == orange4) // true
	fmt.Println("orange3 == orange5 :", orange3 == orange5) // false

	// 数组
	a1 := [1]int{0}
	a2 := [1]int{0}

	fmt.Println("a1 == a2 :", a1 == a2) // true
}

输出结果

op11 == op12 : true
op11 == op2 : false
ch1 == ch2 : true
ch1 == ch3 : false
orange3 == orange4 : true
orange3 == orange5 : false
a1 == a2 : true 
二、关于make及切片slice、映射map详解

内建函数 make 用来为 slice,map 或 chan 类型分配内存和初始化一个对象(注意:只能用在这三种类型上),使用make来创建slice,map,chanel说明如下:

1、make 创建slice
make([]Type, len, cap)

cap可以省略。当cap省略时,默认等于len。此外cap >= len >= 0的条件必须成立。例如,创建一个len和cap均为10的int型slice。

// 长度为5,容量为10的slice,slice中的元素是int
var slice_ []int = make([]int,5,10)
fmt.Println(slice_)

var slice_1 []int = make([]int,5)
fmt.Println(slice_1)

var slice_2 []int = []int{1,2}
fmt.Println(slice_2)

用第三个参数设置该slice的容量(即底层数组的长度)。如果能够预足容量,那么在slice中数据增长的过程中不需要更换底层数组(附带拷贝过程),这样效率更高。

2、make 创建 map
make(map[keyType] valueType, size)

keyType表示map的key类型,valueType表示map的value类型。size是一个整型参数,表示map的存储能力,该参数可省略。

var m_ map[string]int = make(map[string]int)
m_["one"] = 1
fmt.Println(m_)

var m map[string]int = map[string]int{"1":1}
m["2"] = 2
fmt.Println(m)  

根据 size 大小来初始化分配内存,不过分配后的 map 长度为 0,如果 size 被忽略了,那么会在初始化分配内存时分配一个小尺寸的内存

3、make 创建chanel
make(chan Type, size)

使用make创建channel,第一个参数是channel类型。size表示缓冲槽大小,是一个可选的大于或等于0的整型参数,默认size = 0。当缓冲槽不为0时,表示通道是一个异步通道。

package main
 
import "fmt"
 
func main() {
	demo := make(chan int, 10)
	fmt.Println("demo:", demo)
	// output: demo: map[]
	fmt.Println("len(demo):", len(demo))
	// output: len(demo): 0
	fmt.Println("cap(demo):", cap(demo))
	// output: cap(demo): 10

}
4、关于new函数

Go提供内建函数new

func new(Type) *Type

它只接受一个参数,这个参数是一个类型,分配好内存后,返回一个指向该类型内存地址的指针。同时请注意它同时把分配的内存置为零,也就是类型的零值。

func main() {
 var i *int
 i=new(int)
 *i=10
 fmt.Println(*i)
}

它返回的永远是类型的指针,指向分配类型的内存地址

5、注意事项 make和new的区别
  • new的作用是初始化一个指向类型的指针(*T)。使用new函数来分配空间,传递给new函数的是一个类型,不是一个值。返回的是指向这个新分配的零值的指针。(内存置为零)

  • make的作用是为slice、map或chan初始化并返回引用(T)。make仅仅用于创建slice、map和channel,并返回它们的实例。(非零值)

  • make返回的还是这三个引用类型本身;而new返回的是指向类型的指针

  • new不常用,通常都是采用短语句声明以及结构体的字面量达到我们的目的

  • make函数是无可替代的,二者都是内存的分配堆上

6、映射map
  • map是一种数据结构,用于存储一系列无序的键值对,类似java的HashMap

  • 通过散列表实现,使用两个数据结构来存储数据,一个数组用于选择桶的散列键的高八位值,可以区分每个键值属于哪个桶;另一个字节数组,用于存储键值对

  • 创建方式make(map[keyType] valueType, cap),其中keyType表示键类型,valueType表示值类型,cap表示初始存储能力

//创建了一个键类型为string、值类型为PersonInfo
myMap = make(map[string] PersonInfo) 
//也可以选择是否在创建时指定该map的初始存储能力,创建了一个初始存储能力为100的map.
myMap = make(map[string] PersonInfo, 100) 
//创建并初始化map的代码.
myMap = map[string] PersonInfo{ 
  "1234": PersonInfo{"1", "Jack", "Room 101,..."}, 
} 
三、关于数组和切片的区别 ? 
  • Slice和数组类似,也是表示一个有序元素,但这个序列的长度可变,具有动态长度特性;

  • 切片是指针类型,数组是值类型;

  • 数组的长度是固定的,而切片不是(切片可以看成动态的数组);

  • 切片比数组多一个容量(cap)属性;

  • 切片的底层是数组;

  • 多个切片可以指向同一个底层数组,实现了内存共享

  • 切片本身是一个只读对象,其工作机制类似数组指针的一种封装

以下代码输出什么?如果去掉注释又输出什么?

package main

import (
   "fmt"
)

func main() {
   a := [2]int{5, 6}
   b := [2]int{5, 6}

   if a == b {
      fmt.Println("equal")
   } else {
      fmt.Println("not equal")
   }

   /*
      if a[:] == b[:] {
          fmt.Println("equal")
      } else {
          fmt.Println("not equal")
      }
   */
}

输出:equal,去掉注释提示: invalid operation: a[:] == b[:] (slice can only be compared to nil)

go语言中数组和切片的区别

所以,a、b定义的是数组类型,数组对比是相同的,但是,a[:]、b[:]是切片,切片之间不能进行等值判断,只能和nil判断

 

上一篇:深度学习与CV教程(5) | 卷积神经网络
下一篇:没有了
网友评论