strings和strconv使用
. strings.HasPrefix(s string, prefix string) bool: // 判断字符串s是否以prefix开头 。 . strings.HasSuffix(s string, suffix string) bool: // 判断字符串s是否以suffix结尾。 . 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): // 去掉字符串首尾空白字符;\n 也会去掉
strings.Trim(str string, cut string): // 去掉字符串首尾cut字符
func Trim(s string, cutset string) string
---> 去掉字符串s中首部以及尾部与字符串cutset中每个相匹配的字符,如:
---> s="hello yes",cutset="he",那么s的结果为:"ello yes"
strings.TrimLeft(str string, cut string): // 去掉字符串首cut字符
strings.TrimRight(str string, cut string): // 去掉字符串首cut字符 . strings.Field(str string): // 返回str空格分隔的所有子串的slice
strings.Split(str string, split string): // 返回str split分隔的所有子串的slice . strings.Join(s1 []string, sep string): // 用sep把s1中的所有元素链接起来 . strconv.Itoa(i int): // 把一个整数i转成字符串 <---> fmt.Sprintf("%d",str) . strconv.Atoi(str string)(int, error): // 把一个字符串转成整数
示例代码1:
package main import (
"fmt"
"strings"
) func urlProcess(url string) string {
result := strings.HasPrefix(url,"http://") // strings.HasPrefix(变量,匹配内容) 返回一个 bool 值
if !result{
url = fmt.Sprintf("http://%s",url)
}
return url
} func pathProcess(path string) string {
result := strings.HasSuffix(path,"/") // strings.HasSuffix(变量,匹配内容) 返回一个 bool 值
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) } // 运行结果:
[root@NEO example01_string01]# go run main/main.go
10.0.0.8/login f:/learning
http://10.0.0.8/login
f:/learning/
[root@NEO example01_string01]#
# 示例代码2:
package main import (
"fmt"
"strings"
"strconv"
) func main(){
str := " hello world abc \n" result := strings.Replace(str,"abc","neo",) // 字符串替换
fmt.Println("Replace:",result) count := strings.Count(str,"o") // 字符串计数
fmt.Println("Count:",count) result = strings.Repeat(str,) // 把字符串重复几次、拼接到一起
fmt.Println("Repeat:",result) result = strings.ToLower(str) // 变成小写
fmt.Println("ToLower:",result) result = strings.ToUpper(str) // 变成大写
fmt.Println("ToUpper:",result) result = strings.TrimSpace(str) // 去掉字符串首尾空白字符;\n 也会去掉
fmt.Println("TrimSpace:",result) result = strings.Trim(str," \n\r") // 去掉字符串首尾 cutset 字符
fmt.Println("Trim:",result) result = strings.TrimLeft(str," \n\r") // 去掉左侧
fmt.Println("TrimLeft:",result) result = strings.TrimRight(str," \n\r") // 去掉右侧
fmt.Println("TrimRight:",result) splitResult := strings.Fields(str) // 以空格为分隔符切割字符串,返回数组
for i := ; i<len(splitResult);i++ {
fmt.Printf("fieldsResult[%d]=%s\n",i,splitResult[i])
} splitResult = strings.Split(str,"o") // 以"o"为分隔符切割字符串,返回数组
for i := ; i<len(splitResult);i++ {
fmt.Printf("splitResult[%d]=%s\n",i,splitResult[i])
} str2 := strings.Join(splitResult,"o") // 拼接字符串
fmt.Println("Join:",str2) str2 = strconv.Itoa() // 数字转字符串
fmt.Println("Itoa:",str2) num,err := strconv.Atoi(str2) // 字符串转数字;有两个返回值 if err != nil {
fmt.Println("can not convert to int",err)
return
}
fmt.Println("Atoi:",num) } // 编译后执行结果如下:
[root@NEO project]# go build -o bin/example01_string02 go_dev/day03/example01_string02/main
[root@NEO project]# bin/example01_string02
Replace: hello world neo Count:
Repeat: hello world abc
hello world abc
hello world abc ToLower: hello world abc ToUpper: HELLO WORLD ABC TrimSpace: hello world abc
Trim: hello world abc
TrimLeft: hello world abc TrimRight: hello world abc
fieldsResult[]=hello
fieldsResult[]=world
fieldsResult[]=abc
splitResult[]= hell
splitResult[]= w
splitResult[]=rld abc Join: hello world abc Itoa:
Atoi:
[root@NEO project]#
Go中的时间和日期类型
. time包
. time.Time类型,用来表示时间
. 获取当前时间, now := time.Now()
. time.Now().Day(),time.Now().Minute(),time.Now().Month(),time.Now().Year()
. 格式化,fmt.Printf(“%02d/%02d/%02d %02d:%02d:%02d”, now.Year()…)
. time.Duration用来表示纳秒
. 一些常量:
const (
Nanosecond Duration = * Nanosecond
Microsecond = * Nanosecond
Millisecond = * Microsecond
Second = * Millisecond
Minute = * Second
Hour = * Minute
)
. 格式化:
now := time.Now()
fmt.Println(now.Format(“// ::”))
fmt.Println(now.Format(“// :”))
fmt.Println(now.Format(“//”))
示例3:
写一个程序,获取当前时间,并格式化成 2017/06/15 08:05:00 形式
写一个程序,统计一段代码的执行耗时,单位精确到微秒。
// 示例代码如下:
package main import (
"fmt"
"time"
) func test_runtime(){
time.Sleep(time.Millisecond * ) // 停 100 毫秒
} func main (){
now := time.Now()
// 方式一
fmt.Printf("%02d/%02d/%02d %02d/%02d/%02d\n",now.Year(),now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second()) // 方式二: time 自带一个 Format() 函数
fmt.Println(now.Format("2006-01-02 15:04:05")) start := time.Now().UnixNano() // 获取当前时间戳(纳秒级)
test_runtime()
end := time.Now().UnixNano() fmt.Printf("runtime:%d us\n",(end-start)/)
} // 运行结果如下:
[root@NEO example01_string03]# go run main/main.go
// //
-- ::
runtime: us
[root@NEO example01_string03]#
指针类型
. 普通类型,变量存的就是值,也叫值类型
. 获取变量的地址,用&,比如: var a int, 获取a的地址:&a
. 指针类型,变量存的是一个地址,这个地址存的才是值
. 获取指针类型所指向的值,使用:*,比如:var *p int, 使用*p获取p指向的值
示例4:
写一个程序,获取一个变量的地址,并打印到终端。
写一个函数,传入一个int类型的指针,并在函数中修改所指向的值。在main函数中调用这个函数,并把修改前后的值打印到终端,观察结果
// 示例代码如下:
package main import (
"fmt"
) func pointer_val(p *int){ // 该函数的参数p需要传入一个地址
*p = // 修改 指针p 指向的值
} func main(){
str := "hello world"
fmt.Println("addr=",&str) num :=
var p *int // 声明一个 int 类型的指针;p 里面存的是地址
p = &num // 给指针类型的变量赋值时,需要赋值一个地址(&变量);取出指针 p 所指向的值 ---> *p
fmt.Println("p=",p)
fmt.Println("pointer_val_before=",*p)
pointer_val(p) // p 参数是一个地址
fmt.Println("pointer_val_after=",*p)
} // 运行结果如下:
[root@NEO example03_pointer01]# go run main/main.go
addr= 0xc0000101e0
p= 0xc0000120b0
pointer_val_before=
pointer_val_after=
[root@NEO example03_pointer01]#
流程控制
# if语句:
// 1、
if condition1 {
} // 2、
if condition1 { } else { } // 3、
if condition1 { } else if condition2 { } else if condition3 {
} else {
} # switch case 语句
// 语法:
switch var { // var 就变量
case var1:
case var2:
case var3:
default:
} // 形式1:
var i =
switch i {
case :
fallthrough // fallthrough 具有 穿透 的作用
case :
fmt.Println(“”) // go switch 的 case 后不需要加 break
case ,,,:
fmt.Println(“”)
default:
fmt.Println(“def”)
} // 形式2:
var i =
switch {
case i > && i < :
fmt.Println(“i > and i < ”)
case i > && i < :
fmt.Println(“i > and i < ”)
default:
fmt.Println(“def”)
}
示例4:猜数字,写一个程序,随机生成一个0到100的整数n,然后用户在终端,输入数字,如果和n相等,则提示用户猜对了。如果不相等,则提示用户,大于或小于n。
// 示例代码:
package main import (
"fmt"
"math/rand"
) func main(){
var n int
n = rand.Intn() // 生成随机数 for {
flag := false
var input int
fmt.Scanf("%d\n",&input) // %d\n --> 以 换行作为分隔符 switch {
case input == n:
fmt.Println("you are right")
flag = true
case input > n:
fmt.Println("bigger")
default:
fmt.Println("smaller")
}
if flag {
break
}
} }
for 语句
// 方式一:
for 初始化语句; 条件判断; 变量修改 { } // 方式二:
for 条件 {
} // 方式三:for range 语句 --> 用来遍历数组、slice、map、chan
str := "hello world,中国"
for i, v := range str { // i表示下标, v 表示值
fmt.Printf("index[%d] val[%c] len[%d]\n", i, v, len([]byte(string(v)))) // len([]byte(string(v))) --> 表示字符的长度
} // 方式四:
str := “hello world,中国”
for i, v := range str {
if i > {
continue
}
if (i > ) {
break
}
fmt.Printf(“index[%d] val[%c] len[%d]\n”, i, v, len([]byte(string(v))))
} // 方式五:goto 和 label 语句
// label语句1:
package main
import "fmt"
func main() {
LABEL1: // label语法 ---> 字符:
for i := ; i <= ; i++ {
for j := ; j <= ; j++ {
if j == {
continue LABEL1 // 会跳转到 LABEL1 处继续执行
}
fmt.Printf("i is: %d, and j is: %d\n", i, j)
}
}
} // goto label 语句2:
package main func main() {
i :=
HERE:
print(i)
i++
if i == {
return
}
goto HERE // 会跳转到 HERE 处继续执行 ; 此 goto label 实现了一个 for 循环 (只能在同一个函数中跳转)
}
示例5:写一个程序,在终端打印如下图形
A
AA
AAA
AAAA
AAAAA
// 示例代码如下:
package main import (
"fmt"
) func print(n int) { for i := ; i < n; i++ {
for j := ; j < i; j++ {
fmt.Printf("A")
}
fmt.Println()
}
} func main() {
print()
}
示例6:(上述的方式三)
// 示例代码:
package main import "fmt" func main() {
str := "hello world,中国"
for i, v := range str { // i表示下标, v 表示值
fmt.Printf("index[%d] val[%c] len[%d]\n", i, v, len([]byte(string(v)))) // len([]byte(string(v))) --> 表示字符的度
}
} // 运行结果如下:
[root@NEO example04_for01]# go run main/main.go
index[] val[h] len[]
index[] val[e] len[]
index[] val[l] len[]
index[] val[l] len[]
index[] val[o] len[]
index[] val[ ] len[]
index[] val[w] len[]
index[] val[o] len[]
index[] val[r] len[]
index[] val[l] len[]
index[] val[d] len[]
index[] val[,] len[]
index[] val[中] len[]
index[] val[国] len[]
[root@NEO example04_for01]#
函数
golang函数特点:
// a. 不支持重载,一个包不能有两个名字一样的函数
// b. 函数是一等公民,函数也是一种类型,一个函数可以赋值给变量
// c. 匿名函数
// d. 多返回值
示例7:自定义一种函数类型,作为参数传入另一个函数的参数
package main import "fmt" type calc_func func(int, int) int // type --> 自定义一种类型 calc_func:calc_func 是函数类型,该类型有两个参数均为 int,返回值也是 int func add(a int, b int) int {
return a + b
} func operator(op calc_func,a int, b int) int { // op 参数为自定义的 函数类型;函数当作参数传给另一个函数
return op(a,b)
} func main(){
c := add
fmt.Println(c) // c 是函数 add 的内存地址
sum := operator(c,,)
fmt.Println(sum)
} // 运行结果如下:
[root@NEO example05_func01]# go run main/main.go
0x487170 [root@NEO example05_func01]#
函数参数传递方式:
1). 值传递
2). 引用传递
注意1:无论是值传递,还是引用传递,传递给函数的都是变量的副本,不过,值传递是值的拷贝。引用传递是地址的拷贝,一般来说,地址拷贝更为高效。而值拷贝取决于拷贝的对象大小,对象越大,则性能越低。
注意2:map、slice、chan、指针、interface默认以引用的方式传递
函数命名返回值的名字,如下:
func add(a, b int) (c int) { // c 就是返回值
c = a + b
return
} func calc(a, b int) (sum int, avg int) {
sum = a + b
avg = (a +b)/
return
}
_ 标识符,用来忽略返回值,如下:
func calc(a, b int) (sum int, avg int) {
sum = a + b
avg = (a +b)/
return
}
func main() {
sum, _ := calc(, )
}
函数的可变参数,如下:
func add(arg…int) int { // 0个或多个参数
} func add(a int, arg…int) int { // 1个或多个参数
} func add(a int, b int, arg…int) int { // 2个或多个参数
} // 注意:其中arg是一个slice(切片,可理解成数组/列表),我们可以通过arg[index]依次访问所有参数,通过len(arg)来判断传递参数的个数
示例8:
写一个函数add,支持1个或多个int相加,并返回相加结果
写一个函数concat,支持1个或多个string相拼接,并返回结果
// 示例代码如下:
package main import "fmt" func add(a int,arg...int) (sum int){
sum += a
for i := ; i < len(arg); i++{
sum += arg[i]
}
return
} func concat(s string,arg...string)(result string){
result += s
for i := ; i < len(arg); i++{
result += arg[i]
}
return
} func main(){
sum := add(,)
fmt.Println(sum)
sum = add(,,)
fmt.Println(sum) result := concat("hello"," world")
fmt.Println(result)
result = concat("hello"," world"," neo")
fmt.Println(result)
} // 运行结果如下:
[root@NEO example05_func02]# go run main/main.go hello world
hello world neo
[root@NEO example05_func02]#
函数 defer:
// 1. 当函数返回时,执行defer语句。因此,可以用来做资源清理
// 2. 多个defer语句,按先进后出的方式执行 (栈)
// 3. defer语句中的变量,在defer声明时就决定了。
示例代码:
package main import "fmt" func a(){
i :=
defer fmt.Println("func a defer",i) // 执行这个声明的时候,i 的值已经确实为0,此时语句还没有执行,该语句是在函数返的时候才执行
i++
fmt.Println("func a",i) // 先执行这行代码的 Println,再执行 defer 中的 Println
} func f(){
for i := ; i < ; i++ {
defer fmt.Println("func f defer",i) // 先执行后面的 defer 语句
}
} func main(){
a()
f()
} // 运行结果如下:
[root@NEO example05_defer]# go run main/main.go
func a
func a defer
func f defer
func f defer
func f defer
[root@NEO example05_defer]# // defer用途(伪代码):
// 1. 关闭文件句柄 func read() {
//文件操作
file := open(filename)
defer file.Close()
} // 2. 锁资源释放
func read() {
mc.Lock()
defer mc.Unlock()
} // 3. 数据库连接释放
func read() {
conn := openDatabase()
defer conn.Close()
}
示例题:
1. 编写程序,在终端输出九九乘法表。
// 示例代码:
package main import "fmt" func multi() {
for i := ; i <= ; i++{
for j :=; j<=i; j++ {
fmt.Printf("%d*%d=%d ",j,i,i*j)
}
fmt.Println()
}
} func main(){
multi()
}
2. 一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6=1+2+3。编程找出1000以内的所有完数。
package main import "fmt" func perfect(n int) bool {
var sum int
for i :=; i < n; i++{
if n%i == {
sum += i // 把该数的所有因子加起来
}
}
return n == sum
} func process(n int){
for i := ; i <= n; i++{
if perfect(i){
fmt.Println(i)
}
}
} func main(){
var n int
fmt.Scanf("%d",&n) process(n)
}
3. 输入一个字符串,判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串。
// 示例代码:
package main import "fmt" func process(s string) bool {
for i := ; i < len(s)/; i++{ // 从字符串的两边向中间靠拢
if s[i] != s[len(s)--i]{
return false
}
}
return true
} func main(){
var s string
fmt.Scanf("%s\n",&s) result := process(s)
if result {
fmt.Printf("%s is huiwen\n",s)
} else {
fmt.Printf("%s not huiwen\n",s)
}
}
4. 输入一行字符,分别统计出其中英文字母、空格、数字和其它字符的个数。
package main import (
"fmt"
"bufio"
"os"
) func count(s string) (charCount, spaceCount, numCount, otherCount int){
t := []rune(s) // 转换类型 for _,v := range t {
switch {
case v >= 'A' && v <= 'z': // 比较是在 ASCII 中的位置数字; byte 型的只能用单引号
charCount++
case v == ' ':
spaceCount++
case v >= '' && v <= '':
numCount++
default:
otherCount++
}
}
return
} func main (){
reader := bufio.NewReader(os.Stdin) // bufio.NewReader() 实例化一个对象;os.Stdin 标准输入
result, _, err := reader.ReadLine() // 从终端读取输入;返回的第一个参数 (result) 是 []byte
if err != nil {
fmt.Println("Read from console err:",err)
return
} fmt.Println(result) cc, sc, nc, oc := count(string(result)) // 先把 result 转换成 string 类型
fmt.Printf("word count:%d\n space count:%d\n number count:%d\n others count:%d\n",cc,sc,nc,oc)
} // byte 等同于int8,常用来处理ascii字符
// rune 等同于int32,常用来处理unicode或utf-8字符 // 运行结果如下:
[root@NEO example06_count]# go run main/main.go
hello -=
[ ]
word count:
space count:
number count:
others count:
[root@NEO example06_count]#
5. 计算两个大数相加的和,这两个大数会超过int64的表示范围.
package main import (
"fmt"
) func fillZero(s string, n int)string{
var res string = s
for i:=; i<=n; i++{
res = fmt.Sprintf("%c%s",'',res)
}
return res
} func plus(a string, b string) string {
var index,carry,length int // index 表示从右开始的个数; carry 表示进位(相加满十进一);length 表示两个数字字符长度
var str_plus string // 长度小的在前面填充 0
len1 := len(a)
len2 := len(b) if (len1== && len2==){
return ""
} switch {
case len1 > len2:
n := len1 - len2
res := fillZero(b,n)
b = res
length = len1
case len1 < len2:
n := len2 - len1
res := fillZero(a,n)
a = res
length = len2
default:
length = len1
} // 各位相加
for (index <= length-) {
byte_a := a[length--index] - '' // 数字对应的字符 减去 '0' 字符,就是该数字的值;uint8 类型
byte_b := b[length--index] - '' sum := int(byte_a) + int(byte_b) + carry if sum >= {
carry =
} else {
carry =
} byte_new := (sum % ) + ''
str_plus = fmt.Sprintf("%c%s",byte_new,str_plus)
index++
}
if carry == {
str_plus = fmt.Sprintf("1%s",str_plus)
}
return str_plus
} func main(){
var a, b string
fmt.Scanf("%s %s\n",&a, &b) res_plus := plus(a,b)
fmt.Println(res_plus)
}