golang基础-day02

前端之家收集整理的这篇文章主要介绍了golang基础-day02前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

函数声明格式

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
@H_301_491@格式化输出
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>

猜你在找的Go相关文章