func getVal(num1 int, num2 int) (int, int) {
sum := num1 + mum2
sub := num1 - num2
return sum, sub
}
func main() {
sum, sub := getVal(30, 30)
fmt.Println("sum=", sum, "sub=", sub)
sum2, _ := getVal(10, 30)
fmt.Println("sum=", sum2)
}package main
import "fmt"
func main() {
//定义变量
var i int
//给i赋值
i = 10
//使用变量
fmt.Println("i=",i)
}
D:\goproject\src\go_code\chapter02\demon01>go run main.go
i= 10package main
import "fmt"
func main() {
//golang的变量使用方式
//第一种：指定变量类型，定义后若不赋值，使用默认值
//init的默认值是0
var i int
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
i= 02）第二种，根据值自行判断变量类型（类型引导）
package main
import "fmt"
func main() {
//第二种：根据值自行判断变量类型（类型推导）
var num = 10.11
fmt.Println("num=", num)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
num= 10.113）第三种，省略var定义变量并赋值
package main
import "fmt"
func main() {
//第三种：省略var,:= 的:不能省略，否则报错
//下面的方式等价于 var name string name = "tom"
name := "tom"
fmt.Println("name=", name)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
name= tom多变量定义
1）在编程中，有时我们需要一次性定义多个变量，Golang也提供了这样的语法【在函数里面定义】
package main
import "fmt"
func main() {
//该案例演示Golang如何一次性定义多个变量
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)
//一次性定义多个变量的方式二
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1,"b2=", b2,"b3=", b3)
//一次性定义多个变量的方式三，同样可以使用类型推导
c1, name, c3 := 200, "mary", 999
fmt.Println("c1=", c1,"name=", name,"c3=", c3)
}
D:\goproject\src\go_code\chapter02\demon03>go run main.go
a1= 0 a2= 0 a3= 0
b1= 100 b2= tom b3= 888
c1= 200 name= mary c3= 9992）一次性定义全局变量【在go中函数外部定义变量就是全局变量】
package main
import "fmt"
//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的定义方式，也可以改成一次性定义
var (
n3 = 300
n4 = 400
name2 = "zhangsan"
)
func main() {
fmt.Println("n1=", n1,"n2=", n2,"name=", name)
fmt.Println("n3=", n3,"n4=", n4,"name2=", name2)
}
D:\goproject\src\go_code\chapter02\demon03>go run var.go
n1= 100 n2= 200 name= jack
n3= 300 n4= 400 name2= zhangsanpackage main
import "fmt"
func main() {
//该区域的数据值可以在同一类型范围内不断变化
var i int = 10
i = 30
i = 50
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon03>go run var02.go
i= 50程序中+号的使用
1）当左右两边都是数值型时，则做加法运算；
2）当左右两边都是字符串时，则做字符串拼接；
package main
import "fmt"
//演示golang中+号的使用
func main() {
var i = 1
var j = 2
var r = i + j //做加法运算
fmt.Println("r=", r)
var str1 = "hello"
var str2 = "world"
var res = str1 + str2 //做拼接操作
fmt.Println("res=", res)
}
D:\goproject\src\go_code\chapter02\demon04>go run main.go
r= 3
res= helloworld每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间。
package main
import(
"fmt"
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
}D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int3）如何在程序查看某个变量的字节大小和数据类型
package main
import(
"fmt"
"unsafe" //前提引入unsafe函数
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
//如何在程序查看某个变量的占用字节大小和数据类型
var n2 int64 = 10
//unsafe.Sizeof(n2) 是unsafe包的一个函数，可以返回n2变量占用的字节数
fmt.Printf("n2 的数据类型是 %T\nn2占用的字节大小是 %d", n2, unsafe.Sizeof(n2))
}D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int
n2 的数据类型是 int64
n2占用的字节大小是 84）Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。
5）bit：计算机中的最小存储单位；byte：计算机中基本存储单元；1byte=8bit
package main
import(
"fmt"
)
//演示golang中小数类型使用
func main() {
var price float32 = 87.23
fmt.Println("price", price)
}D:\gocode\goproject02\main02>go run main.go
price 87.23
var num3 float32 = -123.00000901
var num4 float64 = -123.00000901
fmt.Println("num3=", num3,"num4=", num4)D:\goproject\src\go_code\chapter02\floatdemo06>go run main.go
num3= -123.00001 num4= -123.00000901说明：float64 的精度比float32 的要准确。
//Golang的浮点类型默认声明为float64类型
var a = 1.1
fmt.Printf("a的数据类型为 %T \n", a)D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
a的数据类型为 float643）浮点型常量有两种表示形式；
① 十进制数形式：如 5.12 .512（必须有小数点）
//十进制数形式
b := 5.12
c := .123
fmt.Println("b=", b, "c=", c)D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
b= 5.12 c= 0.123② 科学计数法形式：如 5.1234e2 ==== 5.12 * 10的2次方； 5.12E-2 ==== 5.12/10的2次方
//科学计数法形式
d := 5.1234e2 // 5.1234 * 10的2次方
e := 5.1234E2 // 5.1234 * 10的2次方
f := 5.1234E-2 // 5.1234 / 10的2次方
fmt.Println("d=", d, "e=", e, "f=",f)D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
d= 512.34 e= 512.34 f= 0.0512344）Golang浮点型只有这两种类型，float32 和 float64，float64 比 float32 更精确。
案例演示
package main
import(
"fmt"
)
//演示golang中字符类型使用
func main() {
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//当直接输出byte值，就是输出了对应字符的码值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
//如果希望输出对应字符，需要格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2)
//如果输出的码值高于byte（0-255）的范围，输出就会溢出,可以用int
var c3 int = '北'
fmt.Printf("c3=%c c3对应码值=%d", c3, c3)
}D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c1= 97
c2= 48
c1=a c2=0
c3=北 c3对应码值=21271对上面代码说明：
1）如果保存的字符在ASCII表，比如【0-1，a-z，A-Z...】直接可以保存到byte；
2）如果保存的字符对应码值大于255，这时可以考虑使用int类型保存；比如中文；
3）如果需要按照字符的方式输出，这时需要格式化输出，即 fmt.Printf("%c", c1)。
//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符；
var c4 int = 22269 //22269 -> '国'
fmt.Printf("c4=%c\n", c4)D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c4=国6）字符类型是可以进行运算的，相当于一个整数，因为它都有对应的Unicode码；
//字符类型是可以进行运算的，相当于一个整数，运算时按照码值运行；
var n1 = 10 + 'a' // 相当于 10 + 97 = 107
fmt.Println("n1=", n1)D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
n1= 107package main
import(
"fmt"
"unsafe"
)
//演示golang中bool类型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事项
//1. bool类型占用存储空间为1个字节
fmt.Println("b 的占用字节 =", unsafe.Sizeof(b))
//2. bool类型只能取true或者false
}D:\goproject\src\go_code\chapter02\booldemo08>go run main.go
b= false
b 的占用字节 = 1//演示golang中string类型使用
func main() {
//string的基本使用
var address string = "北京长城 112 helloworld！"
fmt.Println(address)
}D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
北京长城 112 helloworld！//使用双引号，支持转义字符
str1 := "abc\nbcd"
fmt.Println(str1)D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
abc
bcd②反引号，以字符串的原生形式输出，包括换行和特殊字符，可以输出源代码等效果。
//使用反引号，以字符串的原生形式输出，适用于输出源码
str2 := `
package main
import(
"fmt"
)
`
fmt.Println(str2)D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
package main
import(
"fmt"
)3）字符串拼接方式
//字符串拼接方式
var str3 = "hello" + "world!"
fmt.Println(str3)D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!4）当拼接字符串太长时，需要使用到多行字符串，可以如下处理【注意，将+号留在上一行】
//当拼接的字符串很长时，可以分行写，注意将+保留在上一行
var str4 = "hello" + "world!" + "world!" + "world!" +
"hello" + "world!" + "world!" + "world!" + "hello" +
"world!" + "world!" + "world!" + "hello" + "world!" +
"world!" + "world!"
fmt.Println(str4)D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!world!world!helloworld!world!world!helloworld!world!world!helloworld!
world!world!
package main
import(
"fmt"
)
//基本数据类型的默认值
func main() {
var a int // =0
var b float32 // =0
var c float64 // =0
var d bool // false
var name string // ""
//这里的%v 表示按照变量的值输出
fmt.Printf("a=%d,b=%v,c=%v,d=%v,name=%v", a,b,c,d,name)
}D:\goproject\src\go_code\chapter02\defaultdemo10>go run main.go
a=0,b=0,c=0,d=false,name=package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v", i,n1,n2)
}D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v\n", i,n1,n2)
//被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化！！！
fmt.Printf("i type is %T", i)
}D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100
i type is int323）在转换中，比如将 int64 转换成 int8（-128----127），编译时不会出错，只是转换的结果是按溢出处理，和我们希望的结果不一样，因此在转换时，需要考虑范围。
//在转换中，比如将 int64 转换成 int8（-128----127），编译时不会出错;
//只是转换的结果是按溢出处理，和我们希望的结果不一样;因此在转换时，需要考虑范围。
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2=", num2)D:\goproject\src\go_code\chapter02\transtype11>go run main.go
num2= 63课堂练习
1）以下代码编译不能通过和解决方案
package main
import(
"fmt"
)
func main() {
var n1 int32 = 12
var n2 int64
var n3 int8
//不能编译通过，因为没有进行数据类型转换
n2 = n1 + 20 //int32 ----> int64 错误
n3 = n1 + 20 //int32 ----> int8 错误
//以下是解决方案
n2 = int64(n1) + 20
n3 = int8(n1) + 20
fmt.Println("n2=", n2, "n3=", n3)
}2）如果相加的值大于本身的数据类型范围，则编译不通过
func main() {
//如果相加的值大于本身的数据类型范围，则编译不通过
var n4 int32 = 12
var n5 int8
var n6 int8
n5 = int8(n4) + 127 //【编译通过，但是结果按溢出处理】
n6 = int8(n4) + 128 //【编译不通过，因为128超出int8数据类型的范围】
fmt.Println("n5=", n5)
}基本数据类型转换string类型
1）方式一：fmt.Sprintf("%参数"， 表达式)
函数介绍：
func Sprintf
func Sprintf(format string, a ...interface{}) string
Sprintf根据format参数生成格式化的字符串并返回该字符串。参数需要和表达式的数据类型相匹配；fmt.Sprintf().. 会返回转换后的字符串。
案例演示：
package main
import(
"fmt"
)
//演示golang中基本数据类型转换string类型
func main() {
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
var myChar byte = 'h'
var str string //空的string
//使用第一种方式 fmt.Sprintf 来转换
str = fmt.Sprintf("%d", num1)
fmt.Printf("str type %T; str=%q\n", str, str)
str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T; str=%q\n", str, str)
str = fmt.Sprintf("%t", b)
fmt.Printf("str type %T; str=%q\n", str, str)
str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T; str=%q", str, str)
}D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.456000"
str type string; str="true"
str type string; str="h"2）方式二：使用strconv包的函数
函数介绍：
func FormatBool(b bool) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string案例说明：
package main
import(
"fmt"
"strconv"
)
func main() {
//使用第二种方式 strconv 函数来转换
var num3 int = 99
var num4 float64 = 23.456
var b2 bool = true
str = strconv.FormatInt(int64(num3), 10)
fmt.Printf("str type %T; str=%q\n", str, str)
//说明:'f'格式；10：表示小数位保留10位；64：表示这个小数是float64；
str = strconv.FormatFloat(num4, 'f', 10, 64)
fmt.Printf("str type %T; str=%q\n", str, str)
str = strconv.FormatBool(b2)
fmt.Printf("str type %T; str=%q", str, str)
//strconv包中有一个函数 Itoa，可以将int类型转换成string；
var num5 int = 3456
str = strconv.Itoa(num5)
fmt.Printf("str type %T; str=%q", str, str)
}D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.4560000000"
str type string; str="true"
str type string; str="3456"string类型转换基本数据类型
使用strconv包的函数，函数介绍：
func ParseBool(str string) (value bool, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)案例演示：
package main
import(
"fmt"
"strconv"
)
//演示golang中string类型转换基本数据类型
func main(){
var str string = "true"
var a bool
//strconv.ParseBool(str) 函数会返回两个值（value bool，err error）
//因为只想获取到value bool，使用_忽略第二个值；
a, _ = strconv.ParseBool(str)
fmt.Printf("a type %T; a=%v\n", a, a)
var str2 string = "1234566"
var b int64
b, _ = strconv.ParseInt(str2, 10, 64)
fmt.Printf("b type %T; b=%v\n", b, b)
var str3 string = "124.324"
var c float64
c, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("c type %T; c=%v", c, c)
}D:\goproject\src\go_code\chapter02\string2basictype13>go run main.go
a type bool; a=true
b type int64; b=1234566
c type float64; c=124.324说明一下，由于strconv函数返回的是int64或float64，如果希望得到int32，float64等，如下处理：
var d int64
d = int32(d)基本介绍
1）基本数据类型，变量存的就是值，也叫值类型；变量存值都对应一个地址。
2）获取变量的地址，用 &，比如：var num int，获取num的地址：&num
分析一下基本数据类型在内存的布局:
3）指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值。比如：var ptrint = &num
举例说明：指针在内存中的布局
4）获取指针类型所指向的值，使用星号，*ptr
package main
import(
"fmt"
)
//演示golang中指针类型
func main() {
//基本数据类型在内存布局
var i int = 10
//i的地址是什么，&i
fmt.Println("i的地址=", &i)
//ptr是一个指针变量；ptr的类型是*int；
//ptr本身的值为&i（变量i对应的地址）;
var ptr *int = &i
fmt.Printf("ptr=%v\n", ptr)
fmt.Printf("ptr的地址=%v\n", &ptr)
//获取指针类型所指向的值，使用 *
fmt.Printf("ptr指向的值=%v", *ptr)
}D:\gocode\goproject02\pointerdemo>go run main.go
i的地址= 0xc042050058
ptr=0xc042050058
ptr的地址=0xc04206e020
ptr指向的值=10案例演示
1）写一个程序，获取一个int变量num的地址，并显示到终端；
2）将num的地址赋给指针ptr，并通过ptr去修改num的值。
package main
import(
"fmt"
)
func main() {
var num int = 100
fmt.Println("num的地址=", &num)
var ptr *int = &num
fmt.Printf("ptr=%v\n", ptr)
*ptr = 200
fmt.Println("num=", num)
}D:\gocode\goproject02\pointerdemo>go run main02.go
num的地址= 0xc042050058
ptr=0xc042050058
num= 200
创新互联www.cdcxhl.cn，专业提供香港、美国云服务器，动态BGP最优骨干路由自动选择，持续稳定高效的网络助力业务部署。公司持有工信部办法的idc、isp许可证， 机房独有T级流量清洗系统配攻击溯源，准确进行流量调度，确保服务器高可用性。佳节活动现已开启，新人活动云服务器买多久送多久。
