zhe.ink 在线工具箱

此示例旨在演示指针的声明和访问指针指向的变量的值。

以下是我们应用程序的目录结构。

├── parent
│   ├── go.mod
│   ├── main.go
│   └── child
│       └── child.go

进入parent目录，执行以下命令，创建名为 parent 的go模块。

go mod init parent

上面的命令将创建一个名为 go.mod 的文件。以下是文件的内容。

module parent

go 1.14

parent\main.go代码如下：

package main

import (
	"fmt"
	c "parent/child"
)

func main() {
	a := &c.Data
	fmt.Println("Address of Data is", a)
	fmt.Println("Value of Data is", *a)
	*a++
	c.PrintData()
}

我们将子包别名为c。& 运算符用于获取变量的地址。在main函数中，我们现在可以使用上面的别名访问数据的地址。我们解引用a并打印它的值。

parent\child\child.go代码如下：

package child

import "fmt"

var Data = 10

func PrintData() {
	fmt.Println("Value of Data is", Data)
}

在child文件夹中创建一个文件child.go。子文件夹中的文件应以行包子文件夹开头，因为它属于子包。

parent>go run main.go

如果运行该程序，将获得以下输出。

Address of Data is 0x563230
Value of Data is 10
Value of Data is 11

Go语言教程之边写边学：类型转换-将integer转换为float

我们可以用int32(),float64()等数字类型直接进行转换。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var f32 float32 = 10.6556
	fmt.Println(reflect.TypeOf(f32))

	i32 := int32(f32)
	fmt.Println(reflect.TypeOf(i32))
	fmt.Println(i32)

	f64 := float64(i32)
	fmt.Println(reflect.TypeOf(f64))
}

输出

float32
int32
10
float64

Go语言教程之边写边学：类型转换-将float32转换为float64，将float64转换为float32

我们可以使用float64()或float32()直接进行转换。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var f32 float32 = 10.6556
	fmt.Println(reflect.TypeOf(f32))

	f64 := float64(f32)
	fmt.Println(reflect.TypeOf(f64))

	f64 = 1097.655698798798
	fmt.Println(f64)

	f32 = float32(f64)
	fmt.Println(f32)
}

输出

float32
float64
1097.655698798798
1097.6556

Go语言教程之边写边学：类型转换-将Int数据类型转换为 Int16 Int32 Int64

我们可以直接使用类型转换方法。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var i int = 10
	fmt.Println(reflect.TypeOf(i))

	i16 := int16(i)
	fmt.Println(reflect.TypeOf(i16))

	i32 := int32(i)
	fmt.Println(reflect.TypeOf(i32))

	i64 := int64(i)
	fmt.Println(reflect.TypeOf(i64))
}

输出

int
int16
int32
int64

Go语言教程之边写边学：类型转换-integer到string转换的不同方式

像大多数现代语言一样，Golang 包含 Integer 作为内置类型。让我们举个例子，你可能有一个包含整数值的变量，你想把它转换为字符串。为了在Golang中将整数值转换为字符串类型，您可以使用以下方法。

FormatInt()方法

您可以使用strconv包的FormatInt()函数将 int 转换为字符串值。FormatInt 返回给定基数中i的字符串表示形式，对于2<=基数<= 36。结果使用小写字母“a”到“z”表示数字值 >= 10。

func FormatInt(i int64, base int) string

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var i int64 = 125
	fmt.Println(reflect.TypeOf(i))
	fmt.Println(i)

	var s string = strconv.FormatInt(i, 10)
	fmt.Println(reflect.TypeOf(s))
	
	fmt.Println("Base 10 value of s:", s)
	
	s = strconv.FormatInt(i, 8)
	fmt.Println("Base 8 value of s:", s)
	
	s = strconv.FormatInt(i, 16)	
	fmt.Println("Base 16 value of s:", s)
	
	s = strconv.FormatInt(i, 32)	
	fmt.Println("Base 32 value of s:", s)
}

输出

int64
125
string
Base 10 value of s: 125
Base 8 value of s: 175
Base 16 value of s: 7d
Base 32 value of s: 3t

FMT.Sprintf() 方法

Sprintf根据格式说明符设置格式，并返回结果字符串。在这里，a是接口类型，因此您可以使用此方法将任何类型转换为字符串。

func Sprintf(format string, a ...interface{}) string

package main

import (
	"fmt"
	"reflect"
)

func main() {
	b := 1225
	fmt.Println(reflect.TypeOf(b))

	s := fmt.Sprintf("%v", b)
	fmt.Println(s)
	fmt.Println(reflect.TypeOf(s))
}

输出

int
1225
string

Go语言教程之边写边学：类型转换-如何在 Go 中将浮点转换为字符串类型？

像大多数现代语言一样，Golang 将 Float 作为内置类型包含在内。让我们举个例子，你可能有一个包含 Float 值的变量。为了在Golang中将Float值转换为字符串类型，您可以使用以下方法。

FormatFloat()方法

您可以使用strconv包的 FormatFloat()函数将浮点数转换为字符串值。FormatFloat根据格式fmt和精度prec将浮点数f转换为字符串。它对结果进行舍入，假设原始数据是从bitSize位的浮点值获得的（浮点数为 32，浮点数 32 为 64）。

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var f float64 = 3.1415926535
	fmt.Println(reflect.TypeOf(f))
	fmt.Println(f)

	var s string = strconv.FormatFloat(f, 'E', -1, 32)
	fmt.Println(reflect.TypeOf(s))
	fmt.Println(s)
}

输出

float64
3.1415926535
string
3.1415927E+00

FMT.Sprintf()方法

Sprintf根据格式说明符设置格式，并返回结果字符串。在这里，a 是接口类型，因此您可以使用此方法将任何类型转换为字符串。

func Sprintf(format string, a ...interface{}) string

package main

import (
	"fmt"
	"reflect"
)

func main() {
	b := 12.454
	fmt.Println(reflect.TypeOf(b))

	s := fmt.Sprintf("%v", b)
	fmt.Println(s)
	fmt.Println(reflect.TypeOf(s))
}

输出

float64
12.454
string

Go语言教程之边写边学：类型转换-如何在Go中将布尔类型转换为字符串？

像大多数现代语言一样，Golang包含布尔值作为内置类型。让我们举个例子，你可能有一个包含布尔值true的变量。为了在Golang中将布尔值转换为字符串类型，您可以使用以下方法。

FormatBool函数

您可以使用strconv包的FormatBool()函数将布尔值转换为字符串值。FormatBool根据b的值返回“true”或“false”。

func FormatBool(b bool) string

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var b bool = true
	fmt.Println(reflect.TypeOf(b))

	var s string = strconv.FormatBool(true)
	fmt.Println(reflect.TypeOf(s))
}

输出

bool
string

Go语言教程之边写边学：类型转换-如何在Go中将字符串转换为布尔数据类型转换？

像大多数现代语言一样，Golang包含字符串作为内置类型。让我们举个例子，你可能有一个包含布尔值“true”的字符串。但是，由于此值表示为字符串，因此无法对其执行任何操作。需要将此字符串类型显式转换为布尔类型，然后才能对其执行任何操作。

字符串到布尔值的转换

导入包strconv以执行与字符串之间的转换。ParseBool返回由字符串表示的布尔值。它接受1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False。任何其他值都会返回错误。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s1 := "true"
	b1, _ := strconv.ParseBool(s1)
	fmt.Printf("%T, %v\n", b1, b1)

	s2 := "t"
	b2, _ := strconv.ParseBool(s2)
	fmt.Printf("%T, %v\n", b2, b2)

	s3 := "0"
	b3, _ := strconv.ParseBool(s3)
	fmt.Printf("%T, %v\n", b3, b3)

	s4 := "F"
	b4, _ := strconv.ParseBool(s4)
	fmt.Printf("%T, %v\n", b4, b4)
}

输出

bool, true
bool, true
bool, false
bool, false

Go语言教程之边写边学：类型转换-如何在Go中将字符串转换为浮点类型？

像大多数现代语言一样，Golang 包含字符串作为内置类型。让我们举个例子，你可能有一个包含数值“3.1415926535”的字符串。但是，由于此值表示为字符串，因此无法对其执行任何数学计算。您需要将此字符串类型显式转换为浮点类型，然后才能对其执行任何数学计算。

ParseFloat()函数

ParseFloat将字符串s转换为由bitSize指定的精度的浮点数：32表示float32,64表示float64。当bitSize=32时，结果的类型仍然为float64，但它可以转换为float32，而无需更改其值。

func ParseFloat(s string, bitSize int) (float64, error)

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	s := "3.1415926535"
	f, err := strconv.ParseFloat(s, 8)
	fmt.Println(f, err, reflect.TypeOf(f))

	s1 := "-3.141"
	f1, err := strconv.ParseFloat(s1, 8)
	fmt.Println(f1, err, reflect.TypeOf(f1))

	s2 := "A-3141X"
	f2, err := strconv.ParseFloat(s2, 32)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(f2, err, reflect.TypeOf(f2))
	}
}

要检查转换过程中是否发生错误，请检查err变量是否包含nil值。

输出

3.1415926535 <nil> float64
-3.141 <nil> float64
strconv.ParseFloat: parsing "A-3141X": invalid syntax

Go语言教程之边写边学：类型转换-如何在Go中将字符串转换为整数类型？

像大多数现代语言一样，Golang 包含字符串作为内置类型。让我们举个例子，你可能有一个包含数值“100”的字符串。但是，由于此值表示为字符串，因此无法对其执行任何数学计算。需要将此字符串类型显式转换为整数类型，然后才能对其执行任何数学计算。为了在Golang中将字符串转换为整数类型，您可以使用以下方法。

Atoi()函数

您可以使用strconv包的Atoi()函数将字符串转换为整数值。Atoi 代表 ASCII 到整数。Atoi()函数返回两个值：转换结果和错误（如果有）。

func Atoi(s string) (int, error)

package main

import (
	"fmt"
	"strconv"
	"reflect"
)

func main() {
	strVar := "100"
	intVar, err := strconv.Atoi(strVar)
	fmt.Println(intVar, err, reflect.TypeOf(intVar))
}

输出

100 <nil> int

ParseInt()函数

ParseInt解释给定基数（0,2到36）和位大小(0,64)中的字符串s，并返回相应的值i。此函数接受字符串参数，根据基参数将其转换为相应的int类型。默认情况下，它返回Int64值。

func ParseInt(s string, base int, bitSize int) (i int64, err error)

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	strVar := "100"

	intVar, err := strconv.ParseInt(strVar, 0, 8)
	fmt.Println(intVar, err, reflect.TypeOf(intVar))

	intVar, err = strconv.ParseInt(strVar, 0, 16)
	fmt.Println(intVar, err, reflect.TypeOf(intVar))

	intVar, err = strconv.ParseInt(strVar, 0, 32)
	fmt.Println(intVar, err, reflect.TypeOf(intVar))

	intVar, err = strconv.ParseInt(strVar, 0, 64)
	fmt.Println(intVar, err, reflect.TypeOf(intVar))
}

输出

100 <nil> int64
100 <nil> int64
100 <nil> int64
100 <nil> int64

使用FMT.Sscan

fmt包提供了Sscan()函数，该函数扫描字符串参数并存储到变量中。此函数读取带有空格的字符串并赋值到连续的整数变量中。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	strVar := "100"
	intValue := 0
	_, err := fmt.Sscan(strVar, &intValue)
	fmt.Println(intValue, err, reflect.TypeOf(intValue))
}

输出

100 <nil> int

农历

五行

冲煞

彭祖

方位

宜

忌

吉神

凶神

极简任务管理 help

+ 0 0 0

Task Idea Collect