本篇前瞻

好的，現(xiàn)在你已經(jīng)來到一個(gè)新的小結(jié)，在這里你將學(xué)習(xí)到go語言的重要內(nèi)容，習(xí)得go 25個(gè)關(guān)鍵字中的12個(gè):var, const, if, else, switch, case, default, fallthrough, for, break, goto, continue，即在順序結(jié)構(gòu)學(xué)習(xí)var,const,在分支結(jié)構(gòu)中學(xué)習(xí)if, else, switch, case, default, fallthrough，在循環(huán)結(jié)構(gòu)中學(xué)習(xí)for, break, goto, continue。另外你最好注冊一個(gè)Leetcode賬號.

Leetcode習(xí)題9

讓我們再來看下這個(gè)例子，這個(gè)是一個(gè)比較好的例子，里面包含了順序，分支以及循環(huán)的所有控制結(jié)構(gòu)

題目描述

9. 回文數(shù)

給你一個(gè)整數(shù) x ，如果 x 是一個(gè)回文整數(shù)，返回 true ；否則，返回 false 。

回文數(shù)是指正序（從左向右）和倒序（從右向左）讀都是一樣的整數(shù)。

代碼編寫

func isPalindrome(x int) bool {
	if (x < 0) { //分支結(jié)構(gòu)
		return false
	}
	x64 := x   //順序結(jié)構(gòu)
	px64 := 0
	for x64 != 0 {  //循環(huán)結(jié)構(gòu)
		px64 = px64*10 + x64%10 // 順序結(jié)構(gòu)
		x64 /= 10
	}
	return px64 == x 
}

你在這個(gè)道題目中能看到所有的控制結(jié)構(gòu)：順序結(jié)構(gòu)，分支結(jié)構(gòu)，循環(huán)機(jī)構(gòu)

控制結(jié)構(gòu)

順序結(jié)構(gòu)（Sequence）

聲明和賦值

在順序結(jié)構(gòu)中聲明和賦值是很重要的

var可以聲明一個(gè)變量，而const則聲明一個(gè)常量

package main

import "fmt"

func main() {
	var i1 int     //聲明變量,默認(rèn)值為0
	var i2 int = 1 //聲明變量,初始化為1
	i3 := 2        //這是最常用的聲明和初始化手段
	fmt.Println(i1, i2, i3)
	i4 := i2 + i3 //使用運(yùn)算表達(dá)式賦值
	i3 *= i4      //使用運(yùn)算表達(dá)式賦值
	fmt.Println(i3, i4)
	const ci1 int = 13 //聲明常量，無法
	fmt.Println(ci1)
	x, y, z := 100, 101, 102 //多返回值
	fmt.Println(x, y, z)     //打印結(jié)果
}

輸出：

0 1 2
6 3
13
100 101 102

這里僅僅舉例了整形int的聲明

多返回值賦值

x,y,z := 0,1,2

go語言允許這樣多返回值賦值賦值方式，再挖個(gè)坑，原因會在介紹函數(shù)時(shí)說明一下。

運(yùn)算符

算術(shù)運(yùn)算符

注意： 例如如3/2 在整型中是整除即3/2=1，在浮點(diǎn)型是3.0/2.0=1.5，模運(yùn)算智能用于整數(shù)

位運(yùn)算符

位運(yùn)算符幾乎我們這篇實(shí)用的編程用不到，但是這個(gè)概念也很重要，計(jì)算機(jī)底層事實(shí)上是這樣工作的，這里在挖個(gè)坑，后面會介紹位運(yùn)算的相關(guān)leetcode題目，你會看到它的威力。

邏輯運(yùn)算

這些會在分支語句中大放異彩。

分支結(jié)構(gòu)

if 語句

if 語句有if,if-else以及if-else if-else結(jié)構(gòu)，如下所示：

package main

import "fmt"

func main() {
	var input int
	fmt.Printf("請輸入分?jǐn)?shù)：")
	fmt.Scanf("%d", &input)
	if input < 60 { //if
		fmt.Println("1.不合格")
	}

	if input < 60 { //if-else
		fmt.Println("2.不合格")
	} else{
		fmt.Println("2.合格")
	}

	if input < 60 {//if-else if-else
		fmt.Println("3.不合格")
	} else if input < 70 {
		fmt.Println("3.合格")
	} else if input < 85 {
		fmt.Println("3.良好")
	} else  {
		fmt.Println("3.優(yōu)秀")
	}
}

結(jié)果如下：

請輸入分?jǐn)?shù)：59
1.不合格
2.不合格
3.不合格

switch 語句

事實(shí)上switch 語句比if語句更為強(qiáng)大，在有多個(gè)分支時(shí)更為符合go語言的風(fēng)格，完整代碼如下：

package main

import "fmt"

func main() {
	var i int
	fmt.Printf("請輸入分?jǐn)?shù)：")
	fmt.Scanf("%d\n", &i)
	switch {
	case i < 60: //單個(gè)邏輯表達(dá)式
		fmt.Println("不合格")
	case i < 70:
		fmt.Println("合格")
	case i < 85:
		fmt.Println("良好")
	default:
		fmt.Println("優(yōu)秀")
	}

	var c byte
	fmt.Printf("請輸入等級：")
	fmt.Scanf("%c\n", &c)

	switch c {
	case 'E', 'e': //可以有多個(gè)選擇
		fmt.Println("1.不合格")
	case 'D', 'd':
		fmt.Println("1.基本合格")
	case 'C', 'c':
		fmt.Println("1.合格")
	case 'B', 'b':
		fmt.Println("1.良好")
	case 'A', 'a':
		fmt.Println("1.優(yōu)秀")
	default:
		fmt.Println("1.錯(cuò)誤的輸入")
	}

	switch {
	case c == 'E', c == 'e': //可以有多個(gè)表達(dá)式
		fmt.Println("2.不合格")
	case c == 'D', c == 'd':
		fmt.Println("2.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("2.合格")
	case c == 'B', c == 'b':
		fmt.Println("2.良好")
	case c == 'A', c == 'a':
		fmt.Println("2.優(yōu)秀")
	default:
		fmt.Println("2.錯(cuò)誤的輸入")
	}

	switch {
	case c == 'E':
		fmt.Println("3.不合格")
		fallthrough //fallthrough會執(zhí)行下一個(gè)case區(qū)塊
	case c == 'e':
		fmt.Println("3.真的不合格")
	case c == 'D', c == 'd':
		fmt.Println("3.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("3.合格")
	case c == 'B', c == 'b':
		fmt.Println("3.良好")
	case c == 'A', c == 'a':
		fmt.Println("3.優(yōu)秀")
	default:
		fmt.Println("3.錯(cuò)誤的輸入")
	}

	var in interface{} = i
	switch data := in.(type) { //類型推斷
	case int:
		fmt.Printf("int: %v\n", data)
	case uint:
		fmt.Printf("uint: %v\n", data)
	default:
		fmt.Printf("type: %T\n", data)
	}
}

結(jié)果如下：

請輸入分?jǐn)?shù)：90
優(yōu)秀
請輸入等級：E
1.不合格
2.不合格
3.不合格
3.真的不合格
int: 90

邏輯表達(dá)式

注意case可以是單個(gè)或多個(gè)邏輯表達(dá)式

	switch {
	case c == 'E', c == 'e': //可以有多個(gè)表達(dá)式
		fmt.Println("2.不合格")。
	case c == 'D', c == 'd':
		fmt.Println("2.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("2.合格")
	case c == 'B', c == 'b':
		fmt.Println("2.良好")
	case c == 'A', c == 'a':
		fmt.Println("2.優(yōu)秀")
	default:
		fmt.Println("2.錯(cuò)誤的輸入")
	}

fallthrough

fallthrough會執(zhí)行下一個(gè)case區(qū)塊

	switch {
	case c == 'E':
		fmt.Println("3.不合格")
		fallthrough //fallthrough會執(zhí)行下一個(gè)case區(qū)塊
	case c == 'e':
		fmt.Println("3.真的不合格")
	case c == 'D', c == 'd':
		fmt.Println("3.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("3.合格")
	case c == 'B', c == 'b':
		fmt.Println("3.良好")
	case c == 'A', c == 'a':
		fmt.Println("3.優(yōu)秀")
	default:
		fmt.Println("3.錯(cuò)誤的輸入")
	}

類型推斷

這個(gè)是一個(gè)強(qiáng)大的方式，它可以用于推斷go語言的接口的類型，不過現(xiàn)在只能簡單那介紹一下，你可以將interface{}可以表達(dá)任何類型

	var in interface{} = i
	switch data := in.(type) { //類型推斷
	case int:
		fmt.Printf("int: %v\n", data)
	case uint:
		fmt.Printf("uint: %v\n", data)
	default:
		fmt.Printf("type: %T\n", data)
	}

循環(huán)語句

循環(huán)語句只有for

package main

import "fmt"

func main() {
	var input int
	fmt.Printf("請輸入分?jǐn)?shù)(0-5)：")
	fmt.Scanf("%d", &input)

	for i := 0; i < 5; i++ { //正常的for
		fmt.Println("loop1:", i)

		if i < 2 {
			continue //跳過本次執(zhí)行
		}
		if i == input {
			fmt.Println("loop1: break") //跳出本層循環(huán)
			break
		}
	}
	i := 0
Loop:
	for i < 5 { //去掉;的for循環(huán)
		fmt.Println("loop2:", i)
		for j := 0; j < 5; j++ {
			if j == input {
				fmt.Println("loop2: break Loop") //跳出Loop標(biāo)記的循環(huán)
				break Loop
			}
			if j == 1 {
				break //跳出本層循環(huán)
			}
		}
		i++
	}
	i = 0
	for ; i < 5; i++ { //空缺一個(gè)元素并帶有；的for循環(huán)
		fmt.Println("loop3:", i)
		for j := 0; j < 5; j++ {
			if j < 2 {
				continue
			}
			if j == input {
				goto Exit //跳出到Exit
			}
		}
	}
	return
Exit:
	fmt.Println("loop3: Exit")
}

結(jié)果如下：

請輸入分?jǐn)?shù)(0-5)：1
loop1: 0
loop1: 1
loop1: 2
loop1: 3
loop1: 4
loop2: 0
loop2: break Loop
loop3: 0
loop3: 1
loop3: 2
loop3: 3
loop3: 4

請輸入分?jǐn)?shù)(0-5)：2
loop1: 0
loop1: 1
loop1: 2
loop1: break
loop2: 0
loop2: 1
loop2: 2
loop2: 3
loop2: 4
loop3: 0
loop3: Exit

continue

跳過本次循環(huán)

break

沒有加標(biāo)簽的就是跳過本層循環(huán)

加標(biāo)簽的就是跳過被標(biāo)簽標(biāo)記的循環(huán)

goto

跳到被標(biāo)簽標(biāo)記的循環(huán)，使用goto在處理一些同意的錯(cuò)誤或者統(tǒng)一的出口而降低代碼的冗余，增加代碼可讀性。這里挖個(gè)坑，這里會在go-etl展示goto的魅力

注意：很多書籍指出goto會破環(huán)代碼結(jié)構(gòu)，降低代碼可讀性，那是因?yàn)檫@些書籍講述使用goto的場景錯(cuò)了。

Leetcode習(xí)題69

我們以leetcode習(xí)題開始，而現(xiàn)在有以一道Leetcode習(xí)題結(jié)束

題目描述

69. x 的平方根

給你一個(gè)非負(fù)整數(shù) x ，計(jì)算并返回 x 的 算術(shù)平方根 。

由于返回類型是整數(shù)，結(jié)果只保留 整數(shù)部分 ，小數(shù)部分將被 舍去 。

注意：不允許使用任何內(nèi)置指數(shù)函數(shù)和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

題目分析

這道題會比Leetcode習(xí)題1更加困難些，這次數(shù)據(jù)范圍是int32的非負(fù)整數(shù)范圍，由于不能使用指數(shù)函數(shù)和算符，為此，在這里我們需要使用二分法，即通過二分[a,b](mid = a + (b-a)/2, 第一輪a=0,b=x)去獲取mid=x/2，如果mid*mid<x 那么此時(shí)二分[a，mid-1]，反之二分[mid+1，b], 這樣不斷二分下去直到 mid*mid=x或者a<b。好的，這樣我們獲得了解題思路，但是還有個(gè)問題，選擇y的數(shù)據(jù)類型是什么，如果選擇int32，那么相乘必然超過int32, 為此我們必須選擇int64，注意：在Leetcode習(xí)題9中得出了結(jié)論，int是64位的，所以不用改為int64。

代碼編寫

func mySqrt(x int) int {
	a, b := 0, x //多返回值賦值
	for a <= b { // 無；結(jié)構(gòu)的for
		mid := a + (b-a)/2   //二分區(qū)間
		if mid*mid == x { //if語句
			return mid
		}
		if mid*mid < x { //if-else語句
			a = mid + 1   //選擇較大的區(qū)間
		} else {
			b = mid - 1  //選擇較小的區(qū)間
		}
	}
	return b
}

本篇小結(jié)

恭喜你已經(jīng)完成了所有控制結(jié)構(gòu)的學(xué)習(xí)，你以及知道了所有控制結(jié)構(gòu)用到的保留字和注意點(diǎn)。另外，通過Leetcode習(xí)題69和Leetcode習(xí)題9，你已經(jīng)知道在編程時(shí)選擇數(shù)據(jù)類型的重要性，并且練習(xí)了所有控制結(jié)構(gòu)。這里的相關(guān)代碼放在go語言學(xué)習(xí)的go-base/3中，請下載后進(jìn)行實(shí)際的練習(xí)

注意：之后的Leetcode題目解答以及使用工具的編程中，數(shù)據(jù)類型的選擇以及控制結(jié)構(gòu)的應(yīng)用是非常重要的，也是最為基礎(chǔ)的。

下篇預(yù)告

go語言復(fù)合類型文章來源地址http://www.zghlxwxcb.cn/news/detail-659392.html

到了這里，關(guān)于3.你所不知道的go語言控制語句——Leetcode習(xí)題69的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！