函数声明格式
package main
import("fmt"
// _ "pck1"
)
func method1(){
fmt.Println("method1")
}
func method2(a int) int {
return a
}
func method3(a int,b int ) int {
return a + b
}
func method4(a int,b int )(int,int){
return a+1,b+1
}
func main(){
method1()
fmt.Print(method2(2),"\n")
fmt.Print(method3(2,2),"\n")
fmt.Print(method4(3,4))
}
输出如下：
method1 2 4 4 5
常量
常量使用const 修饰，代表永远是只读的，不能修改
const 只能修饰boolean，number（int相关类型、浮点类型、complex）和string
package main
import("fmt"
// _ "pck1"
)
/** 常量的第一种写法 */
const b string = "abc"
const c = "cde"
const d = true
/** 常量还可以按如下的写法 */
const(
e = 0
f = 1
)
func main(){
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
fmt.Println(f)
}
输出如下：
abc
cde
true
0
1
变量
package main
import("fmt"
// _ "pck1"
)
var a int
var b string = "aa"
var c bool
var(
d int
e string = "ccc"
)
func main(){
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
}
输出如下：
0
aa
false
0
ccc
值类型、引用类型
值类型：变量直接存储值，内存通常在栈中分配
值类型：基本数据类型int、float、bool、string以及数组和struct。
引用类型：变量存储的是一个地址，这个地址存储最终的值。内存通常在
堆上分配。通过GC回收
引用类型：指针、slice、map、chan等都是引用类型
& 是取地址符号,即取得某个变量的地址,如 ; &a
*是指针运算符,可以表示一个变量是指针类型,也可以表示一个指针变量所指向的存储单元,也就是这个地址所存储
看测试代码：
package main
import("fmt"
// _ "pck1"
)
func modify(a int){
a = 2
}
func modify1(a *int){
*a = 2
}
func main() {
a := 1
modify(a)
fmt.Print(a)
modify1(&a)
fmt.Print(a)
}
输出如下：
12
在modify(a int)方法中参数为值类型，使用普通变量作为函数参数的时候，在传递参数时只是对变量值得拷贝，即将实参的值复制给变参，当函数对变参进行处理时，并不会影响原来实参的值。
在modify1(a *int)中参数为指针类型的，接受的是地址值，继而修改了地址值
函数的变量不仅可以使用普通变量，还可以使用指针变量，使用指针变量作为函数的参数时，在进行参数传递时将是一个地址看呗，即将实参的内存地址复制给变参，这时对变参的修改也将会影响到实参的值。
交换2个变量的值（副本）
package main
import("fmt"
// _ "pck1"
)
func swap(a *int,b *int){
temp := *a
*a = *b
*b = temp
}
func swap1(a *int,b *int){
temp := a
a = b
b = temp
}
func swap2(a int,b int)(int,int){
return b,a
}
func main() {
a:=2
b:=3
swap(&a,&b)
fmt.Print(a,b,"\n")
//不会修改
swap1(&a,"\n")
a,b = swap2(a,b)
fmt.Print(a,b = b,a
fmt.Print(a,"\n")
}
输出如下：
3 2 3 2 2 3 3 2
数据类型和操作符
package main
import("fmt"
// _ "pck1"
)
//数字类型
var a bool
var b bool = true
var c int8 = 100
var d int16 = 200
var e uint8 = 99
var f byte = 'a'
func main() {
fmt.Print(a,"\n")
//逻辑操作符
fmt.Print(!a,a&&b,a||b,"\n")
//类型转换
var f int32 = int32(6)
fmt.Print(f,"\n")
//以下是错误的，因为不同的数据类型
// fmt.Print(d+e)
fmt.Println("%c\n",f)
}
输出如下：
false
true false true
6
%c
6
字符串
package main
import("fmt"
// _ "pck1"
)
func main() {
var str1 ="hello"
str2:="world"
//设定输出格式
str3:=fmt.Sprintf("%s%s",str1,str2)
fmt.Println(str3)
//格式化输出
n:= len(str3)
fmt.Printf("len(str3)=%d\n",n)
//截取索引从0到5
subStr:=str3[0:6]
fmt.Println(subStr)
//从索引4开始
subStr = str3[4:]
fmt.Println(subStr,"\n----")
fmt.Println(str3,"\n-====---")
result := reverse(str3)
fmt.Println(result)
result = reverse1(result)
fmt.Println(result)
}
func reverse(str string) string {
var result string
strLen := len(str)
for i := 0; i < strLen; i++ {
result = result + fmt.Sprintf("%c",str[strLen-i-1])
}
return result
}
func reverse1(str string) string {
var result []byte
tmp := []byte(str)
length := len(str)
for i := 0; i < length; i++ {
result = append(result,tmp[length-i-1])
}
return string(result)
}
输出如下：
helloworld
len(str3)=10
hellow
oworld ----
helloworld -====---
dlrowolleh
helloworld
格式化输出
package main
import("fmt"
// _ "pck1"
)
func main(){
var a bool
var b int
var c byte = 'a'
fmt.Printf("%v\n",a)
fmt.Printf("%v\n",b)
fmt.Printf("%v\n",c)
//布尔
fmt.Printf("%t\n",a)
//二进制
fmt.Printf("%b\n",100)
fmt.Printf("%c\n",c)
fmt.Printf("%d\n",100)
fmt.Printf("%d\n",c)
//浮点数
fmt.Printf("%f\n",100.3)
//为字符串加双引号
fmt.Printf("%q\n","aaaaa")
fmt.Pr``
ntf("%s","aaaaa")
}
输出如下：
false
0
97
false
1100100
a
100
97
100.300000
"aaaaa"
aaaaa
读取键盘输入
判断一个数字是不是素数
package main
import("fmt"
)
func main(){
var a int
fmt.Scanf("%d",&a)
fmt.Println(isPrime(a))
}
func isPrime(a int) bool{
var result bool
//从1到a-1开始循环
for i:=2;i<a-1;i++ {
if a%i == 0{
result = false
return result
}
}
result = true
return result
}
测试数字
PS E:\golang\go_pro\src\safly> go run demo.go
9
false
PS E:\golang\go_pro\src\safly> go run demo.go
7
true
PS E:\golang\go_pro\src\safly>