Go初探 (3) – 基础语句

基础语句

条件语句

if

if条件语句与Java基本一致,基础语法为

if 表达式 {
    //你的代码
}

例如

package main
import "fmt"

func main(){
    a := 10
    if a > 0 {
        fmt.Print("123")
    }
}

你也许已经知道了,表达式可以不需要括号。

推测下去,go的if分支条件语句还有如下写法

//if...else...
if 表达式 {
    //你的代码
} else {
    //你的代码
}

//if...else if...
if 表达式 {
    //你的代码
} else if 表达式 {
    //你的代码
}

//嵌套if
if 表达式 {
    if 表达式 {
        //你的代码
    } else {
        //你的代码
    }
}

switch

与Java不同,go语言里switch的case分支自带break属性,默认在满足条件的情况下,不会执行接下来的分支。

switch 表达式 {
    case val1:
        //你的代码
    case val2:
        //你的代码
    default:
        //你的代码
}

当然,与Java不同的是,你还可以这么干

switch {
    case val1 == val2:
        //你的代码
    case val3 == val4:
        //你的代码
    default:
        //你的代码
}

case后可填入条件表达式。当第一处运行为真时,退出分支。

当然了,如果你想在满足条件时,执行接下来剩下的分支,你需要在分支后添加fallthrough

switch {
    case val1 == val2:
        fallthrough
        //你的代码case val3 == val4:
        fallthrough
        //你的代码
    default:
        //你的代码
}

fallthrough在执行剩下的分支时,不会判断剩下分支的表达式是否为真,就如Java中的case分支不加上break。

type-switch

除此之外,switch语句还可以判断某个接口的类型。如果你还没学到接口,这里可以跳过。

package main

import "fmt"

type MyInterface interface{
    call() int32
}

type MyStruct struct {
    name string
}

func (a *MyStruct) call() int32{
    return 1
}

func main() {
    var myInterface MyInterface
    myStruct := new(MyStruct)
    myInterface = myStruct

    switch i := myInterface.(type){
    case *MyStruct:
        fmt.Println("MyStruct", i)
    case nil:
        fmt.Println("nil")
    }
}

select

select语句与switch类似。但与switch不同的是,case中的表达式必须是一个通信。如果case中没有可运行的,程序将堵塞,直到有case可以运行为止。

select {
    case 通信1:
        //你的代码
    case 通信2:
        //你的代码
    //可选
    //default: 
        //你的代码
}

其中:

  • 每个case必须是一个通信
  • 如果有多个case可运行,go将公平地随机选取一个case运行
  • 如果没有case可运行
    • 如果没有defalut分支,程序将堵塞
    • 如果有,将运行default分支
  • 所有被发送的表达式都会被求值
  • 如果任意某个通信可以进行,它就执行,其他被忽略

循环语句

for

for循环有3种形式

for 初始值; 条件; 赋值表达式 {} //Java中的for(初始值; 条件; 赋值表达式){}
for 条件 {} //Java中的while(条件){}
for {} //Java中的while(true){}

也可以用range格式,相当于Java的foreach。for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。

for key, value := oldMap {
    newMap[key] = value
}

例如:

numbers := []int32{100, 200, 300}
for i, value := numbers {
    fmt.Printf("%d: %d\n", i, value)
}

除此之外,与Java类似,循环分支包括以下几种循环控制语句。

break

break可以跳出for循环。相同的,你可以使用标签来跳出指定的分支。

continue

continue可以跳过当前循环,执行下一个循环。

goto

emmm…这个还是别用了吧

函数

函数定义:

func 函数名 (参数) [返回类型] {
   函数体
}

例如:

func add (a int, b int) int {
    return a + b
}

调用:

func main(){
    var b int
    b = add(1, 2)//调用函数
    fmt.Print(b)
}

当然,函数可以有多个返回值

func swap (a, b int) int{
    return b, a
}

func main(){
    a, b := swap(3, 4)
    fmt.Printf("%d %d", a, b)
}

除此之外,你还可以以指针作为参数传递

func print(str *string){
    *str += "123"
}

func main(){
    str := "456"
    print(&str)
    fmt.Println(str)
}
闭包

Go 语言支持匿名函数,可作为闭包。匿名函数是一个“内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量,不必申明。

例如:

func get(i int) func() int{
    i++
    return func() int {
        i += 2
        return i
    }
}

func main(){
    var a int
    a := get(2)
    fmt.Print(a())
}
方法

go语言中,函数也可变为方法。方法的定义如下

func (对象名 对象方法) 方法名(参数) [返回类型]{
    方法体
}

即,这个对象拥有了这个方法。

type Dog struct{

}

func (dog *Dog) bark(){
    fmt.Print("I'm barking!")
}

func main(){
    dog := new(Dog)
    dog.bark();
}

执行后,bark方法被执行。

暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇