go语言（二）

执行go程序的几种方式

 

go没有分号，认为每一行就是一句话的结束

 

目录结构

goproject是其gopath

 

第一个go程序

package main
import "fmt"
func main()
{
	fmt.Println("hello world!")
}

package main表示该程序hello.go文件所在的包是main

go程序都必须归属于一个包

 

fmt包实现了格式化IO(输入/输出)的函数

 

go程序开发注意事项

 

1、go程序的执行入口是main()方法

      main函数是每一个go程序必须包含的，一般来说都是在启动后第一个执行的函数

      如果有init()函数则会先执行init()函数

2、go语言严格区分大小写

3、需要这样

main{

}

不能这样

main

{

}

4、go编译器是一行行进行编译的，因此一行就写一条语句，不能把多条语句写在同一个中，否则报错

5、如果go语言中定义的变量或者import的包没有用到，则代码不能编译通过

6、注释

      单行：//

      多行：/**/

7、go不允许在变量名中使用@、$、%等标点符号，第一个字符必须是字母或下划线而不能是数字

8、可见性规则

①Go语言中，使用大小写来决定标识符（常量、变量、类型、接口、结构或函数）是否可以被外部包所调用。
②以一个大写字母开头，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（使用时程序需要先导入这个包），如同面向对象语言中的pubic。
③如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的，像面向对象语言中的private。

9、Go 程序是通过package来组织的。

•  只有package名称为main的包可以包含main函数。
•  一个可执行程序有且仅有一个main包。
•  通过import关键字来导入其他非main包。
•  可以通过import关键字单个导入，也可以同时导入多个

 

go语言是面向对象的语言吗？

       go官网的定义是Yes and No

       明显go是允许OO的编程风格的，但又缺乏一些Java和C++中的常见类型继承结构。Go的interface也和Java中的用法大相径庭，这也是我经常吹捧的隐式继承

 

变量声明和初始化

变量声明

1、未初始化的标准格式

var 变量名 变量类型

2、未初始化的批量格式
不用每行都用var申明

var(
    a int
    b string
    c []float32
    d func() bool
    e struct{
        x int
        y string
    }
)

未初始化变量的默认值：
        整形和浮点型变量默认值：0
        字符串默认值为空字符串
        布尔型默认值为false
         函数、指针变量初始值为nil

 

package main
import "fmt"
func main(){
	var a int
	var b string
	var c float32
	fmt.Printf("%T, %v \n", a, a)
	fmt.Printf("%T, %v \n", b, b)
	fmt.Printf("%T, %v \n", c, c)
	fmt.Println(a,b,c)
}

 

 

3、初始化变量的标准格式
    var 变量名类型=表达式

4、初始化变量的编译器自动推断类型格式
    var变量名=表达式

5、初始化变量的简短声明格式（短变量声明格式）

• 变量名：=表达式
• 使用：=赋值操作符，：=可以高效地创建一个新的变量，称之为初始化声明。
• 声明语句省略了var关键字·变量类型将由编译器自动推断
• 这是声明变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值
• 该变量名必须是没有定义过的变量，若定义过，将发生编译错误
• 在多个短变量声明和赋值中，至少有一个新声明的变量出现在左侧中，那么即便有其它变量名可能是重复声明的，编译器也不会报错。

 

循环和选择语句

for循环

for i:=1; i<10;i++ {

}

没有括号

赋值号

写法2：

相当于while

i:=1
for i<=5{
	fmt.Println("hello world!")
	i++
}

但此时i的作用域也是全局的

写法3：

相当于while True

for{
	fmt.Println("hello world!")
}

 

if语句

if n>10 {

}

 

 

函数

语法格式：

注意go语言的函数是先写函数名，再写函数类型

func getsum(){
	sum := 0
	for i:=1;i<=10;i++{
		sum+=i
	}
	fmt.Println("1-10的和是: %d", sum)
}

func getsum(n int){
	sum := 0
	for i:=1;i<=n;i++{
		sum+=i
	}
	fmt.Println("1-10的和是: %d", sum)
}

func getsum()int{
	sum := 0
	for i:=1;i<=10;i++{
		sum+=i
	}
	return sum
}

//return 多返回值

func rectangle(len,wid float64)(float64,float64){
	perimeter := (len+wid)*2 
	area := len*wid
	return perimeter,area
}

 

数组

var ids= [5]int{1,2,3,4,5}

var names=[3]string{"张三","李四","王五"}

var matrix[5][6] int

var matrix[5][6] int={{1,2,3},{4,5,6}}

 

切片 slice

      Go 语言切片是对数组的抽象。
      Go数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片（“动态数组”），与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大

     []里面有长度的就表示是数组，没有长度的就是切片

var s1 []int

s2 := []int{1,2,3,4}

s3 := make([]int,3,8) //长度3，容量8     但是超过容量还会自动扩容

append()函数，向切片末尾添加元素

s4 := append(s4, 1,2)

遍历切片

for i:=0;i<len(s4);i++{
    fmt.Println(s4[i])
}


for i,v := range s4{
    fmt.Println(i,v)
}