Go语言学习二 （变量及常量与数据类型）

最新推荐文章于 2023-06-27 11:13:01 发布
最新推荐文章于 2023-06-27 11:13:01 发布
阅读量187 收藏
点赞数
分类专栏： Go 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LlZzSss/article/details/123599951
版权

目录

一、变量

1. 定义

变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
变量可以通过变量名访问。
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字。

var identifier type
//可以一次声明多个变量
var identifier1, identifier2 type

2. 变量声明方式

第一种：指定变量类型，如果没有初始化，则变量默认为零值

var num1 int = 123
var num2 float32	// num2 没有赋值，默认为 0

//---------------------------
package main

import "fmt"

var num1 int = 123
var num2 float32

func main() {
	fmt.Println(num1)
	fmt.Println(num2)
}
//---------------------------
结果：
123
0

第二种：根据值自行判定变量类型

var num = 456

//-----------------------
package main

import "fmt"

var num = 456

func main() {
	fmt.Println(num)
}
//----------------------------
456

第三种：如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误

v_name := value

//---------------------------
var intVal int 
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明


intVal := 1 
//等于
var intVal int
intVal =1 


f := "Runoob" // var f string = "Runoob"

3. 多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

4. 全局变量和局部变量

package main

import "fmt"

//全局变量
var num1 = 123
var num2 = 456

func main() {
	//局部变量
	num3 := 789
	fmt.Println(num1)
	fmt.Println(num2)
	fmt.Println(num3)
}

程序运行的时候，先加载全局变量，然后加载局部变量。

5. 变量的作用域

  • 在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。
  • 在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用。当然，不包含这个全局变量的源文件需要使用 “import” 关键字引入全局变量所在的源文件之后才能使用这个全局变量。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。
  • 在定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。形式参数会作为函数的局部变量来使用。
    请添加图片描述

6. 值类型与引用类型

6.1 值类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量 直接指向存在内存中的值。
请添加图片描述

  • 当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝。
    请添加图片描述
  • 可以通过 &i 来获取变量 i 的内存地址，例如：0xc00000a0a0（每次的地址都可能不一样）。
package main

import "fmt"

func main() {
	i := 50
	fmt.Println(&i)
}

//结果
0xc00000a0a0
  • 值类型变量的值存储在堆中。
  • 内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。

值的拷贝

//定义了一个数组 a，它是值类型，复制给 b 是 copy，当 b 发生变化后 a 并不会发生任何变化
package main

import "fmt"

func main(){
	a := [5]int{2, 3, 4, 5, 6}
	b := a
	fmt.Println(a,b)
	b[2] = 77
	fmt.Println(a,b)
}

//结果
[2 3 4 5 6] [2 3 4 5 6]
[2 3 4 5 6] [2 3 77 5 6]

值引用

//定义了一个数组 a，它是引用类型（slice 切片），被 b 引用（指针）后，当 b 发生变化后 a 也发生任何变化
package main

import "fmt"

func main(){
	a := []int{2, 3, 4, 5, 6}
	b := a
	fmt.Println(a,b)
	b[2] = 77
	fmt.Println(a,b)
}

//结果
[2 3 4 5 6] [2 3 4 5 6]
[2 3 77 5 6] [2 3 77 5 6]

6.2 引用类型

  • 复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
  • Golang 中引用类型：指针，slice，map，channel，接口，函数等。变量存放的是一个内存地址值，这个地址值指向的空间存的才是最终的值。内存通常在堆中分配，当没有任务变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，通过 GC 回收。
  • Go 没有引用传递，都是值传递。
var a = []int{1,2,3,4,5}
b := a      //此时a，b都指向了内存中的[1 2 3 4 5]的地址
b[1] = 10   //相当于修改同一个内存地址，所以a的值也会改变
c := make([]int,5,5)    //切片的初始化
copy(c,a)   //将切片acopy到c
c[1] = 20   //copy是值类型，所以a不会改变
fmt.Printf("a的值是%v，a的内存地址是%p\n",a,&a)   //a的值是[1 10 3 4 5]，a的内存地址是0xc42000a180
fmt.Printf("b的值是%v，b的内存地址是%p\n",b,&b)   //b的值是[1 10 3 4 5]，b的内存地址是0xc42000a1a0
fmt.Printf("c的值是%v，c的内存地址是%p\n",c,&c)   //c的值是[1 20 3 4 5]，c的内存地址是0xc42000a1c0
d := &a     //将a的内存地址赋值给d，取值用*d
a[1] = 11
fmt.Printf("d的值是%v，d的内存地址是%p\n",*d,d)   //d的值是[1 11 3 4 5]，d的内存地址是0xc420084060
fmt.Printf("a的值是%v，a的内存地址是%p\n",a,&a)   //a的值是[1 11 3 4 5]，a的内存地址是0xc420084060


总结：
值赋值（值类型）和地址赋值（引用类型）是不一样的，值赋值它们的内存地址是不同的，只是值一样，修改一个变量的值不会改另一个；地址赋值两个变量指向了同一个地址，这个内存地址存放了一个值，表现出来的就是两个变量值一样，修改其中一个值另一个也会修改。

7. 空白标识符

Golang 中不允许变量声明了但不使用。既然不想使用，何必声明变量呢，那就将变量用空白符代替，反正空白符就是用来抛弃的。

package main

import "fmt"

func main() {
	str1,str2,str3,str4 := test()
	fmt.Println("str1=",str1,"\nstr2=",str2,"\nstr3=",str3,"\nstr4=",str4)
}

func test() (int,float64,bool,string) {
	a,b,c,d := 20,30.5,true,"hello"
	return a,b,c,d
}

// 结果
str1= 20 
str2= 30.5 
str3= true 
str4= hello

上面的代码如果我们不想要输出第一个参数怎么办呢，代码如下：

package main

import "fmt"

func main() {
	_,str2,str3,str4 := test()
	fmt.Println("str2=",str2,"\nstr3=",str3,"\nstr4=",str4)
}

func test() (int,float64,bool,string) {
	a,b,c,d := 20,30.5,true,"hello"
	return a,b,c,d
}

// 结果
str2= 30.5 
str3= true 
str4= hello

想要替换哪个就在相应位置设为 -

二、常量

1. 定义

  • 常量是一个简单值的标识符，在程序运行时，不会被修改的量。
  • 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
  • 常量的定义格式：
const identifier [type] = value

可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义：const b string = “abc”
  • 隐式类型定义：const b = “abc”

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

声明一个常量

const MAX = 4096

声明一个指定类型的常量

const LIMIT int16 = 1024
const LIMIT2 = int16(1024)

声明一组常量

const (
    start  = 0x1 
    resume = 0x2 
    stop   = 0x4 
)

声明一组指定类型的常量

const (
    start  int8 = 0x1 
    resume int8 = 0x2 
    stop   int8 = 0x4 
)

综合示例

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5  
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)  
}

//结果
面积为 50
1 false str

2. iota

  • iota：特殊常量，可以认为是一个可以被编译器修改的常量。
  • iota 在 const 关键字出现时将被重置为 0（const 内部的第一行之前），const 中每新增一行常量声明将使 iota 计数一次（iota 可理解为 const 语句块中的行索引）。
package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

// 结果
0 1 2 ha ha 100 100 7 8


package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

// 结果
i= 1
j= 6
k= 12
l= 24

请添加图片描述

三、数据类型

在 Go 编程语言中，数据类型用于声明函数和变量。
数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
Go 语言按类别有以下几种数据类型：

序号类型和描述
1布尔型: 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2数字类型: 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4派生类型: 包括：指针类型（Pointer）,数组类型,结构化类型(struct),Channel 类型,函数类型,切片类型,接口类型（interface）,Map 类型

1. 布尔值

package main

import "fmt"

func main() {
	var a bool = true
	var b bool
	fmt.Println(a)
	fmt.Println(b)
}

// 结果
true
false

2. 数字类型

序号 类型和描述
1uint8 无符号 8 位整型 (0 到 255)
2uint16 无符号 16 位整型 (0 到 65535)
3uint32 无符号 32 位整型 (0 到 4294967295)
4uint64 无符号 64 位整型 (0 到 18446744073709551615)
5int8 有符号 8 位整型 (-128 到 127)
6int16 有符号 16 位整型 (-32768 到 32767)
7int32 有符号 32 位整型 (-2147483648 到 2147483647)
8int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
package main

import "fmt"

func main() {
	a := 10
	b := 10.0
	c := true
	d := "test"
	fmt.Printf("a 的类型为 %T",a)
	fmt.Println()
	fmt.Printf("b 的类型为 %T",b)
}

//结果
a 的类型为 int
b 的类型为 float64

//---------------------------------------------//
package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
}

// 结果
3.141593
3.14

//-----------------------------------------//
var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
fmt.Println(x*y)                 // "(-5+10i)"
fmt.Println(real(x*y))           // "-5"
fmt.Println(imag(x*y))           // "10"

3. 字符串类型

package main

import "fmt"

func main() {
	a := "ddasas2252"
	fmt.Println(a)
	fmt.Printf("a 的类型为 %T",a)
}

// 结果
ddasas2252
a 的类型为 string

4. 其他类型

4.1 指针类型

  • & 取内存地址
  •   * 根据地址取值

基本数据类型和内存

package main
import(
        "fmt"
)
func main(){
        var age int = 18
        //&符号+变量 就可以获取这个变量内存的地址
        fmt.Println(&age) //0xc0000a2058
}

请添加图片描述

指针变量

package main
import(
        "fmt"
)
func main(){
        var age int = 18
        //&符号+变量 就可以获取这个变量内存的地址
        fmt.Println(&age) //0xc0000a2058
        //定义一个指针变量：
        //var代表要声明一个变量
        //ptr 指针变量的名字
        //ptr 对应的类型是：*int 是一个指针类型 （可以理解为指向int类型的指针）
        //&age 就是一个地址，是ptr变量的具体的值
        var ptr *int = &age
        fmt.Println(ptr)
        fmt.Println("ptr本身这个存储空间的地址为：",&ptr)
        //想获取ptr这个指针或者这个地址指向的那个数据：
        fmt.Printf("ptr指向的数值为：%v",*ptr) //ptr指向的数值为：18
}

请添加图片描述
可以通过指针改变指向值

func main(){
        var num int = 10
        fmt.Println(num)
        var ptr *int = &num
        *ptr = 20
        fmt.Println(num)
}

// 结果
10
20
  • 指针变量接收的一定是地址值。
  • 指针变量的地址不可以不匹配。
  • 基本数据类型（又叫值类型），都有对应的指针类型，形式为 *数据类型，比如 int 的对应的指针就是 *int，float32 对应的指针类型就是 *float32。依次类推。

5. 数据类型转换

  • Go 在不同类型的变量之间赋值时需要显式转换，并且只有显式转换（强制转换）。
  • 类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型 将 int16 转换为 int32。当从一个取值范围较大的类型转换到取值范围较小的类型时 将 int32 转换为 int16 或 将 float32 转换为 int，会发生精度丢失 截断 的情况。
  • 只有相同底层类型的变量之间可以进行相互转换 如将 int16 类型转换成 int32 类型，不同底层类型的变量相互转换时会引发编译错误 如将 bool 类型转换为 int 类型。
  • 语法：valueOfTypeB = typeB(valueOfTypeA)（类型 B 的值 = 类型 B(类型 A 的值)）
package main

import "fmt"

func main() {
	a := 5.2
	b := int(a)
	fmt.Println("a 的值为",a)	// 如果小数为 0 会省略
	fmt.Printf("a 的类型为 %T\n",a)
	fmt.Printf("b 的类型为 %T",b)
}

// 结果
a 的值为 5.2
a 的类型为 float64
b 的类型为 int

字符串格式化参考：字符串格式化

5.1 基本数据类型转 string 类型

  • 方式 1：fmt.Sprintf("%参数",表达式)(推荐方式)
  • 方式 2：使用 strconv 包的函数

方法一

package main
import "fmt"
func main(){
	var n1 int = 19
	var n2 float32 = 4.78
	var n3 bool = false
	var n4 byte = 'a'
	var s1 string = fmt.Sprintf("%d",n1)
	fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
	var s2 string = fmt.Sprintf("%f",n2)
	fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
	var s3 string = fmt.Sprintf("%t",n3)
	fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
	var s4 string = fmt.Sprintf("%c",n4)
	fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
}

// 结果
s1对应的类型是：string ，s1 = "19" 
s2对应的类型是：string ，s2 = "4.780000" 
s3对应的类型是：string ，s3 = "false" 
s4对应的类型是：string ，s4 = "a"

方法二

package main
import(
        "fmt"
        "strconv"
)
func main(){
        var n1 int = 18
        var s1 string = strconv.FormatInt(int64(n1),10)  //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        var n2 float64 = 4.29
        var s2 string = strconv.FormatFloat(n2,'f',9,64)
        //第二个参数：'f'（-ddd.dddd）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        var n3 bool = true
        var s3 string = strconv.FormatBool(n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}

// 结果
s1对应的类型是：string ，s1 = "18" 
s2对应的类型是：string ，s2 = "4.290000000" 
s3对应的类型是：string ，s3 = "true"

5.2 string 类型转基本类型

package main
import(
        "fmt"
        "strconv"
)
func main(){
        //string-->bool
        var s1 string = "true"
        var b bool
        //ParseBool这个函数的返回值有两个：(value bool, err error)
        //value就是我们得到的布尔类型的数据，err出现的错误
        //我们只关注得到的布尔类型的数据，err可以用_直接忽略
        b , _ = strconv.ParseBool(s1)
        fmt.Printf("b的类型是：%T,b=%v \n",b,b)
        //string---》int64
        var s2 string = "19"
        var num1 int64
        num1,_ = strconv.ParseInt(s2,10,64)
        fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
        //string-->float32/float64
        var s3 string = "3.14"
        var f1 float64
        f1,_ = strconv.ParseFloat(s3,64)
        fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
        //注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
        var s4 string = "golang"
        var b1 bool
        b1 , _ = strconv.ParseBool(s4)
        fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
        var s5 string = "golang"
        var num2 int64
        num2,_ = strconv.ParseInt(s5,10,64)
        fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}

// 结果
b的类型是：bool,b=true 
num1的类型是：int64,num1=19 
f1的类型是：float64,f1=3.14 
b1的类型是：bool,b1=false 
num2的类型是：int64,num2=0
LlZzSss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GO语言基本数据类型总结
12-25
本文实例总结了GO语言基本数据类型。分享给大家供大家参考。具体如下： 1、注释（与C++一样） 行注释：//块注释：/* …*/ 2、标识符 可以这么说，除了数字开头的不允许，符号开头的不允许，关键字不允许，其他的...
golang format时间格式化
qq_53603794的博客
05-26 1138
golang format时间格式化
Golang 字符串格式化
深漂小码哥
11-29 928
Golang 字符串格式化
09-golang格式化输出
hanjinjuan的博客
05-22 5335
文章目录概念哪些函数支持PrintSprint占位符使用占位符类型结构体通用占位符布尔占位符整数占位符浮点数和复数字符串与字节切片指针其它标记精度截断字符串实例 概念 在 Golang 中，格式化的输入与输出，都需要使用到格式化占位符。比如获取用户输入的数据的函数 fmt.Scanf() ，格式化输出的函数 fmt.Printf()。 Go 语言的格式化占位符大概可分为普通占位符、布尔 占位符、整数 占位符、浮点数 和 复数 占位符、字符串 与 字节切片 占位符、指针 占位符以及其它标记等。 哪些函数支持
Golang 学习三（变量/常量与数据类型）
shenyuanhaojie的博客
03-17 887
文章目录一、变量1. 定义2. 变量声明方式3. 多变量声明4. 全局变量和局部变量5. 值类型与引用类型5.1 值类型5.2 引用类型二、常量1. 定义2. iota三、数据类型1. 布尔值2. 数字类型3. 字符串类型4. 指针类型 一、变量 1. 定义 变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。 变量可以通过变量名访问。 Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。 声明变量的一般形式是使用 var 关键字。 var identifier type /
Go_数据类型转换（Sprintf、Format）
itzhuzhu的博客
02-08 4307
类型转换是将一种数据类型的变量转为另一种类型的变量 Go强制要求使用显式类型转换。所以语法更能确定语句及表达式的明确含义 转换的时候如果大的转给小的，会有精度损失（数据溢出）比如int64转int8............
详解Golang编程中的常量与变量
01-20
Go语言常量 常量是指该程序可能无法在其执行期间改变的固定值。这些固定值也被称为文字。 常量可以是任何像一个整型常量，一个浮点常量，字符常量或字符串文字的基本数据类型。还有枚举常量。 常量是一样，只是它们...
Golang入门-数据类型
01-07
 任何Go语言源码文件都由若干个程序实体组成的，再Go语言中，变量，常量，函数，结构体和接口统称为“程序实体”，而它们的名字统称为“标识符”。  标识符可以是任何unicode编码可以表示的字母字符，数字以及...
Go 语言数据类型
01-03
在 Go 编程语言中，数据类型用于声明函数和变量。 数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。 Go 语言按类别有以下几种数据类型...
go语言中文教程及手册.pdf
05-06
《go语言中文教程及手册》包含了语言结构、基础语法、数据类型、语言变量、语言常量以及运算符等内容的介绍，可以让你快速进阶为go语言编程高手。简洁，一句废话没有，对于初学者可以让大家快速掌握GO语言！
Golang时间格式化
Jaemon
10-10 5652
Golang时间格式化
Go源码解析之format.go
techdashen的博客
06-27 214
在处理时间格式化时，程序会逐个字符读取时间格式化字符串，当遇到%字符时，就会读取该字符后面的字符来判断该占位符的类型，并做出相应的操作，如替换成实际的数字或文本。最后，将这个切片转换为一个字符串，并将其返回。在time包中，时间格式字符串必须包含相应的时间部分，如“2006-01-02 15:04:05”，其中年用2006表示，月用01表示，日用02表示，小时用15表示，分钟用04表示，秒用05表示，这个时间格式字符串是Golang作者们的一个约定，目的是为了帮助程序员更好地理解时间格式字符串。
golang中time.Format()方法时间显示不对的问题
sinat_35945236的博客
10-10 3694
golang中time.Format()方法时间显示不对的问题 在使用golang的time.Format()方法时，需要导入一个时间的模板，最开始的一直以为这个模板只要是我们自己的设置的模板，golang即可按照我们设置的模板就行识别，但是最终显示的时间始终不对，如下图 第一条是系统的时间，第二条是自己的设置的模板，代码如下： fmt.Println(time.Now()) ret := time.Now().Format("2006-10-10 12:00:00.000") return ret 修
fmt 包中的函数和方法
txj236的专栏
12-27 5003
/ Fprintf 将参数列表 a 填写到格式字符串 format 的占位符中 // 并将填写后的结果写入 w 中，返回写入的字节数 func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) // Printf 将参数列表 a 填写到格式字符串 format 的占位符中 // 并将填写后的
golang：类型转换
OceanStar的博客
07-01 1306
理论 在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明： valueOfTypeB = typeB(valueOfTypeA) 类型 B 的值 = 类型 B(类型 A 的值) 示例 a := 5.0 b := int(a) 类型转换只能在定义正确的情况下转换成功， 例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将 int16 转换为 int32）。 当从一个取值范围较大的类型转换到取值范围较小的类型时（将
Golang学习笔记（三）——数据类型转换
yushuaigee的博客
05-24 1430
目录 1. 强制类型转换 2. strconv包：字符串和数值类型的相互转换 1. 强制类型转换 类似于其他语言，Go语言也支持强制类型转换： //valueOfTypeB = typeB(valueOfTypeA) //类型 B 的值 = 类型 B(类型 A 的值) a := 5.0 b := int(a) 但是只有相同底层类型的变量之间可以进行相互转换（如将 int16和int32相互转换，float类型和 int 类型相互转换），不同底层类型的变量相互转换时会引发编译错误（如...
坑爹的golang日期时间格式format()
weixin_30378623的博客
11-12 1276
今天重拾golang，用到了format()函数格式化字符串，用了语句time.now().format(“2015-11-12 12:00:00”)，结果输出结果就是不能达到理想的结果，然后把golang文档中的”2006-01-02 15:04:05“放进去就可以了，搞了好久没搞明白怎么回事，随意百度了一下，原来golang规定必须要用这个时间点...
Golang基础--01--类型，变量与常量
ListentTome的博客
05-23 210
注意事项 - 省略调用和别名不能同时使用 - go关键字25个，都是小写 - 常量，变量，类型，接口，结构，首字母大写就是public,首字母小写是private，一个包是一个整体 - 常量，变量，一般类型（非struct,interface)都可以组合成组 - var只能声明全局变量，也可以在函数体里面用，但是不建议这样用 - type：自定义类型，可以用来更改类型的名字...
Golang格式化输出
ymxyld的博客
05-22 1022
Golang格式化输出向外输出fmt.Printfmt.Fprintfmt.Sprintfmt.Errorf获取输入fmt.Scanfmt.Scanffmt.Scanlnbufio.NewReaderFscan系列Sscan系列占位符通用占位符布尔型整型浮点数与复数字符串和[]byte指针宽度标识符其他flag fmt包实现了类似C语言printf和scanf的格式化I/O。 向外输出 fmt.Print Print系列函数会将内容输出到系统的标准输出，区别在于Print函数直接输出内容，Printf函数支
go语言学习思维导图
最新发布
01-11
很高兴为您介绍Go语言学习思维导图。根据提供的引用内容，Go语言学习思维导图...通过学习这些内容，您将对Go语言的基础知识、数据类型、流程控制、函数、复合数据类型、面向对象、泛型、并发和反射有一个全面的了解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值