第一个go程序
package main import "fmt" func main() { /* 这是我的第一个简单的程序 */ fmt.Println("Hello,
World!") }
* 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包,如:package main。package
main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包。
* 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包(的函数,或其他元素),fmt 包实现了格式化
IO(输入/输出)的函数。
* 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的,一般来说都是在启动后第一个执行的函数(如果有
init() 函数则会先执行该函数)。
* 下一行 /*...*/ 是注释,在程序执行时将被忽略。单行注释是最常见的注释形式,你可以在任何地方使用以 //
开头的单行注释。多行注释也叫块注释,均已以 /* 开头,并以 */ 结尾,多行注释一般用于包的文档描述或注释成块的代码片段。
* 下一行 fmt.Println(...) 可以将字符串输出到控制台,并在最后自动增加换行字符 \n。
*
当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的
public);标识符如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected )。
数据类型

Go语言的基本类型有:

* bool
* string
* int、int8、int16、int32、int64
* uint、uint8、uint16、uint32、uint64、uintptr
* byte // uint8 的别名
* rune // int32 的别名 代表一个 Unicode 码
* float32、float64
* complex64、complex128
变量

Go语言是静态类型语言,因此变量(variable)是有明确类型的,编译器也会检查变量类型的正确性。

1)声明变量的一般形式是使用 var 关键字:var name type

Go和许多编程语言不同,它在声明变量时将变量的类型放名称后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式,例如:int* a, b; 。其中只有
a 是指针而 b 不是。如果你想要这两个变量都是指针,则需要将它们分开书写。而在 Go 中,则可以和轻松地将它们都声明为指针类型:var a, b *int

多变量声明
var ( a int b string c []float32 d func() bool e struct { x int } )
 

2)除 var 关键字外,还可使用更加简短的变量定义和初始化语法。

名字 := 表达式

需要注意的是,简短模式(short variable declaration)有以下限制:

* 定义变量,同时显式初始化。
* 不能提供数据类型。
* 只能用在函数内部。

和 var 形式声明语句一样,简短变量声明语句也可以用来声明和初始化一组变量:

i, j := 0, 1

3)根据值自行判定变量类型。
package main import "fmt" func main() { var d = true fmt.Println(d) }
算术运算符
package main import "fmt" func main() { var a int = 21 var b int = 10 var c
int c = a + b fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a - b fmt.Printf("第二行 - c
的值为 %d\n", c ) c = a * b fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a / b
fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a % b fmt.Printf("第五行 - c 的值为 %d\n", c )
a++ fmt.Printf("第六行 - a 的值为 %d\n", a ) a=21 // 为了方便测试,a 这里重新赋值为 21 a--
fmt.Printf("第七行 - a 的值为 %d\n", a ) } 第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为
210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - a 的值为 22 第七行 - a 的值为 20
位运算符

位运算符对整数在内存中的二进制位进行操作。

下表列出了位运算符 &, |, 和 ^ 的计算:

 

p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1
 

假定 A = 60; B = 13; 其二进制数转换为:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101
A^B = 0011 0001
 

运算符 描述 实例
& 参与运算的两数各对应的二进位相与。 (A & B) 结果为 12, 二进制为 0000 1100
| 参与运算的两数各对应的二进位相或 (A | B) 结果为 61, 二进制为 0011 1101
^ 参与运算的两数各对应的二进位相异或,当两对应的位相异时,结果为1。 (A ^ B) 结果为 49, 二进制为 0011 0001
<< 左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 A <<
2 结果为 240 ,二进制为 1111 0000
 赋值运算符

下表列出了所有Go语言的赋值运算符。

运算符 描述 实例
= 简单的赋值运算符,将一个表达式的值赋给一个左值 C = A + B 将 A + B 表达式结果赋值给 C
+= 相加后再赋值 C += A 等于 C = C + A
-= 相减后再赋值 C -= A 等于 C = C - A
*= 相乘后再赋值 C *= A 等于 C = C * A
/= 相除后再赋值 C /= A 等于 C = C / A
%= 求余后再赋值 C %= A 等于 C = C % A
<<= 左移后赋值 C <<= 2 等于 C = C << 2
>>= 右移后赋值 C >>= 2 等于 C = C >> 2
&= 按位与后赋值 C &= 2 等于 C = C & 2
^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
|= 按位或后赋值 C |= 2 等于 C = C | 2
 

其他运算符

 

运算符 描述 实例
& 返回变量存储地址 &a; 将给出变量的实际地址。
* 指针变量。 *a; 是一个指针变量
以下实例演示了其他运算符的用法:

实例
package main import "fmt" func main() { var a int = 4 var b int32 var c
float32 var ptr *int /* 运算符实例 */ fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); fmt.Printf("第 3 行 - c 变量类型为 = %T\n",
c ); /* & 和 * 运算符实例 */ ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为
%d\n", a); fmt.Printf("*ptr 为 %d\n", *ptr); }
以上实例运行结果:
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为
4 *ptr 为 4
运算符优先级

由上至下代表优先级由高到低:

优先级 运算符
5 * / % << >> & &^
4 + - | ^
3 == != < <= > >=
2 &&
1 ||
循环

普通for循环
package main import "fmt" func main() { sum := 0 for i := 0; i <= 10; i++ {
sum += i } fmt.Println(sum) }
 foreach

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。
package main import "fmt" func main() { strings := []string{"google",
"runoob"} for i, s := range strings { fmt.Println(i, s) } numbers := [6]int{1,
2, 3, 5} for i,x:= range numbers { fmt.Printf("第 %d 位 x 的值 = %d\n", i,x) } }
 

函数
func function_name( [parameter list] ) [return_types] { 函数体 }
* func:函数由 func 开始声明
* function_name:函数名称,函数名和参数列表一起构成了函数签名。
* parameter
list:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。
* return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下
return_types 不是必须的。
* 函数体:函数定义的代码集合。 /* 函数返回两个数的最大值 */ func max(num1, num2 int) int { /* 声明局部变量
*/ var result int if (num1 > num2) { result = num1 } else { result = num2 }
return result }
返回多个值
package main import "fmt" func swap(x, y string) (string, string) { return y,
x } func main() { a, b := swap("Google", "Runoob") fmt.Println(a, b) }
引用传参
package main import "fmt" func main() { /* 定义局部变量 */ var a int = 100 var b
int= 200 fmt.Printf("交换前,a 的值 : %d\n", a ) fmt.Printf("交换前,b 的值 : %d\n", b ) /*
调用 swap() 函数 * &a 指向 a 指针,a 变量的地址 * &b 指向 b 指针,b 变量的地址 */ swap(&a, &b)
fmt.Printf("交换后,a 的值 : %d\n", a ) fmt.Printf("交换后,b 的值 : %d\n", b ) } func
swap(x *int, y *int) { var temp int temp = *x /* 保存 x 地址上的值 */ *x = *y /* 将 y
值赋给 x */ *y = temp /* 将 temp 值赋给 y */ }
数组

声明:

语法格式如下:
var variable_name [SIZE] variable_type
以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32:
var balance [10] float32
初始化:
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小,Go 语言会根据元素的个数来设置数组的大小:
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
该实例与上面的实例是一样的,虽然没有设置数组的大小。
balance[4] = 50.0
初始化二维数组:
a = [3][4]int{ {0, 1, 2, 3} , /* 第一行索引为 0 */ {4, 5, 6, 7} , /* 第二行索引为 1 */ {8,
9, 10, 11}, /* 第三行索引为 2 */ }
注意:以上代码中倒数第二行的 } 必须要有逗号,因为最后一行的 } 不能单独一行,也可以写成这样:
a = [3][4]int{ {0, 1, 2, 3} , /* 第一行索引为 0 */ {4, 5, 6, 7} , /* 第二行索引为 1 */ {8,
9, 10, 11}} /* 第三行索引为 2 */
指针

和c一样
package main import "fmt" func main() { var a int= 20 /* 声明实际变量 */ var ip *int
/* 声明指针变量 */ ip = &a /* 指针变量的存储地址 */ fmt.Printf("a 变量的地址是: %x\n", &a ) /*
指针变量的存储地址 */ fmt.Printf("ip 变量储存的指针地址: %x\n", ip ) /* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip ) } a 变量的地址是: 20818a220 ip 变量储存的指针地址:
20818a220 *ip 变量的值: 20
空指针判断:
if(ptr != nil) /* ptr 不是空指针 */ if(ptr == nil) /* ptr 是空指针 */
多重指针: 
package main import "fmt" func main() { var a int var ptr *int var pptr **int
a = 3000 /* 指针 ptr 地址 */ ptr = &a /* 指向指针 ptr 地址 */ pptr = &ptr /* 获取 pptr 的值
*/ fmt.Printf("变量 a = %d\n", a ) fmt.Printf("指针变量 *ptr = %d\n", *ptr )
fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr) } 变量 a = 3000 指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000
 

 

技术
©2019-2020 Toolsou All rights reserved,
uboot设置nfs参数——linux kernel使用nfs方式加载根文件系统rootfs(六)冲突声明(conflicting declaration)解决【Python】读取txt文件,获取指定行中指定位置数据vue-countTo 操作大全(精华)2020年7月13日 微信小程序 页面间通信(精华)2020年6月29日 C#类库 接口签名校验keras数据生成器--数据增强Map 判断key对应的value值是否存在-containsKey()【JAVA】【华为校园招聘笔试-软件】2020-09-09Java Thread之Sleep()使用方法总结