第一个Go程序

go语言的基础知识，包括命名，变量声明，初始化，赋值等
等。
欢迎来我的个人博客：fizzyi

//hello.go

package main

import(
    "fmt"
)

func main(){
    fmt.Println("Hello Go")
}

每个Go源码文件的开头都是一个package声明，代表该Go代码所属的包。包是Go语言里最基本的分发单位，也是工程管理中依赖关系的提现。

要执行Go可执行程序，必须建立一个名为main的包，并且该包中包含一个叫main的函数，该函数是Go可执行程序的执行起点。

Go语言的main()函数不能带参数，也不能定义返回值。

在声明之后，是一系列的import语句，用于导入该程序所依赖的包。

所有Go函数以关键字func开头，一个常规的函数定义包含以下部分:

func 函数(参数列表)(返回值列表){
    //函数体
}

命名

go语言的25个关键字:

go_base1.png

变量声明

声明格式: var 变量名 类型

var v1 int
var v2 int

//一次定义多个变量
var v3,v4 int

var (
    v5 int
    v6 int
)

如果只声明变量不进行赋值 则初始值都为0 空 flase

变量初始化

var v1 int = 10  #方法1
var v2 = 10  #方法2  自动推导类型
v3 := 10   #方法3  自动推导

var v4 int 
v4 = 10

变量赋值

var v1 int 
v1 = 123

var v2,v3,v4 int
v2,v3,v4 = 1,2,3  //多重赋值

i := 10
j := 20
i,j = j, i  //多重赋值

匿名变量

_(下划线)是个特殊的变量名，任何赋予它的值都会被丢弃

-,i,_,j :=1,2,3,4

func test()(test,string){
    return 250, "sb"
}

_,str := test()

用法1: 函数返回多个值，如果其中某个值不需要，就用_丢弃

常量

常量可以是数值类型(整型，浮点型，复数类型)，布尔类型，字符串类型

常量定义 const关键字

const pi float64 = 3.14
const zero = 0.0//浮点常量，自动推导类型

const(  //变量名
    size int64 = 1024
    eof = -1 //整型常量，自动推导类型
)

iota枚举

常量声明可以使用iota常量生成器初始化，用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式，在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加1

const(
    x = iota //x == 0
    y = iota //y == 1
    z = iota //z == 2
    w    //这里隐式的说w =iota，因此w == 3,
)

const v = iota //每遇到一个const关键字，iota就会重置，此时v == 0

const (
    h,i,j = iota,iota,iota //h=0,i=0,j=0 iota在同一行值相同
)

基础数据类型

类型	名称	长度	零值
bool	布尔类型	1	false
byte	字节型	1	0
int	整型	4或8	0
float	浮点型	4	0.0
string	字符串	“”

格式化输出，类型转换，类型别名

使用fmt包来格式化字符串

打印格式	含义
%c	字符型
%d	十进制数
%f	浮点数
%s	字符串
%t	以true或者false输出布尔值
%T	输出类型

类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之中。

运算符

其他运算符

运算符	术语	说明
&	取地址运算符	变量的地址
*	取值运算符	变量所存的值

流程控制

选择结构

if语句

var a int = 3
if a==3 {  //条件没有括号
    fmt.Println("a==3")
}

//支持一个初始化表达式，初始化字句和条件表达式直接需要用分号分隔
if b:=3(初始化自居);b==3(条件表达式){
    fmt.Pintln("b==3")
}

if...else

if a:=3;a ==4{
    fmt.Println("a == 4")
}else{
    fmt.Println("a!=4")
}

if...else if...else

if a:=3;a>3{
    fmt.Println("a>3")
}else if a<3{
    fmt.Println("a<3")
}else if a ==3{
    fmt.Println("a==3")
}else{
    fmt.Println("error")
}

switch语句
Go里面的switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case，而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码。

var score int = 90

switch score{
case 90:
    fmt.Println("优秀")
    //fallthrough
case 80:
    fmt.Println("良好")
    //fallthrough
case 50, 60, 70:
    fmt.Println("一般")
    //fallthrough
default:
    fmt.Println("差")
}

同时也可以使用任何类型或者表达式作为条件语句

循环语句

for语句

var i,sum int

for i=1;i<=100;i++{
    sum += i
}
fmt.Println("sum = ",sum)

range

s := "abc"
for i := range s{ //第二个返回值，默认丢弃，返回元素的位置
    fmt.Printf("%c\n",s[i])
}

for _,c := range s{
    fmt.Printf("%c\n",c)
}

跳转语句

break 跳出当前循环
continue 跳出本次循环
goto 跳转到必须在当前函数内定义的标签

第一个Go程序

//hello.go

package main

import(
    "fmt"
)

func main(){
    fmt.Println("Hello Go")
}

每个Go源码文件的开头都是一个package声明，代表该Go代码所属的包。包是Go语言里最基本的分发单位，也是工程管理中依赖关系的提现。

要执行Go可执行程序，必须建立一个名为main的包，并且该包中包含一个叫main的函数，该函数是Go可执行程序的执行起点。

Go语言的main()函数不能带参数，也不能定义返回值。

在声明之后，是一系列的import语句，用于导入该程序所依赖的包。

所有Go函数以关键字func开头，一个常规的函数定义包含以下部分:

func 函数(参数列表)(返回值列表){
    //函数体
}

命名

go语言的25个关键字:

变量声明

声明格式: var 变量名 类型

var v1 int
var v2 int

//一次定义多个变量
var v3,v4 int

var (
    v5 int
    v6 int
)

如果只声明变量不进行赋值 则初始值都为0 空 flase

变量初始化

var v1 int = 10  #方法1
var v2 = 10  #方法2  自动推导类型
v3 := 10   #方法3  自动推导

var v4 int 
v4 = 10

变量赋值

var v1 int 
v1 = 123

var v2,v3,v4 int
v2,v3,v4 = 1,2,3  //多重赋值

i := 10
j := 20
i,j = j, i  //多重赋值

匿名变量

_(下划线)是个特殊的变量名，任何赋予它的值都会被丢弃

-,i,_,j :=1,2,3,4

func test()(test,string){
    return 250, "sb"
}

_,str := test()

用法1: 函数返回多个值，如果其中某个值不需要，就用_丢弃

常量

常量可以是数值类型(整型，浮点型，复数类型)，布尔类型，字符串类型

常量定义 const关键字

const pi float64 = 3.14
const zero = 0.0//浮点常量，自动推导类型

const(  //变量名
    size int64 = 1024
    eof = -1 //整型常量，自动推导类型
)

iota枚举

常量声明可以使用iota常量生成器初始化，用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式，在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加1

const(
    x = iota //x == 0
    y = iota //y == 1
    z = iota //z == 2
    w    //这里隐式的说w =iota，因此w == 3,
)

const v = iota //每遇到一个const关键字，iota就会重置，此时v == 0

const (
    h,i,j = iota,iota,iota //h=0,i=0,j=0 iota在同一行值相同
)

基础数据类型

类型	名称	长度	零值
bool	布尔类型	1	false
byte	字节型	1	0
int	整型	4或8	0
float	浮点型	4	0.0
string	字符串	“”

格式化输出，类型转换，类型别名

使用fmt包来格式化字符串

打印格式	含义
%c	字符型
%d	十进制数
%f	浮点数
%s	字符串
%t	以true或者false输出布尔值
%T	输出类型

类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之中。

运算符

其他运算符

运算符	术语	说明
&	取地址运算符	变量的地址
*	取值运算符	变量所存的值

流程控制

选择结构

if语句

var a int = 3
if a==3 {  //条件没有括号
    fmt.Println("a==3")
}

//支持一个初始化表达式，初始化字句和条件表达式直接需要用分号分隔
if b:=3(初始化自居);b==3(条件表达式){
    fmt.Pintln("b==3")
}

if...else

if a:=3;a ==4{
    fmt.Println("a == 4")
}else{
    fmt.Println("a!=4")
}

if...else if...else

if a:=3;a>3{
    fmt.Println("a>3")
}else if a<3{
    fmt.Println("a<3")
}else if a ==3{
    fmt.Println("a==3")
}else{
    fmt.Println("error")
}

switch语句
Go里面的switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case，而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码。

var score int = 90

switch score{
case 90:
    fmt.Println("优秀")
    //fallthrough
case 80:
    fmt.Println("良好")
    //fallthrough
case 50, 60, 70:
    fmt.Println("一般")
    //fallthrough
default:
    fmt.Println("差")
}

同时也可以使用任何类型或者表达式作为条件语句

循环语句

for语句

var i,sum int

for i=1;i<=100;i++{
    sum += i
}
fmt.Println("sum = ",sum)

range

s := "abc"
for i := range s{ //第二个返回值，默认丢弃，返回元素的位置
    fmt.Printf("%c\n",s[i])
}

for _,c := range s{
    fmt.Printf("%c\n",c)
}

跳转语句

break 跳出当前循环
continue 跳出本次循环
goto 跳转到必须在当前函数内定义的标签