GOLNAG语言学习——day01

标题：走进 Go 语言基础语言 - 掘金网址：juejin.cn/course/byte…

golang语言的优势

1、高性能，高并发 2、语法碱度，学习曲线平缓 3、丰富的标准库 4、完善的工具链 5、静态链接 6、快速编译 7、跨平台 8、垃圾回收

基础语法练习

练习1：hello golang

//创建 HelloGolang.go文件，并在文件中编写如下命令行

package main //把test.go 引入main包
//import {
//    "fmt"
//} 或
import "fmt"  
func main(){
	//打印hello golang！
	fmt.println("hello golang!")
}

>集成终端输入
>
>1.先编译后运行
>
>go bulid HelloGolang.go  //编译过程
>
>./HelloGolang.exe        //运行过程 
>
>2.直接运行
>
>go run HelloGolang.go

练习2：变量

变量的声明(类似于javascript) 1、var 变量名 = 变量值(go自主判断变量类型) / var 变量名变量类型 = 变量值 2、变量名 := 变量类型(变量值) / 变量名 := 变量值常量的声明(类似于javascript) const 变量名变量类型 = 变量值

package main
import {
   "fmt"
    "math"
}

func main() {
  var a = "initial"  //字符串类型
  var b,c  int = 1,2  //整型Integer 这种先声明变量名在声明类型的语句类似SQL语句
  var d = true  //boolean布尔型
  var e float64 //64位浮点型  默认值为0
  f := float32(e) 
  g := a + "top"
  
  //打印数据
  fmt.Println(a,b,c,d,e,f)
  fmt.Println(g)
 
  //下面开始使用math
  const s stirng = "constant"  //字符串
  const numb = 30000000
  const i = 3e20 / numb

  fmt.Println(s,numb,i,math.Sin(h),math.Sin(i))
}

条件语句 if-else

[注]

if 判断条件 {

true时的result }else { false时的resul }

package main
import "fmt"

func main() {
  //% 取余数
  if 7%2 == 0{
    fmt.Println(”7 is even“)
  }else  {
    fmt.Println("7 is odd")
  }

  if num :=9;num < 0 {
    fmt.Println("num = ",num,"result is num < 0")  
  }else if num < 10 {
    fmt.Println("num=",num,"result is num <10")
  }else{
    fmt.Println("result is num > 0 && num > 10")
  }
}

循环语句 for

for 语句

[注] for 初始值;循环条件;循环体{} 其中初始值,循环条件,循环体不强制要求声明在for之后 break //跳出当前循环，不在执行for语句 continue //跳出当次循环，执行循环体后继续佛如语句 break && continue 之后的语句都不在执行

package main
import "fmt"

func main(){
  i := 1 //初始条件声明在for外
  for {
    fmt.Println("用break来跳出当前死循环！")
    break
  }
  //j++ : j 自增1，即 j := j+1
  for j := 1 ;j < 50; j++{
     if j%2 == 0{
       continue;
     }
     if j != 49 {
       fmt.Print(j,",")
     }else {
       fmt.Println(j)
     }
 }

  for i < 5 {
    fmt.Println(i)
    i += 1
  }
}

switch

[注] case 不需要使用break来截断

package main
import (
   "fmt"
   "time"
)

func main(){
  a := 2
  switch a{
     case 1:
         fmt.Println("one");
     case 2:
         fmt.Println("two");
      default:
          fmt.Prinlt("now execute default");
   }

  t := time.Now()   //获取当前时间
  swtich {
     //t对象(?)调用 .Hour()方法(函数)
     case t.Hour() < 12:
        fmt.Println("noon")
      case t,Hour() > 12:
         fmt.Println("morning")
  }
  }

}

数组

[注]

一维数组

var 数组名 [数组长度]数组类型

b := [数组长度]数组类型{数组内部数据} //数据位置 = 数组索引-1

二位数组 var towD [数组长度][数组长度]数组类型

package main
import "fmt"

func main(){
  var a[5]int   //一维长度为5的数组
  twoB := [2][5]int //二维数组，大小为10
  twoB[0] := [5]int{1,2,3,4,5}
  twoB[1] := [5]int{6,7,8,9,10} 
  //获取数组长度
  fmt.Println(len(twoB[0]))
}

切片(类似Stack)

[注]

**声明方式：**s := make([]切片类型，切片长度)

已知索引的赋值 s[0] = "a" //0为角标(索引)

未知索引赋值 s = append(切片对象名，新增内容i)(i可以有多个)

打印一般情况下与数组打印方式一致；打印特定位置内容是使用 ‘fmt.Println(s[i:j])’ [i,j索引前闭后开]

package main
import "fmt"

func main() {
  s := make([]string,2)
  s[0] = "a"
  s[1] = "b"
  s = append(s,"c","d")
 
  c := make([]string,len(s))
  copy(c,s)  //将s中数据拷贝到c中
  
  fmt.Println(s[1:2])  //可理解为前闭后开

}

map

[注]

m := make(map[key]value) //类似于一维函数中的x(key)和y(value)，一个y(value)可以对应多个x(key),一个x(key)只可以对应一个y(value)

package main
import "fmt"

func main(){
  m := make(map[key值类型]value值类型)
  m["one"] = 1 // one => 1 
  m["two"] = 1 // two => 1
  m["one"] = 2 // one =>2(代替1)

  fmt.Println(len(m))  //2

  r,ok := m["one"] //判断map中是否含有 key=one的元素
  fmt.Println(r,ok)  //2 ftrue

  delete(m,"one")
  mm := make(map[string]int{"one":1,"two":2})  //注意使用，隔开
}

range函数

快速遍历数组 for 遍历结果名1:遍历结果名2 := range 遍历map \ 数组名

package main
import "fmt"

func main() {
  ints := [3]int{1,2,3}
  sum := 0

  for index,value := range ints {
    sum += value
    fmt.Println("索引为：",index,"，值为：",value)
  }
  //输出value和
  fmt.Println(sum)
  m := map[string]int{"a":1,"b":2,"c":3}
  for key,value := range m{
    fmt.Println(key,":",value)
  }
}

函数

类似于java中的方法

package main
import "fmt"

//add=>函数名
//(a int,b int)=>实参a，b
//int 返回值类型
func add(a int,b int) int{
  return a + b
}

func add2(a , b int) int {
  return a + b
}

//判断k在m中是否存在的函数
//牛啊，go语言中可以有多个返回值
func exists(m map[string]string,k string)(v string,ok bool){
   v,ok  = m[k]
   return v,ok
}

func main() {
  //函数调用
  res := add(1,2)
  v,ok := exists(map[string]string{"a":"A","b":"B"},"a")
}

指针(相当可变化的实参)

java内不含

package main
import "fmt"

//改变实参可用方式一：
func add2ptr(i *int){
  *i += 2
}

//改变实参可用方式二：
func add2ptr2(i int) int {
  return i+2
}

func main() {
  var i int = 2
  add2ptr(&i)
  fmt.Println(i)
  i = add2ptr2(i)
  fmt.Println(i)
}

Tips：

golang语言的开发者是C语言之父
为了避免不必要的import，go语言规定只有使用过的包才可以被import
:= 声明后赋值 / == 等于
Println 中必须大写否则会报错
任意类型的数据都可以使用switch,且数据两侧不用加()
数组内部赋值需要使用 ‘=’
无内部填充值的数组不可以用 b := [5]int 的方式进行声明只可使用 var b [5]int，有内部填充值的数组不可使用 var b[1]int{1}进行声明
:= 可以理解为定义后赋值
golang中map的输出是随机输出

Golang语言学习—day01