以下是记录我学习Go时练习的小程序段，接上篇，已经过编译通过，在此记录，以供翻阅复习
package main
import "fmt"
func main(){
var a int =10
for a<20{
fmt.Println("a的值为:\n",a)
a++
if a>15{
break
}
}
}
//这个if下面只有一条语句也要加个花括号。否则会报错。
/*
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15
*/
//continue语句
//continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。
package main
import "fmt"
func main(){
var a int=10
for a<20{
if a==15{
a++
continue
}
fmt.Println("a的值是：",a)
a++
}
}
/*
以上实例执行结果为：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19
*/
//Go语言goto语句
/*Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。*/
package main
import "fmt"
func main(){
var a int=10
LOOP:for a<20{
if a==15{
a++
goto LOOP
}
fmt.Println("a的值为：\n",a)
a++
}
}
/*
以上实例执行结果为：
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19
*/
//输出1-100素数
package main
import "fmt"
func main(){
var C,c int
C = 1
A:for C<100{
for c=2;c<C;c++{
if C%c==0{
C++
goto A
}
}
fmt.Println(C,"是素数")
C++
}
}
//Go语言实现99乘法表
package main
import "fmt"
func main(){
for i := 1; i <=9; i++ {
for j :=1;j<=i;j++{
fmt.Printf("%d*%d=%d ",j,i,i*j) //Printf不换行 Println换行
}
fmt.Println()
}
}
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
/*
函数是基本的代码块，用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。
*/
package main
import "fmt"
func main(){
var a int = 100
var b int = 200
var ret int
//调用函数并返回最大值
ret = max(a,b)
fmt.Printf("最大值是：%d\n",ret)
}
//函数返回两个数的最大值
func max(num1,num2 int)int{
//定义局部变量
var result int
if(num1 > num2){
result = num1
}else{
result = num2
}
return result
}
//最大值 是：200
//函数返回多个值
package main
import "fmt"
func swap(x,y string)(string,string){
return y,x
}
func main(){
a,b:=swap("Mahesh","Kumar")
fmt.Println(a,b)
}
//Kumar Mahesh
//默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
package main
import "fmt"
func swap(x,y int) int{
var temp int
temp=x
x=y
y=temp
return temp
}
func main(){
//定义局部变量
var a int=100
var b int=200
fmt.Printf("交换前a 的值为：%d\n",a)
fmt.Printf("交换前b 的值为：%d\n",b)
//通过调用函数来交换值
swap(a,b)
fmt.Printf("交换后a的值：%d\n",a)
fmt.Printf("交换后b的值：%d\n",b)
}
//程序中使用的是值传递, 所以两个值并没有实现交互，我们可以使用 引用传递 来实现交换效果。
/*
交换前a 的值为：100
交换前b 的值为：200
交换后a的值：100
交换后b的值：200
*/
//引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
//引用传递指针参数传递到函数内，以下是交换函数 swap() 使用了引用传递
package main
import "fmt"
func swap(x *int,y *int){
var temp int
temp=*x /* 保持 x 地址上的值 */
*x=*y /* 将 y 值赋给 x */
*y=temp /* 将 temp 值赋给 y */
}
func main(){
//定义局部变量
var a int =100
var b int =200
fmt.Printf("交换前，a 的值 : %d\n", a )
fmt.Printf("交换前，b 的值 : %d\n", b )
//&a指向a指针 a变量的地址
//&b指向b指针 b变量的地址
//调用swap()函数
swap(&a,&b)
fmt.Printf("交换后，a 的值 : %d\n", a )
fmt.Printf("交换后，b 的值 : %d\n", b )
}
/*
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
*/
package main
import "fmt"
//在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量
//在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
//全局变量可以在任何函数中使用
func PartT(){
//声明局部变量
var a,b,c int
a=10
b=20
c=a+b
fmt.Printf("结果： a=%d,b=%d,c=%d\n",a,b,c)
}
//声明全局变量
var g int
var a int =20;
func PartS(){
//声明局部变量
var a,b int
//初始化参数
a=20
b=30
g=a+b
fmt.Printf("结果： a=%d,b=%d,g=%d\n",a,b,g)
}
//Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑
func PartN(){
var g int=111
fmt.Printf("结果：g=%d\n",g)
}
func sum(a,b int)int{
fmt.Printf("sum()函数中a=%d\n",a);
fmt.Printf("sum()函数中b=%d\n",b);
return a+b;
}
func PartM(){
var a int=10
var b int=20
var c int=0
fmt.Printf("main()函数中 a=%d\n",a);
c=sum(a,b);
fmt.Printf("main()函数中 c=%d\n",c);
}
func main(){
PartT() //结果： a=10,b=20,c=30
PartS() //结果： a=20,b=30,g=50
PartN() //结果：g=111
PartM()
/*
main()函数中 a=10
sum()函数中a=10
sum()函数中b=20
main()函数中 c=30
*/
}