一、 go语言分支语句与循环语句

package main

 //go语言分支语句与循环语句import (

   "io/ioutil"

   "fmt"

   "strconv"

   "os"

   "bufio") //var 和 const可以用括号括起来,import也可以

//这里讲解iffunc main() {

   const filename= "abc.txt" //常量定义,赋值类型不用指明

   //contents,err := ioutil.ReadFile(filename)
//变量定义

   //

   //if err != nil {

   // fmt.Println("出错了")

   //} else {

   //
fmt.Printf("%s\n",contents)

   //结果 :

   //读取了本文件,这就是那句话

   //换一行

   //嘿嘿


   //另一种写法:

   var a int = 1;

   if contents,
err := ioutil.ReadFile(filename);a == 1 &&
err != nil{  //这里有一个读取文件的操作,而且这里,

   // 函数的返回值可以是两个

      fmt.Println("出错了")

   } else {

      fmt.Printf("%s\n", contents)

   }//与上面结果样,这里的contents与err就是if这个语句块中的了,不能在外面访问了。

   //if后面只能跟两个及以下的语句,第一个复制,另一个是bool语句


   //这里对switch进行

   fmt.Println(userswitch(10))

   //这里传入的10  ,如下运行结果;

   //这个数小于40

   //运行完了

//由此可见,switch语句中如果是用boolean的话,从第一个开始检测,如果第一个为真了,那么久执行第一个后,后面的就不会

//再执行了,如下函数,不管你输入什么数,他只会执行第一句,这个可以算作switch的一个小细节需要注意吧。


   //这里对for进行

   fmt.Println(userfor(13),

      userfor(1205454534),

      userfor(0),

         ) //换行讲究,没有逗号就不可以换行


   //上面提到的读文件,现在才用一行一行的读文件

   file,err := os.Open(filename) //打开一个文件

   if err !=
nil{ //nil 就是空的意思

      panic(err) //panic就是报错的意思,会中断执行

   }

   scanner := bufio.NewScanner(file) //用文件句柄去拿到读取器吧,我这样理解


   for i := 1; scanner.Scan(); i++{

      fmt.Println("第"+strconv.Itoa(i)+"行 :" +
scanner.Text()) //每行的信息

   }

}

func userswitch(score int) string{ //函数的定义,类型总是写在后面。

   switch  {

   case score
< 40:

      fmt.Println("这个数小于40")

   case score
< 20:

      fmt.Println("这个数小于20")

      fallthrough //如果执行完不跳出的话,需要加这个

   case score
< 0:

      fmt.Println("这个数小于0")

   default:

      panic(fmt.Sprintln("这个输入的数大于了40我不执行"))

   //相当于打印出错信息,会中断程序

   }

   return "运行完了"}

func userfor(num int) string{

   //实现一个正数转换成二进制的表达式

   re := ""

   for ; num
> 0; num /= 2{

      s := num % 2

      re = strconv.Itoa(s) + re; //数字转换成字符串的方式,strconv

   }

   return re

}

//这个while有问题func userforlikewhile()  {

   if false {

      for true {

         i := 1

         i += 1

      } //死循环,我就不跑了,这就好比while,go为了极力简化关键字,while也米有了


      for{

         fmt.Println("这就是go的死循环")

      }//go的死循环很好写,因为go语言很多地方的写并发,都要用到死循环。

   }

}

二、 go语言函数

package main

import "fmt"

//go语言的函数,,,刚刚去看了下库,发现,go语言仍然使用驼峰规则


//定义一个函数


//我暂时没有找到函数的参数定义意义的注释方式
func myfirstfunc(a, b int, c string) string { //int类型参数一样写在一起,简化了语法


   return "运行了这个函数"
}

func func1() (string, string) { // 返回两个值的函数,呸,应该说多个值

   return "第一个返回值", "第二个返回值"
}
func func2() (s1,s2 string) { // 返回两个值的函数,可以个参数取名字

   s1 = "1";

   s2 = "2";//s1与s2两个变量已经被定义好了,可以用于返回

   return "第一个返回值", "第二个返回值"
}
//多返回值函数不能乱用,一般只用于比较简单的函数中
func main() {

   a,b := func1()

   fmt.Println(a,b); //没有问题,可以接收到

   //如果只想接收一个值怎么办,

   c,_ := func1() //下划线代表不想要

   fmt.Println(c)



   //go语言多返回值的应用,返回错误

   aa,ee := gofun(60)

   if ee != nil {

      fmt.Println("出错了哦")

   }else {

      fmt.Println(aa)

   }


   toUseFun()//函数参数调用哪儿


   can := canChange(9,2,3,4,5)//可变参数

   fmt.Println(can)

}

//上面对函数的基本用法讲解了,对于函数的多返回值多讲解一句,

//go语言中对于异常的做法就是通过多返回值的方式往外部返回,所以一般多返回值不能乱用,多用于传输异常。

//例:
func gofun(a int) (r string,err error) {

   //两个括号,

   //后一个参数就是返回异常

   if a > 50{

      return "大于50",fmt.Errorf("大于50,有问题 ")

   } else{

      return "小于50",nil

   }

}

//go语言的函数式编程,函数作为参数

//例:
func ccc(a,b int) int {

   return a + b

}
func gofun1(do func(int,int) int,a,b int) int { //函数作为参数

   return do(a,b)

}

func toUseFun()  {

   a :=gofun1(func(i int, i2 int) int { //这里可以写匿名参数,也写其他参数的名字,反射这里我就不抄别人的代码,后面学到再说

      return i + i2

   },1,2)

   fmt.Println(a)

}

//可变参数列表的函数
func canChange(a ...int)int{

   var sum1 int

   var sum2 int

   for c := range a { //这里涉及到一个关键字range,所以有问题哦

      sum1 += c // 这个c是什么,现在看就是1234递增等明白range才能知道

      sum2 += a[c]

   }

   return sum2;

}

 

三、 go语言指针

package main

import "fmt"

//go语言的指针

//go语言有指针,相对与c语言的指针,go语言的指针没那么难,go语言的指针更加简单

//c语言的指针之所以难是因为c语言的指针能够运算,变化万千,而go语言的指针只能有个指向功能

//通常用于函数传递参数


//那么我们来演示下函数传递参数时的做法
func swap(a,b *int)  {

   //传入两个指针

   *a,*b = *b,*a;

}

func main() {

   a,b := 1,2;

   swap(&a,&b);

   fmt.Println(a,b)//输出两个值的交换后 a,b
}

//go语言只有值传递,指针复制与结构体复制与值复制

 

四、 go语言数组

package main

import (

   "fmt"
)

//go语言数组
func main() {

   //定义

   var arr [5]int//var,自动复制为0

   arr1 := [3]int{1,2,3} //指明长度,没有var就必须要赋值

   arr2 := [...]int{1,2,3,4,5} //不指明长度

   fmt.Println(arr,arr1,arr2) //结果[0 0 0 0 0] [1 2 3] [1 2 3 4 5 6 7 8 9]


   //**数组时值类型,函数传递的时候采用拷贝的方式。

   var gird [4][6]int //4行6列0

   fmt.Println(gird)


   goEvery(arr2)

   goE(&arr2) //把arr2传个地址
}

func goEvery(arr [5]int)  {

   for i := range arr{ //这里遇见第一个range的用法,i返回的时数组的下标

   //联想前面的可变参数传入的应该就是一个数组,啊呸,一个切片(这个下一节看)

      fmt.Print(i)

      fmt.Print(arr[i])

   }

   for i,v := range arr {

      fmt.Print(i)

      fmt.Print(v)//与上面的那几行代码一个意思,这里的i,v通过range传出,厉害呢

   }

}

func goE(arr *[5]int)  {

   arr[0] = 100; //这个arr的指针传进来,将第一个改为100,没问题。指针直线
}