三、golang时间、流程控、函数

练习1、判断url是否是以http://开头，如果不是则加上http://
a)    练习2、判断一个路径是否以“/”结尾，如果不是，则加上/

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)

}
执行：
D:\project>go build -o day3/example1.exe go_dev/day3/example/example1

D:\project>cd day3

D:\project\day3>example1.exe
10.100.8.8/user/login c:/study
http://10.100.8.8/user/login
c:/study/

package main

import (
   "strings"
   "fmt"
   "strconv"
)

func main(){
   str:="hello world abc \n"
   result:=strings.Replace(str,"world","you",1)
   fmt.Println("replace",result)

   count:=strings.Count(str,"1")
   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(str)
   fmt.Println("trimspace",result)

   result=strings.Trim(str,"\n\r")
   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:=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])
   }


   str2:=strings.Join(splitResult,"l")
   fmt.Println("join",str2)

   str2=strconv.Itoa(1000)
   fmt.Println("itoa",str2)

   number,err:=strconv.Atoi(str2)
   if err!=nil{
      fmt.Println("can not conert to int",err)
   }
   fmt.Println(number)

}
执行结果：
D:\project>go build go_dev/day3/example/example2

D:\project>example2.exe
replace hello you abc

count 0
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
fields hello
fields world
fields abc
split he
split
split o wor
split d abc

join hello world abc

itoa 1000
1000

package main

import (
   "time"
   "fmt"
)

func test(){
   time.Sleep(time.Millisecond*100)
}



func main(){
   now:=time.Now()
   fmt.Println(now.Format("2006/01/02 15:04:05"))  //获取当前时间
   start:=time.Now().UnixNano()  //获取1970年到现在的纳秒数
   test()
   end:=time.Now().UnixNano()
   fmt.Printf("cost:%d us\n",(end-start)/1000)  //统计时间
}
/*
D:\project>go build go_dev/day3/example/example3

D:\project>example3.exe
2017/11/24 16:49:38
*/

package main

import "fmt"

func main(){
   var a int=10
   fmt.Println(&a)

   var p *int
   p=&a
   fmt.Println(*p)
   *p=100
   fmt.Println(a) //这里的a的值为100
   
   var b int=999
   p=&b
   *p=5
   fmt.Println(a) //100
   fmt.Println(b) //5
   
}

package main

import "fmt"

func modify(p * int){
   fmt.Println(p)  //打印的是一个地址
   *p=1000900
   return
}

func main(){
   var a int=10
   fmt.Println(&a)

   var p *int
   p=&a
   fmt.Println(*p)
   *p=100
   fmt.Println(a) //这里的a的值为100
   modify(&a)  //因为参数是指针，所以这里传入的应该是地址
   fmt.Println(a)//1000900
}
上面第一个函数的参数是指针，所以传入参数的时候应该传入的是一个地址（指针就是一个地址），然后在函数中进行给指针赋值，也就是给地址赋值所以a的值就变化了

package main

import (
   "fmt"
   "strconv"
)

func main(){
   var str string
   fmt.Scanf("%s",&str)   //这里是获取输入内容的地址
   number,err:=strconv.Atoi(str)
   if err!=nil{
      fmt.Println("converf failed",err)
      return
   }
   fmt.Println(number)
}

package main

import(
   "fmt"
   "math/rand"
)

func main(){
   var n int
   n=rand.Intn(100)
   for {
      var input int
      /*
      下面如果不加上\n的话会输出两次，原因是输入的数字和回车会放入到缓冲区，然后scanf
      过来取，首先取输入的数字，然后取回车键，分别打印。
      这里的Scanf默认是空格来分割的，这里用\n来分割，就不会打印输出两次了
      */
      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
      }
   }
}

package main

import(
   "fmt"
)

func print(n int){
   for i:=1;i<n+1;i++{
      for j:=0;j<i;j++{
         fmt.Printf("A")
      }
      fmt.Println()  //这里代表换行
   }
}

func main(){
   print(6)
}

如：
package main
import (
    “fmt”
)
func main(){
LABEL:
    for i:=0;i<=5;i++{
for j:=0;j<=5;j++{
    if j==4{
        countinue LABEL   //当j等于4的时候就跳到LABEL上面
}
fmt.Printf(“i is %d j is :%d/n”,i,j)
}
}
}

func calc(a,b int) (sum int,avg int){
    sum=a+b
    avg=(a+b)/2
    return
}
func main(){
    sum,_=calc(100,200)
}
上面的这个小程序如果只想要和不想要平均值，那么这个时候可以用_来忽略返回值