Go语言学习Day02

今天早上比昨天还早起了一点点，然后学习了go的变量申明以及函数的写法等方面，感觉还是有所收获的，我感觉写法有点怪，可能是跟C++的声明有点不一样。坚持就能成功！

一、变量声明：

声明通用格式为：

var variantname type :variantname指变量名 type：值变量类型

//声明变量
package main

import "fmt"

//默认初始化 int类型为0 bool false
var c,python,java bool

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

二、变量初始化：

当变量有确定的参数时，初始化可以不加类型标识符，系统将自动识别：（这点有点像Python）

//变量初始化
package main

import (
	"fmt"
)

var i,j int = 1,3

func main(){
	//变量初始化后，可以省略类型，系统将自动识别。
	var c,python = false,"ddd"
	fmt.Println(c,python,i,j)
}

声明变量时，如果未赋值，系统将自动赋值为0值。

如果是string类型的话，则赋值为""空值

//声明变量时，未赋值的话将会自动赋值为零值
package main

import "fmt"

func main()  {
	var  i int
	var f float32
	var j bool
	var s string
	fmt.Printf("%v,%v,%v,%v",i,j,s,f)
}

如果有确定赋值的话，变量的声明还可以改为： var dd = "dd" 等价于 dd:= "dd"

package main

import (
	"fmt"
)
//自动识别类型，取决于它的精度
func main(){
	v:="ddd"
	fmt.Printf("This type is %T",v)
}

四、数据的类型转换：

一个重点是必须得是强制类型转换形式，如下：

//类型转换
package main

import (
	"fmt"
	"math"
)
//重点：中括号不能写在下面
func main() {
	var x,y int = 3,4
	var f float64= math.Sqrt(float64(x*x + y*y))
	var z uint = uint(f)
	fmt.Println(x, y, z)
}

// :在类型明确的情况下，作用类似于var
package main

import "fmt"

func main()  {
var i,j int=1,3
k:=3
c,python,java:=true,false,"day"
fmt.Println(i,j,k,c,python,java)
}

当需要导入多个包时，可以使用import("""")这种形式示例代码如下：

//go learn
package main

//import 导入多个包 用括号来包含多个包
import (
	"fmt"
	"math"
	"math/rand"
)

func main()  {
	//rand.Intn总会返回相同的数字，因为运行环境固定
	//Println 和Printf区别：Println可以输出字符串和变量， Printf只能输出字符串
fmt.Println("My Favorite Number is",rand.Intn(10))
fmt.Printf("Now you have %g problems.\n",math.Sqrt(7))
}

Go语言函数的通用格式：

func 函数名（参数名参数类型）（返回的数据类型）{

方法

}

package main

import "fmt"

const (
	Big = 1 << 100
	Small = Big >> 99
)

func needInt(x int)int{
	return x*10 + 1
}
func needFloat(x float64)float64{
	return  x * 0.1
}

func main(){
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
}

可以使用变量作为返回值，如下：

//命名返回值
package main

import "fmt"

func split(sum int)(x,y int){
	x = sum * 4 /9
	y = sum - x
	return
}

func main()  {
	fmt.Println(split(36))
}

/*多值返回*/
package main

import "fmt"

/*多值返回情况，返回值类型用括号包*/
func swap(x,y string)(string,string){
	return y,x
}

func main()  {
	//a,b多参数赋值写法如下：
	a,b:= swap("today","tomorrow")
	fmt.Println(swap("ss","mm"))
	fmt.Println(a,b)
}

package main

import "fmt"

//go 函数： func 函数名(变量 变量类型,变量 变量类型)返回类型{函数体}
func add(x int,y int)int{
	return x + y
}

//go函数，要是函数参数类型一样时，保留最后一个类型参数即可。
func addsave(x ,y int)int{
	return x + y
}

func main(){
	fmt.Println("结果为：",add(42,12))
	fmt.Println("测试数据 56+12=",addsave(56,12))
}

package main

import "fmt"

//常量命名首字母通常大写
const Pi  = 3.14

func main(){
	const World = "世界"
	fmt.Println("Hello,%v",World)
	fmt.Println("Happy",Pi,"Day")
	const Truth  = true
	fmt.Println("Go rules",Truth)
}

重点：：：Go语言的基本数据类型：
bool string int int8,int 16,int32,int64 uint uint8, uint16 uint32 uint64
uintptr byte:uint8 rune:int32
float32 float64
complex64 complex128

变量声明也可以用 var()的形式，更加方便简洁直观

//go语言的基本数据类型
//bool string int int8,int 16,int32,int64 uint uint8, uint16 uint32 uint64
//uintptr byte:uint8  rune:int32
//float32 float64
//complex64 complex128
package main

import (
	"fmt"
	"math/cmplx"
)

//声明多个变量的另一种方式
var(
	ToBe bool = false
	MaxInt uint64 = 1<<64 -1
	z complex128 = cmplx.Sqrt(-5+12i) //复数类型
)

//%T:输出的是它的类型 %v：输出的是实际的值
func main(){
	fmt.Printf("Type: %T Value:%v\n",ToBe,ToBe)
	fmt.Printf("Type: %T Value:%v\n",MaxInt,MaxInt)
	fmt.Printf("Type: %T Value:%v\n",z,z)
}

希望能够学有所成，兴趣最重要！