函数声明格式常量变量值类型、引用类型交换2个变量的值(副本)数据类型和操作符字符串格式化输出读取键盘输入
函数声明格式
package main
import(
"fmt"
)
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"
)
/**
常量的第一种写法
*/
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"
)
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"
)
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"
)
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,&b)
fmt.Print(
a,b,
"\n")
a,b = swap2(
a,b)
fmt.Print(
a,b,
"\n")
a,b = b,
a
fmt.Print(
a,b,
"\n")
}
输出如下:
3 2
3 2
2 3
3 2
数据类型和操作符
package main
import(
"fmt"
)
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.Println(
"%c\n",f)
}
输出如下:
false
true false true
6
%c
6
字符串
package main
import(
"fmt"
)
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)
subStr:=str3[
0:
6]
fmt.Println(subStr)
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
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
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>