首页 > 代码库 > 初始go语言

初始go语言

一.创建第一个go语言程序:打印hello world!

package mainimport "fmt"func main() {    fmt.Println("Hello World")}

运行go语言:

go run main.go 

小结:

切换到main.go所在的目录, go run main.go运行main.go程序, 输出"Hello World". go run命令后面是要编译并运行的文件, 多个文件用空格分开, go run将go程序文件编译成可执行的程序, 并放在一个临时目录下面. 如果程序有错误, go的编译器会提示哪里出错.

import关键字使包含在其他package的代码用在当前程序中, 如main.go的import "fmt", fmt包实现了格式化输入和输出, import在包括包时, 报名需要用""括起来.

在go中注释一行代码使用//, 被注释的代码go编译器忽略, 注释只是提高代码的可读性, 如果需要注释多行代码, go提供了另一种方式: /* ... */, 在/*和*/之间的代码都被go编译器忽略不计.

二:变量的声明与初始化:

go语言中的变量引入var关键字,类型信息放到变量之后

eg1:声明并初始化一个变量

package mainimport "fmt"func main() {    var m int = 10    fmt.Println(m)}

输出结果10

eg2.1:声明初始化多个变量:

package mainimport "fmt"func main() {    var a,b,c = 1,3,8    fmt.Println(a,b,c)}

输出结果:1 3 8

eg2.2匿名变量

package mainimport "fmt"func main() {    var a,_,c = 1,3,8    fmt.Println(a,c)}

输出结果为1 8

  解释:这种情况主要用在函数有多个返回值的时候,去除我们需要的一个或者多个值的时候使用,如果没有用_的话,直接fmt.Println(a,c),会报错

eg3:var关键字的另一种用法是可以将若干个需要声明的变量放置在一起,免得程序员需要重复写var关键字,如下:

package mainimport "fmt"var (    v1 int    v2 string)func main() {    v1 = 10    v2 = "subao"    fmt.Println(v1,v2)}

输出信息:10 subao

eg4:对于声明变量时需要进行初始化的场景,var关键字可以保留,但不再是必要的元素,如下:

package mainimport "fmt"func main() {    var v1 int = 88    var v2 = 88    v3 := 88    fmt.Println(v1,v2,v3)}

输出结果 88 88 88

以上三种用法的效果是完全一致的。

     注意:出现在:=左侧的变量不应该是已经被声明过的,否则会导致错误。

 常量:go语言中,常量是指编译期间就已知且不可改变的值。常量可以是数值的类型(包括整型、浮点型、布尔型、字符串型等)

 

二.values :值类型

go语言内置以下这些基础类型

布尔型:bool

整型:int8,byte,int16,int,int16,uint,uintptr等

浮点类型:float32、float64

复数类型:complex64、complex128

字符串型:string

字符类型:rune

错误类型:error

此外,go语言支持的复数类型:

指针(pointer)

数组(array)

切片(slice)

字典(map)

通道(chan)

结构体(struct)

接口(interface)

布尔型:

package mainimport "fmt"//布尔型func main() {     var v1 bool     v1 = true     fmt.Println(v1)}布尔型不能接受其他类型的赋值,不支持自动或者强制的类型转换,一下写法是错误的
func main() { var b bool b = 1 fmt.Println(b)}

 输出:true

  下面错的会报错:

 ./hello.go:14: cannot use 1 (type int) as type bool in assignment

整型:整型是所有语言中最基础的数据类型,go支持下图所示的整型类型

技术分享

i:类型的表示:

首先说一点是:int和int32在go语言里被认为是两种不同的类型,编译器也不会帮你自动做类型转换,举一个错误例子

package mainimport "fmt"func main() {     var value2 int32     value1 := 64     value2 = value1     fmt.Println(value2)}

会出现:

./hello.go:24: cannot use value1 (type int) as type int32 in assignment

如果以后真的遇到这样的错误,需要强制转换类型,正确的方式是:

package mainimport "fmt"//整型func main() {     var value2 int32     value1 := 64     value2 = int32(value1)(强制转换)     fmt.Println(value2)}

正确输出:64

ii:数值的运算:举一个例子加法:

package mainimport "fmt"//数值运算func main() {     var v1,v2,v3 int     v1 = 64     v2 = 32     v3 = v1 + v2     fmt.Println(v3)}

输出结果:96

iii:比较运算,与大多数其他语言相同,几种比较常见的运算符:>、<、==、>=、<=、!=

package mainimport "fmt"//比较运算func main() {     var v1,v2 int     v1 = 64     v2 = 32     if v1 >= v2 {	fmt.Println("v1 大于 v2")     }}

 输出:v1 大于 v2

注意:两个不同类型的整型数不能直接比较,比如int8类型的数和int类型的数不能直接比较,但是各种类型的整型变量都可以直接与字面常量(literal)进行比较

技术分享

 

iv:位运算

技术分享

浮点型:

i.浮点数的表示:

package mainimport "fmt"func main() {     var f1 float32     f1 = 12     f2 :=12.0     if f1 == f2 {        fmt.Println("相等")     }}

报错:./hello.go:9: invalid operation: f1 == f2 (mismatched types float32 and float64)

原因:以上例子中类型自动推到的f2,需要注意的是其类型被自动设置成float64,而不管给他的数字是否用32为长度表示的。因此我们必须要强制类型转换,进行比较:

package mainimport "fmt"func main() {     var f1 float32     f1 = 12     f2 :=12.0     if f1 == float32(f2) {        fmt.Println("相等")     }}

 输出:相等

ii:浮点数比较

因为浮点数不是一种精确的表达方式,所以想整型那样直接用==来判断是不可行的,(上面的例子是特殊情况),会导致不稳定的结果。

技术分享

复数类型:

i.复数的表示:

package mainimport "fmt"func main() {var value1 complex64value1 = 3.2 + 12ivalue2 := 3.2 + 12ivalue3 := complex(3.2,12)value4 := real(value3)value5 := imag(value3)fmt.Println(value1,value2,value3,value4,value5)}

输出:(3.2+12i) (3.2+12i) (3.2+12i) 3.2 12

ii.实部与虚部

对于一个复数value3 :=complex(3.2,12),可以通过go语言内置函数real(z)获得该复数的实数,也就是3.2,通过imag(z)获得该复数的虚数。

字符串:

i:字符串操作:

package mainimport "fmt"func main() {    var str string    str = "hello world"    ch := str[0]    fmt.Printf("The length of \"%s\" is %d \n", str, len(str))    fmt.Printf("The first character of \"%s\" is %c.\n", str,ch)}

输出信息:

The length of "hello world" is 11
The first character of "hello world" is h.

字符串遍历:

a.遍历字符串(字节)

package mainimport "fmt"func main() {    var str2 = "hello"    str3 := "世界"    // 字符串合并    str4 := str2 + " " + str3    // 遍历字符串(字节)    for i:=0;i<len(str4);i++ {        fmt.Printf("%d : %d\n", i, str4[i])    }}

输出结果:

0 : 104
1 : 101
2 : 108
3 : 108
4 : 111
5 : 32
6 : 228
7 : 184
8 : 150
9 : 231
10 : 149
11 : 140

可以看出一个汉字三个字节,并且字符串的拼接也有了。

b.遍历字符串的字符:

package mainimport "fmt" func main() {    var str2 = "hello"    str3 := "世界"     // 字符串合并    str4 := str2 + " " + str3     // 遍历字符串(字符)    for k,v := range(str4) {        fmt.Printf("%d : %x : %c\n", k, v, v)   }}

 输出:

0 : 68 : h
1 : 65 : e
2 : 6c : l
3 : 6c : l
4 : 6f : o
5 : 20 :
6 : 4e16 : 世
9 : 754c : 界

数组:数组是go语言编程中常见的数据结构之一,顾名思义,数组就是指一系列数据的集合。数组中包含的每个数据被称为数组元素(element),一个数组包含的元素个数被称为数组的长度

数组必知:在go语言中,数组长度在定义后就不可更改,在声明时长度可以为一个常量或者是一个常量表达式(常量表达式是指在编译期即可计算结果的表达式)。数组的长度是该数组类型的一个内置常量,可以用go语言的内置函数len()来获取。方法:

arrLength :=len(arr)

i: 数组的创建方式:

package mainimport "fmt" func main() {     var a [10]int     var b = [10]int{0,1,2,3,4,5,6,7,8,9}     var c = [...]int{0,1,2,3,4,5,6,7,8,9}     var d = [2][2]int{[2]int{1,1},[2]int{2,2}}     var e = [2][2]int{{1,1},{2,2}}     arrLength :=len(a)     fmt.Println(a,b,c,d,e,arrLength)}

输出信息:[0 0 0 0 0 0 0 0 0 0] [0 1 2 3 4 5 6 7 8 9] [0 1 2 3 4 5 6 7 8 9] [[1 1] [2 2]] [[1 1] [2 2]] 10

解释:a没有赋值,默认是0;b与c实现的功能是相同的,取除10以内的整数;d,e则是二维数组,表示的是两行两列的二维整型数组,总共存放了四个元素;arrLength是获取的函数的长度

ii:元素的访问:

可以用数组下标来访问数组中的元素,数组下标从0开始,len(array)-1,则表示最后一个元素的下标。下面是遍历整型数组并逐个打印元素内容:

package mainimport "fmt"func main() {     var c = [...]int{0,1,2,3,4,5,6,7,9}     for i := 0; i < len(c); i++ {         fmt.Println("Element", i, "of c is", c[i])     }}/*func main() {     var c = [...]int{0,1,2,3,4,5,6,7,9}     for i,v := range c {         fmt.Println("c element[", i , "]=", v)     }}*/

以上两个函数都可以遍历整型数组的,输出内容是:

c element[ 0 ]= 0   Element 0 of c is 0
c element[ 1 ]= 1   Element 1 of c is 1
c element[ 2 ]= 2   Element 2 of c is 2
c element[ 3 ]= 3   Element 3 of c is 3
c element[ 4 ]= 4   Element 4 of c is 4
c element[ 5 ]= 5   Element 5 of c is 5
c element[ 6 ]= 6   Element 6 of c is 6
c element[ 7 ]= 7   Element 7 of c is 7
c element[ 8 ]= 9   Element 8 of c is 9

并且上面的例子可看出,c具有两个返回值,第一个返回值是数组下标,第二个返回值是元素的值。

iii值类型:

未完待续。。。

 

初始go语言