教程集 > Golang编程 > golang教程 > 正文 golang 类型等

golang 类型等

发布时间：2023-03-18 编辑：jiaochengji.com

教程集为您提供golang 类型等等资源，欢迎您收藏本站，我们将为您提供最新的golang 类型等资源

go标识符

Go源文件中的变量名、常量名、类型名、函数名、接口名、语句标号和包等等都可以成为标识符，必须以一个Unicode字母为下划线开头，气候跟任意字母、数据或者下划线。

常用

关键字(共25个)：
break、case、chan、const、continue、default、defer、else、failthrough、for、func、go、goto、if、import、interface、map、package、range、return、select、struct、swith、type、var

预定义标识符（30多个）：
- 内建常量：true、false、iota、nil
- 内建类型：int、int8、int16、int32、int64、uintpter\float32、float64、complex64、compltx128、bool、byte、rune、string、error、
- 内建函数 make、len、capnew、append、complex、real、imag、panic、recover。

注意：函数内部定义的标识符，只能在函数内部访问。函数外不包括函数自身和自定义标识符，若首字母大写，则可以被外部包和所在包内访问；若首字母小写，则不能被外部包访问，只能在所在包内访问。


程序又标识符、运算符、分隔符、和各种标点符号最终组成。

go类型种类

const 声明常量，
type 声明新类型，
func 申明函数，
package 申明包，
interface 声明接口。

go变量

var 变量名类型

全局变量与const常量在内存中数据区存储
局部变量在与函数一样在内存中栈区存储

go 关于变量的问题

golang 单引号一般用与rune类型。

字符串请强烈使用双引号双引号一般用于可解析的字符串字面量。

反引号一般用于sql html 正则是原声的字符串字面量

使用var 申明变量自动化初始值以及申明变量类型，若提供了初始值，可以生虐变量类型，有编译器自动推断

示例：
var x int
var f float = 1.6
var s = 'abc'  ///这个地方可以这样做var s string = "abc"

若在函数内部定义变量可以不提前申明但用法如下

在函数内部 定义变量示例：
func main(){
    x:=123 
}

/// 特别注意 假如这个函数内的局部变量于全局变量名一样的话 计入使用全局变量就直接使用 若使用局部变量就用 :=
1. 尽量少的使用全局变量。
2. 尽量少的使用:=语法糖。
3. 使用:=的时候要确保左值没有被定义过。

下划线 _ 可做占位符 通常从左边开始顺数匹配占位 占位符为空

make 与 new 区别

make用于内建类型（map、slice 和channel）的内存分配。new用于各种类型的内存分配。

内建函数new本质上说跟其它语言中的同名函数功能一样：new(T)分配了零值填充的T类型的内存空间，并且返回其地址，即一个*T类型的值。用Go的术语说，它返回了一个指针，指向新分配的类型T的零值。有一点非常重要：new返回指针。


内建函数make(T, args)与new(T)有着不同的功能，make只能创建slice、map和channel，并且返回一个有初始值(非零)的T类型，而不是*T。

本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个slice，是一个包含指向数据（内部array）的指针、长度和容量的三项描述符；在这些项目被初始化之前，slice为nil。对于slice、map和channel来说，make初始化了内部的数据结构，填充适当的值。make返回初始化后的（非零）值。

make 是 引用类型 初始化的方法
new是申请新内存并返回指针引用

new会分配结构空间，并初始化为清空为零，不进一步初始化 主要给int、float32、struct...返回的事指针
new之后需要一个指针来指向这个结构
make会分配结构空间及其附属空间，并完成其间的指针初始化主要给channel、map、slice 主要用来分配引用类型
make返回这个结构空间，不另外分配一个指针

go 语言的常量问题

常量值必须是编译期可确定的数字、字符串、布尔值。

go语言的类型转换类型

不支持隐式转换，即便是从窄向宽转换也是不可以的。

var b byte=100
var n int = int(b)  ///这是显式转换。

同样也不能将其他类型当bool值使用
a := 100
if a{
    println("true")
}

枚举 iota

枚举 常量生成器 只能是整形数据
枚举是 默认第一个值为0 换行逐渐1
举例：
    
写法一：
    const(
    a = iota
    b = iota //其实从第二行开始可以不用鞋iota 默认为枚举
    c = iota
    d = iota 
    )
    
    注意 ：1，同一行的时候一排都是同样的值
           2. 定义第一排可以赋值  但换行后值不会随着换行增长

枚举的另一种神奇写法二
    type EventApppenStatus int
    const (
    	_,_ EventApppenStatus= iota , iota-1
    	Success,DuplicateEvent
    	Failed,DuplicateCommand
    )


枚举的另一种神奇写法三
    type EventApppenStatus int
    const (
    	Success EventApppenStatus = iota 1
    	DuplicateEvent
    	Failed
    	DuplicateCommand
    )



枚举的另一种神奇写法三
    enum StatusCode {
                UNDEFINED = 0;
                SUCCESS = 200;
                FAILURE = 500;
            }

  
  
枚举的另一种神奇写法四
    package main
    
    import (
    	"fmt"
    )
    
    type State int
    
    // iota 初始化后会自动递增
    const (
    	Running    State = iota // value --> 0
    	Stopped                 // value --> 1
    	Rebooting               // value --> 2
    	Terminated              // value --> 3
    )
    
    func (this State) String() string {
    	switch this {
    	case Running:
    		return "Running"
    	case Stopped:
    		return "Stopped"
    	default:
    		return "Unknow"
    	}
    }
    
    func main() {
    	state := Stopped
    	fmt.Println("state", state)
    }

go赋值

基本赋值语法格式

1，变量 = 表达式，例如 var a int:a=1     ///这是将变量a赋值为int类型且a=1
2，变量里的元素 = 表达式，例如 var arr [3]int = [3];int{1,2,3}

声明变量类型的同时赋值

1，变量 类型 = 表达式，例如 var arr [3]
int = [3]int{1,2,3}

符合操作

1，变量 运算符 = 表达式，例如：var 不int = 10; b  =1
2，变量里的元素 运算符 = 表达式; 例如：var arr [3]int; arr[1]  = 2

自增和自减语句，使用数值类型，不能放在表达式中。

变量  、变量--，例如 var i int = 99; i

元祖赋值

变量1,变量2,变量3 = 表达式1,变大时2,变量3，例如：var x,y,z int; x,y,z=1,2,3

简短声明，声明变量同时直接赋值，变量类型则有go自推导（与python类似）

变量:=表达式，例如： gopher:='liuxin'

类型可以是Go语言内置的各种数据类型、复合数据类型(字符串、接口、函数、切片、指针、map、chan)、接口 甚至是自定义类型

特别说明：申明变量会给变量设定零值。数据类型为变量零值为0、布尔类型为false、字符串类型零值为空字符串、接口、函数、切片、指针、map、chan零值为nil、数组或结构体则为构成它们的元素对应类型的零值。```

go 类型转换

go 查看变量类型 reflect.TypeOf(变量名 )

int 转string

s:=strconv.Itoa(i) 等价于 strconv.FormatInt(int(i),10)
示例：
func zhuan(){
	var a int = 2
	fmt.Println(a,reflect.TypeOf(a))
	b:=strconv.Itoa(a)
	b:=strconv.FormatInt(int64(a),10)
	fmt.Println(b,reflect.TypeOf(b))
}

int64转string

i := int64(123)
s := strconv.FormatInt(i, 10)
第二个参数为基数，可选2~36

注：对于无符号整形，可以使用FormatUint(i uint64, base int)

示例：

func zhuan(){
	i := int64(1234)
	fmt.Println(i,reflect.TypeOf(i))
	s:=strconv.FormatInt(i,10)
	fmt.Println(s,reflect.TypeOf(s))
}

string转int

i,err :=strconv.Atoi(s)
字符串转int有一个空值变量一起跟着转换，所以可以用一个_ 来承接这个nil 
示例：
func zhuan(){
	a1 := "223344"
	fmt.Println(a1,reflect.TypeOf(a1))
	b2,_:=strconv.Atoi(a1)
	fmt.Println(b2,reflect.TypeOf(b2))
}

string 转 int64

i, err := strconv.ParseInt(s, 10, 64)
第二个参数为基数（2~36），第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，分别对应 int, int8, int16, int32和int64

func zhuan(){
    a1 := "223344"
	b3,_:=strconv.ParseInt(a1,10,64)
	fmt.Println(b3,reflect.TypeOf(b3))
}

float 相关

string转float

func zhuan(){
	s3:="3.1415926535"
	b4,_:=strconv.ParseFloat(s3,32)
	b5,_:=strconv.ParseFloat(s3,64)
	fmt.Println(b4,reflect.TypeOf(b4))
	fmt.Println(b5,reflect.TypeOf(b5))
}

float转string

func zhuan(){
	s4:=3.1415926535
	b6:=strconv.FormatFloat(s4, 'E', -1, 32)
	b7:=strconv.FormatFloat(s4, 'E', -1, 64)
	fmt.Println(b6,reflect.TypeOf(b6))   ///3.1415927E 00 string
	fmt.Println(b7,reflect.TypeOf(b7))       ///3.1415926535E 00 string
}
注意语法类型：
s1 := strconv.FormatFloat(v, 'E', -1, 32) 
v代表要转换的变量，'E'为参数，-1为对应转换过去的小数点后续数量，32/64为需要转变的类型
/// 'b' (-ddddp±ddd，二进制指数)
/// 'e' (-d.dddde±dd，十进制指数)
/// 'E' (-d.ddddE±dd，十进制指数)
/// 'f' (-ddd.dddd，没有指数)
/// 'g' ('e':大指数，'f':其它情况)
/// 'G' ('E':大指数，'f':其它情况)

//string到int int,err:=strconv.Atoi(string)

//string到int64 int64, err := strconv.ParseInt(string, 10, 64) //int到string string:=strconv.Itoa(int)

//int64到string string:=strconv.FormatInt(int64,10)

//string到float32(float64) float,err := strconv.ParseFloat(string,32/64)

//float到string string := strconv.FormatFloat(float32, 'E', -1, 32) string := strconv.FormatFloat(float64, 'E', -1, 64)

// 'b' (-ddddp±ddd，二进制指数)

// 'e' (-d.dddde±dd，十进制指数)

// 'E' (-d.ddddE±dd，十进制指数)

// 'f' (-ddd.dddd，没有指数)

// 'g' ('e':大指数，'f':其它情况)

// 'G' ('E':大指数，'f':其它情况)

[]int8 相关

[]int8抓换为struct

struct 转 io.reader

b, err := json.Marshal(postdata)
if err != nil {
	return Tbm_response{false, "josndumps false"}
}
body := bytes.NewBuffer([]byte(b))

map转struct

struct 转map

package main

import (
	"fmt"
	"reflect"
	"time"
)

type User struct {
	Id        int64
	Username  string
	Password  string
	Logintime time.Time
}

func Struct2Map(obj interface{}) map[string]interface{} {
	t := reflect.TypeOf(obj)
	v := reflect.ValueOf(obj)

	var data = make(map[string]interface{})
	for i := 0; i < t.NumField(); i   {
		data[t.Field(i).Name] = v.Field(i).Interface()
	}
	return data
}

func main() {
	user := User{5, "zhangsan", "pwd", time.Now()}
	data := Struct2Map(user)
	fmt.Println(data)
}

作者： Chelydra
链接： https://blog.csdn.net/Chelydra/article/details/99618629
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

到此这篇关于“golang 类型等”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
Golang将IP转为整型int存储
 goLang 类型断言 type assertion
golang判断变量的类型
 Go核心编程－面向对象 [OOP]
Golang 标准库：strconv 包的应用
 golang error 包使用以及error类型原理
 go语言中map的实现原理
 golang基础教程
 Golang设计模式之原型模式
 golang学习之结构体，方法，接口

上一篇：golang的一些基础数据类型转换下一篇：go语言的channel特性

[关闭]