Go语言_通神路之灵胎篇(3)

1、变量

go的变量和java变量差不多，也分局部作用域和全部作用域

package main

import "fmt"

var c,python,java bool

func main()  {
   var i int
   fmt.Print(i,c,java,python)
}

结果为：0 false false false

2、变量的初始化

变量声明可以包含初始值，每个变量对应一个。如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型

package main

import "fmt"

var i,j int  = 2,4

func main()  {
   var success,isah = true,false
   fmt.Println(i,j,success,isah)
}

结果为：2 4 true false

3、短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明!!!

函数外的每个语句都必须以关键字开始（var func等等），因此 := 结构不能在函数外使用。

package main

import "fmt"

var i,j int  = 2,4

func main()  {
   success,isah := true,false
   fmt.Println(i,j,success,isah)
}

结果为：2 4 true false

4、go数据类型

    4.1 整型

go语言有13种整形，其中有2种只是名字不同，实质是一样的，所以，实质上go语言有11种整型

整型

    4.2 浮点类型　　　　　

go语言有2种类型的浮点和两种类型的复数类型。

浮点类型

标准库math包中，包含了众多数学函数，其中所有函数均使用float64，标准库math/cmplx包含众多复数相关的数学函数,其中所有函数均使用complex128）

    4.3、字符串

Go语言的字符串是用UTF-8编码的变宽字符序列，每个字符都用一个或多个字节表示

创建：一种是用双引号（"）括起来，它表示可解析的字符串，可以进行字符转义。另一种是用单引号（'）括起来，它表示原生的字符串，可以包含除反引号之外的任何字符，当然也可以换行

package main

import "fmt"

func test1() {
   str1 := "\"it's me!\""
   str2 := `"it's me,too"`
   fmt.Println(str1)
   fmt.Println(str2)
}

func main()  {
   test1()
}

结果为：

"it's me!"
"it's me,too"

Go语言的字符串支持 “+=”操作，可以通过[n]获取索引处的原始字节、通过[n:m]、[n:]、[:m]来获取字节对应的字符串，若字符被截段，显示乱码。

package main

import "fmt"

func test1() {
   str1 := "\"it's me!\""
   str2 := `"it's me,too"`
   fmt.Println(str1)
   fmt.Println(str2)
}
func test2() {
   str1 := "Go语言是目前最有潜力的语言，由GooGle开发，用于区块链的主流语言"
   fmt.Println(str1[4:15])
   fmt.Println(str1[5:15])
   fmt.Println(str1[5])
   fmt.Println(str1[:5])
   fmt.Println(len(str1))         //字节数
   fmt.Println(len([]rune(str1))) //字符数
}

func main()  {
   test2()
}

结果为：

5、bool类型

取值范围为：true , false，长度为 1 个字节，不可以用数字来表示true 和 false

6、指针

    6.1 简单的指针

package main

import "fmt"

func test1() {
   str1 := "\"it's me!\""
   str2 := `"it's me,too"`
   fmt.Println(str1)
   fmt.Println(str2)
}
func test2() {
   str1 := "Go语言是目前最有潜力的语言，由GooGle开发，用于区块链的主流语言"
   fmt.Println(str1[4:15])
   fmt.Println(str1[5:15])
   fmt.Println(str1[5])
   fmt.Println(str1[:5])
   fmt.Println(len(str1))         //字节数
   fmt.Println(len([]rune(str1))) //字符数
}

func test3() {
   a := "abc"
   b := "xyz"
   pa := &a  //pa为指向a的指针，在java里面就是指向a的内存地址
   pp := &pa //pp为指向pa的指针，在java里面就是指向pa的内存地址
   fmt.Println(a, b, *pa, **pp)
   a += "zz" //a追加“mm”
   fmt.Println(a, b, *pa, **pp)
   *pa += "bb" //pp指向的值，追加"bb"
   fmt.Println(a, b, *pa, **pp)
   fmt.Println("打印a各种情况：", &a, a)
   fmt.Println("打印pa各种情况：", &pa, pa, *pa)
   fmt.Println("打印pp各种情况：", &pp, pp, *pp, **pp)
}


func main()  {
   test3()
}

结果为：

所以说大家可以明白，& 这个就是指向后面参数的内存地址，而并非值，当使用*来表示的时候就是现实内存内容的具体值了！！！

    6.2 创建变量

有两种创建变量的语法，同时获得指向它们的指针：new(Type) 和 &Type{}

在上面添加一个结构体（java中的实体类一样）和一个函数（java中方法一样）

type point struct {
   x int
   y int
}

func test4() {
   a := point{2, 4}
   b := new(point)
   c := &point{}
   d := &point{3, 5}
   fmt.Println(a, b, c, d)
}

运行结果：

{2 4} &{0 0} &{0 0} &{3 5}

 Go语言打印指向结构体的指针时，会打印解引用后的结构体内容，同时会将&作为前缀，表示它是一个指针！

7、默认数据类型

    1、零值并不等于空值，而是当变量被声明为某种类型的初始值
    2、正常情况下的默认值为0
    3、bool默认为false
    4、string默认为空字符串

8、常量修饰

const mdxl  = "ed"

用const 修饰常量，当mdxl时，不能外部调用，当变成大写Mdxl的时候，可以外部调用