go 基礎（二）
strings和strconv使用
一、strings使用segmentfault
- strings.HasPrefix(s string, prefix string) bool：判斷字符串s是否以prefix開頭。
- strings.HasSuffix(s string, suffix string) bool：判斷字符串s是否以suffix結尾。
上面兩個函數代碼樣例：bash
package main
import(
"fmt"
"strings"
)
func urlProcess(url string) string{
result := strings.HasPrefix(url, "http://")
if !result{
url = fmt.Sprintf("http://%s", url)
}
return url
}
func pathProcess(path string) string{
result := strings.HasSuffix(path, "/")
if !result{
path = fmt.Sprintf("%s/", path)
}
return path
}
func main () {
var(
url string
path string
)
fmt.Scanf("%s%s", &url, &path)
url = urlProcess(url)
path = pathProcess(path)
fmt.Println(url)
fmt.Println(path)
}
- strings.Index(s string, str string) int：判斷str在s中首次出現的位置，若是沒有出現，則返回-1
- strings.LastIndex(s string, str string) int：判斷str在s中最後出現的位置，若是沒有出現，則返回-1
- strings.Replace(str string, old string, new string, n int)：字符串替換，若是n<0會替換全部
- strings.Count(str string, substr string)int：字符串計數
- strings.Repeat(str string, count int)string：重複count次str
- strings.ToLower(str string)string：轉爲小寫
- strings.ToUpper(str string)string：轉爲大寫
- strings.TrimSpace(str string)：去掉字符串首尾空白字符
- strings.Trim(str string, cut string)：去掉字符串首尾cut字符
- strings.TrimLeft(str string, cut string)：去掉字符串首cut字符
- strings.TrimRight(str string, cut string)：去掉字符串首cut字符
- strings.Fields(str string)：返回str空格分隔的全部子串的slice
- strings.Split(str string, split string)：返回str split分隔的全部子串的slice
- strings.Join(s1 []string, sep string)：用sep把s1中的全部元素連接起來
package main
import (
"strings"
"fmt"
)
func main(){
str := "hello world "
str1 := " hello world abc \n"
result := strings.Replace(str, "world", "you", 1)
fmt.Println("Replace:", result)
count := strings.Count(str, "l")
fmt.Println("Count:", count)
result = strings.Repeat(str, 3)
fmt.Println("Repeat:", result)
result = strings.ToLower(str)
fmt.Println("ToLower:", result)
result = strings.ToUpper(str)
fmt.Println("ToUpper:", result)
result = strings.TrimSpace(str1)
fmt.Println("TrimSpace:", result)
result = strings.Trim(str1, "\n\r")
fmt.Println("Trim:", result)
result = strings.TrimLeft(str1, " ")
fmt.Println("TrimLeft:", result)
result = strings.TrimRight(str1, "\n\r")
fmt.Println("TrimRight:", result)
splitResult := strings.Fields(str)
for i := 0; i < len(splitResult); i ++ {
fmt.Println("Fields:", splitResult[i])
}
splitResult = strings.Split(str, "l")
for i := 0; i < len(splitResult); i ++ {
fmt.Println("Split:", splitResult[i])
}
joinResult := strings.Join(splitResult, "l")
fmt.Println("Join:", joinResult)
}
二、strconv使用less
- strconv.Itoa(i int)：把一個整數i轉成字符串
- strconv.Atoi(str string)(int, error)：把一個字符串轉成整數
package main
import (
"fmt"
"strconv"
)
func main(){
str2 := strconv.Itoa(1000)
fmt.Println("Itoa:", str2)
number, err := strconv.Atoi(str2)
if err != nil {
fmt.Println("can not convert to int", err)
}
fmt.Println("Atoi:", number)
}
時間和日期類型
一、time包函數
二、time.Time類型，用來表示時間url
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
三、獲取當前時間， now := time.Now()spa
-
time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()指針
func testTime() {
for {
now := time.Now()
fmt.Printf("type of now is:%T\n", now)
year := now.Year()
month := now.Month()
day := now.Day()
str := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d\n", year, month, day, now.Hour(), now.Minute(), now.Second())
fmt.Println(str)
time.Sleep(time.Second)
fmt.Printf("timestamp:%d\n", now.Unix())
}
}
四、time.Duration用來表示納秒orm
package main
import (
"time"
"fmt"
)
func test(){
time.Sleep(time.Millisecond * 100)
}
func main() {
now := time.Now()
fmt.Println(now)
fmt.Println(now.Format("2006/01/02 15:04:05")) // 獲取當前時間
start := time.Now().UnixNano()
test()
end := time.Now().UnixNano()
fmt.Printf("cost:%d", (end - start)/1000) // 統計一段代碼的執行耗時，單位精確到微秒。
}
五、格式化，強制寫下面時間，這個是go誕生時間blog
now := time.Now() fmt.Println(now.Format(「02/1/2006 15:04:05」)) fmt.Println(now.Format(「02/1/2006 03:04:05」)) fmt.Println(now.Format(「2006/1/02 15:04:05」)) fmt.Println(now.Format(「2006/1/02」))
指針類型
一、普通類型，變量存的就是值，也叫值類型。指針類型存的是地址內存
二、獲取變量的地址，用&，好比： var a int, 獲取a的地址：&a
三、指針類型，變量存的是一個地址，這個地址存的纔是值
四、獲取指針類型所指向的值，使用 *，好比：var *p int, 使用*p獲取p指向的值
五、聲明一個指針類型，默認初始化nil
var p *int
直接賦值*p = 200會報錯，它是一個空指針，這個時候能夠理解爲它只是放入一個地址，它初始值是nil。
nil在Go中至關與其它語言中的NULL、null和None等，在實際的使用中表示某一個變量爲空。nil只能賦值給指針、channel、func、interface、map或slice類型的變量。若是將nil賦值給其餘變量的時候將會引起panic。
兩種方式使用：
方式一：
var p *int var b int p = &b *p = 200
這種方式是將b的內存地址賦值給p，實際上p和b共用一個內存地址的值。由於b聲明時默認它的值是0
方式二：
p = new(int) *p = 1000
使用new關鍵字分配內存，這種方式*p的默認值是0。
- demo
func test() {
var p *int //p 默認初始化nil
var b int
p = &b
*p = 200 //b = 200
if (p == &b) {
fmt.Printf("equal\n")
}
fmt.Printf("%p %p %p\n", p, &b, &p)
p = new(int)
fmt.Println(*p)
*p = 1000
fmt.Printf("%d\n", *p)
fmt.Printf("%p %p %p\n", p, &b, &p)
if (p == &b) {
fmt.Printf("equal")
}
//指針類型的變量初始化：1. 使用其餘變量地址給它賦值。 2. 使用new分配
}
流程控制
一、if / else 分支判斷
寫法一：
if condition1 {
}
寫法二：
if condition1 {
} else {
}
寫法三：
if condition1 {
} else if condition2 {
} else if condition3 {
} else {
}
package main
import (
"strconv"
"fmt"
)
func main() {
var str string
fmt.Scanf("%s", &str)
number, err := strconv.Atoi(str)
if err != nil {
fmt.Println("can not convert to int", err)
return
}
fmt.Println("Atoi:", number)
}
二、switch case語句（不須要break）
語法：
switch var {
case var1:
case var2:
case var3:
default:
}
關鍵字fallthrough，可讓知足條件分支執行後，繼續執行下一個分支。
package main
import "fmt"
func main() {
var a int = 10
switch a {
case 0, 1, 2:
fmt.Println("a is equal 0,1,2")
case 10:
fmt.Println("a is equal 10")
fallthrough
default:
fmt.Println("a is equal default")
}
}
樣例：
package main
import (
"math/rand"
"fmt"
)
func main() {
/*
隨機生成一個0到100的整數n，而後用戶在終端，輸入數字，若是和n相等，則提示用戶猜對了。若是不相等，則提示用戶，大於或小於n
*/
var n int
n = rand.Intn(100)
for {
var input int
fmt.Scanf("%d\n", &input)
flag := false
switch {
case input == n:
fmt.Println("you are right")
flag = true
case input > n:
fmt.Println("bigger")
case input < n:
fmt.Println("less")
}
if flag{
break
}
}
}
三、for 語句
寫法一：
for 初始化語句; 條件判斷; 變量修改 {
}
package main
import "fmt"
func Print(n int){
for i := 0; i < n; i ++ {
for j :=0; j < i; j ++ {
fmt.Printf("A")
}
fmt.Println()
}
}
func main() {
Print(6)
}
寫法二：
for 條件 {
}
寫法三：
for range 語句
func Range(){
str := "hello world,中國"
for i, v := range str {
fmt.Printf("index[%d] val[%c]\n", i, v)
}
}
寫法四：break continue語句
func break_continue(){
str := "hello world,中國"
for i, v := range str {
if i > 2 {
continue
}
if i > 3 {
break
}
fmt.Printf("index[%d] val[%c]\n", i, v)
}
}
寫法五： label 語句
package main
import "fmt"
func main() {
LABEL1:
for i := 0; i <= 5; i++ {
for j := 0; j <= 5; j++ {
if j == 4 {
continue LABEL1
}
fmt.Printf("i is: %d, and j is: %d\n", i, j)
}
}
}
四、goto和label 語句
package main
func main() {
i := 0
HERE:
print(i)
i++
if i == 5 {
return
}
goto HERE
}
go使用中遇到的問題總結
相關文章
- 1. Go基礎及語法（二）
- 2. Go入門（三）-Go基礎（二）
- 3. GO基礎
- 4. Go 基礎 02
- 5. go基礎
- 6. Go基礎RPC
- 7. GO 基礎
- 8. Go基礎
- 9. go二次學習基礎（1）
- 10. go語言基礎語法（二）
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（二）基本類型
- • RxJava操作符（二）Transforming Observables
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Go基礎及語法（二）
- 2. Go入門（三）-Go基礎（二）
- 3. GO基礎
- 4. Go 基礎 02
- 5. go基礎
- 6. Go基礎RPC
- 7. GO 基礎
- 8. Go基礎
- 9. go二次學習基礎（1）
- 10. go語言基礎語法（二）