Go-语言基础-变量-类型-函数

第一个程序

//单行注释
/*
多行注释
 */
package main // 表示当前go文件属于main包
import "fmt" // 导入包
//编译型语言需要有一个入口文件，main包下的main函数
func main(){  //定义了一个main函数包
    fmt.Println("Hello,world!") // 打印hello world
    //a..编辑器自动填充提供的参数名a,表示可以传多个参数
}
// 编译型语言：先编译成编译文件，在执行go.exe文件

运行Go文件:

变量

变量是什么

　　变量指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于声明变量。

声明单个变量

var name type 是声明单个变量的语法。

定义变量var

第一种：

package main //表示是main包的
import  "fmt"
func main(){
    // 定义变量
    //方式一：全名称 go语言中，定义了变量必须使用，否者报错
    // 固定的格式：var关键字 变量名 变量的类型 = 值
    var age int=20 // 完整的变量名声明的方式
    fmt.Println(age)
}

必须指定数据类型，不然报错

第二种：

　　简略的声明方式

package main //表示是main包的
import  "fmt"
func main(){
    // 定义变量
    //方式一：全名称 go语言中，定义了变量必须使用，否者报错
    // 固定的格式：var关键字 变量名 变量的类型 = 值
    //var age int=20 // 完整的变量名声明的方式
    //fmt.Println(age)
    //
    //
    ////类型推导
    //var age=10
    //fmt.Println(age)

    //简略的说明
    age :=20
    fmt.Println(age)
}

第三种：

Go 能够通过一条语句声明多个变量。

声明多个变量的语法是 var name1, name2 type = initialvalue1, initialvalue2。

package main

import "fmt"

func main() {
    var width, height int = 100, 50 // 声明多个变量

    fmt.Println("width is", width, "height is", heigh)
}

你可能已经想到，如果 width 和 height 省略了初始化，它们的初始值将赋值为 0。

package main

import "fmt"

func main() {
    var width, height int
    fmt.Println("width is", width, "height is", height)
    width = 100
    height = 50
    fmt.Println("new width is", width, "new height is ", height)
}

上面的程序将会打印：

width is 0 height is 0
new width is 100 new height is  50

在有些情况下，我们可能会想要在一个语句中声明不同类型的变量。其语法如下：

var (
    name1 = initialvalue1,
    name2 = initialvalue2
)

使用上述语法，下面的程序声明不同类型的变量。

package main

import "fmt"

func main() {
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.Println("my name is", name, ", age is", age, "and height is", height)
}

这里我们声明了 string 类型的 name、int 类型的 age 和 height（我们将会在下一教程中讨论 golang 所支持的变量类型）。运行上面的程序会产生输出 my name is naveen , age is 29 and height is 0。

其他注意事项：

    //变量不能重复定义
    //var a int=10
    //var a =10
    ////a:=10
    //fmt.Println(a)

    //强类型语言,类型是固定的
    //var a =10
    //a=100
    //b:="lqz"
    //a=b
    //fmt.Println(a)
    //fmt.Println(b)

    //定义不赋初值  :int 类型默认值是0  string 类型默认值是空字符串
    //var a int
    //a=10
    //var b string

    //b="lqz"
    //fmt.Println(b)

    //同时定义多个变量
    //var a =10
    //var b=100
    //var a,b int
    //var a,b int=10,20
    //var a,b=10,20
    //var a,b=10,"lqz"
    //a,b:=10,20
    //a,b:=10,"lqz"
    //fmt.Println(a)
    //fmt.Println(b)

　　// 多种类型
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.Println(name)
    fmt.Println(age)
    fmt.Println(height)

}

变量的类型

类型

下面是 Go 支持的基本类型：

• bool
• 数字类型
  • int8, int16, int32, int64, int
  • uint8, uint16, uint32, uint64, uint
  • float32, float64
  • complex64, complex128
  • byte
  • rune
• string

bool

bool 类型表示一个布尔值，值为 true 或者 false。

package main

import "fmt"

func main() {
    a := true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
    d := a || b
    fmt.Println("d:", d)
}

在上面的程序中，a 赋值为 true，b 赋值为 false。

c 赋值为 a && b。仅当 a 和 b 都为 true 时，操作符 && 才返回 true。因此，在这里 c 为 false。

当 a 或者 b 为 true 时，操作符 || 返回 true。在这里，由于 a 为 true，因此 d 也为 true。我们将得到程序的输出如下。

a: true b: false
c: false
d: true

有符号整型

int8：表示 8 位有符号整型
大小：8 位
范围：-128～127

int16：表示 16 位有符号整型
大小：16 位
范围：-32768～32767

int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647

int64：表示 64 位有符号整型
大小：64 位
范围：-9223372036854775808～9223372036854775807

int：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 -2147483648～2147483647，而在 64 位系统是 -9223372036854775808～9223372036854775807。

无符号整型

uint8：表示 8 位无符号整型
大小：8 位
范围：0～255

uint16：表示 16 位无符号整型
大小：16 位
范围：0～65535

uint32：表示 32 位无符号整型
大小：32 位
范围：0～4294967295

uint64：表示 64 位无符号整型
大小：64 位
范围：0～18446744073709551615

uint：根据不同的底层平台，表示 32 或 64 位无符号整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 0～4294967295，而在 64 位系统是 0～18446744073709551615。

浮点型

float32：32 位浮点数
float64：64 位浮点数

下面一个简单程序演示了整型和浮点型的运用。

package main

import (
    "fmt"
)

func main() {
    a, b := 5.67, 8.97
    fmt.Printf("type of a %T b %T\n", a, b)
    sum := a + b
    diff := a - b
    fmt.Println("sum", sum, "diff", diff)

    no1, no2 := 56, 89
    fmt.Println("sum", no1+no2, "diff", no1-no2)
}

a 和 b 的类型根据赋值推断得出。在这里，a 和 b 的类型为 float64（float64 是浮点数的默认类型）。我们把 a 和 b 的和赋值给变量 sum，把 b 和 a 的差赋值给 diff，接下来打印 sum 和 diff。no1 和 no2 也进行了相同的计算。上述程序将会输出：

type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33

简单的总结：

    //数字类型
    /*
    int类型：表示整数,int8   int16  int32  int64
    计算机最小计量单位：bit位  int8 是 8个比特位=1个字节，表示的范围是：正负2的7次方减1
    在32位机器上int 就是int32 ，在64位机器上int就是int64
    uint类型：表示正整数 uint8 uint16...
    float类型：表示小数只有float32和float64
    complex64类型：复数
    byte: uint8的别名
    rune:int32的别名
     */

 

复数类型

complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。

内建函数 complex用于创建一个包含实部和虚部的复数。complex 函数的定义如下：

 

func complex(r, i FloatType) ComplexType

其他数字类型

byte 是 uint8 的别名。
rune 是 int32 的别名。

在学习字符串的时候，我们会详细讨论 byte 和 rune。

string 类型

　　在 Golang 中，字符串是字节的集合。如果你现在还不理解这个定义，也没有关系。我们可以暂且认为一个字符串就是由很多字符组成的。我们后面会在一个教程中深入学习字符串。 下面编写一个使用字符串的程序。

package main

import (
    "fmt"
)

func main() {
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

上面程序中，first 赋值为字符串 "Naveen"，last 赋值为字符串 "Ramanathan"。+ 操作符可以用于拼接字符串。我们拼接了 first、空格和 last，并将其赋值给 name。上述程序将打印输出 My name is Naveen Ramanathan。

还有许多应用于字符串上面的操作，我们将会在一个单独的教程里看见它们。

类型转换

Go 有着非常严格的强类型特征。Go 没有自动类型提升或类型转换。我们通过一个例子说明这意味着什么。

package main

import (
    "fmt"
)

func main() {
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //不允许 int + float64
    fmt.Println(sum)
}

上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。i 的类型是 int ，而 j 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到 main.go:10: invalid operation: i + j (mismatched types int and float64)。

要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)。

package main

import (
    "fmt"
)

func main() {
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int
    fmt.Println(sum)
}

现在，当你运行上面的程序时，会看见输出 122。

赋值的情况也是如此。把一个变量赋值给另一个不同类型的变量，需要显式的类型转换。下面程序说明了这一点。

package main

import (
    "fmt"
)

func main() {
    i := 10
    var j float64 = float64(i) // 若没有显式转换，该语句会报错
    fmt.Println("j", j)
}

在第 9 行，i 转换为 float64 类型，接下来赋值给 j。如果不进行类型转换，当你试图把 i 赋值给 j 时，编译器会抛出错误。

常量

定义

在 Go 语言中，术语"常量"用于表示固定的值。比如 5 、-89、 I love Go、67.89 等等。

package main

func main() {
    const a = 55 // 允许
    a = 89       // 不允许重新赋值
}

常量的值会在编译的时候确定。因为函数调用发生在运行时，所以不能将函数的返回值赋值给常量。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println("Hello, playground")
    var a = math.Sqrt(4)   // 允许
    const b = math.Sqrt(4) // 不允许
}

字符串常量

　　双引号中的任何值都是 Go 中的字符串常量。例如像 Hello World 或 Sam 等字符串在 Go 中都是常量。

什么类型的字符串属于常量？答案是他们是无类型的。

像 Hello World 这样的字符串常量没有任何类型。

const hello = "Hello World"

意味着定义一个常量的关键参数时“const”

//常量：恒定不变的量
package main

import "fmt"

func main() { 
　　　//const trueConst = true 布尔型常量
    //var a int=10 

    //定义了一个常量a
    //const a int=10
    const a =10
    //a=100
    fmt.Println(a)
    const b ="192.168.1.1"

}

函数

　　函数：（function）

函数是什么？

函数是一块执行特定任务的代码。一个函数是在输入源基础上，通过执行一系列的算法，生成预期的输出。

函数的声明

在 Go 语言中，函数声明通用语法如下：

func functionname(parametername type) returntype {
    // 函数体（具体实现的功能）
}

函数的声明以关键词 func 开始，后面紧跟自定义的函数名 functionname (函数名)。函数的参数列表定义在 ( 和 ) 之间，返回值的类型则定义在之后的 returntype (返回值类型)处。声明一个参数的语法采用 参数名 参数类型 的方式，任意多个参数采用类似，

(parameter1 type, parameter2 type) 即(参数1 参数1的类型,参数2 参数2的类型)的形式指定。之后包含在 { 和 } 之间的代码，就是函数体。

函数中的参数列表和返回值并非是必须的，所以下面这个函数的声明也是有效的

func functionname() {
    // 译注: 表示这个函数不需要输入参数，且没有返回值
}

示例函数

//函数
package main

//func main() {
    //test()
    //test(1,2)
    //var a int=test(1,2)
    //var a =test(1,2)
    //var a string
    //a =test(1,2)
    //fmt.Println(a)
    //var a int
    //var b string
    //a,b:=test(1,2)
    fmt.Println("a","b")
}

多返回值

//函数定义，语法
//func关键字 函数名(参数1 类型，参数2 类型) (返回值类型){}
//无参数，无返回值
//func test()  {
//    fmt.Println("xxx")
//
//}
//有两个int类型的参数
//func test(a int,b int)  {
//func test(a ,b int)  {
//func test(a ,b int,c string)  {
//    fmt.Println(a+b)
//}

//有一个数字类型返回值,一定要指定返回值类型
//func test(a,b int) int {
//    return a+b
//}
//func test(a,b int) string {
//    return "lqz"
//}

//返回多个值
//func test(a,b int) (int,string)  {
//    return a+b,"成功"
//}

命名返回值

　　从函数中可以返回一个命名值。一旦命名了返回值，可以认为这些值在函数第一行就被声明为变量了。

return 可以不写返回值，因为已经被定义过了。

//命名返回值
//func test(a,b int) (c int, d string)  {
//    c=10
//    d="成功"
//    return
//}

空白符

　　**_** 在 Go 中被用作空白符，可以用作表示任何类型的任何值。

    //不要第二个返回值
    //a,_:=test(1,2)
    //fmt.Println(a)
    //fmt.Printf(_)

理解：不给2赋值，打印输出2。

例子：

不定长参数，闭包函数

package main
func main()

//在go中没有位置参数和关键字参数，都是位置参数,也没有默认参数
//func test(a,b int) int {
//    return a+b
//}

//不定长参数
//func test(a ...interface{})  {
//    fmt.Println(a)
//
//}

//闭包函数
//定义在函数内部，对外部作用域有引用
//go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民

//func test(a int) (int,int) {
//    fmt.Println("xxx")
//    return 1,2
//
//}
//
//func main() {
//    var a func(a int)(int,int)
//    //var a =test
//    a=test
//    a(1)
//}

不定长源码：

简单的例子：

package main

import "fmt"

func main() {
    //test(1,"Rose")
    index(1,2,2,65,784,646,12,21222)
}
//func test(a...interface{}){
//    fmt.Println(a)
//}
func index(a...int)  {
    fmt.Println(a)
}

>>>：[1 2 2 65 784 646 12 21222]

闭包函数

package main

import "fmt"

//闭包函数
//定义在函数内部，对外部作用域有引用
//go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民
func test(a int) (int,int) {
    fmt.Println("xxx")
    return 1,2
}
func main() {
    var a func(a int)(int,int)
    //var a =test
    a=test
    a(1)
}