01.go基本语法

包的概念、导入和可见性
0.1 一般来说文件名和报名都是不同的;
0.2 每个go语言都包含一个名为main的包
0.3 所有的包名都必须使用小写字母
0.4 对一个包进行更改或重新编译,所有引用了这个包的客户端程序都必须全部重新编译
0.5 导入多个包写法
-- import (
     "fmt"
     "os"
   )



-- import "fmt"; import "os"
-- import ("fmt";"os")
0.6 包pack1中有一个变量或者函数叫做Max,首字母大写 可以被外部调用,如果是小写
  -- 对外不可见 但是对内是可见 并且可用的。
0.7 别名方式:
--
package main
import fm "fmt" // alias fm

func main() {
    fm.Println("vim-go")
}

0.8 注释:
-- // 单行
-- /* */ 多行

0.9 type
-- var 声明的变量的值会自动初始化为该类型的零值。类型定义了某个变量的值的集合与可对其进行操作的集合。
-- 类型可以是基本类型,如:int、float、bool、string;
-- 结构化的(复合的),如:struct、array、slice、map、channel;
-- 只描述类型的行为的,如:interface。
-- 结构化的类型没有真正的值,它使用nil作为默认值,Go语言中不存在类型继承。
  -- 结构类型定义:
  type Jesse struct {
    id int
    name string
    age int
  }

0.10 函数格式
-- 格式
func 函数名(参数1 参数1类型,参数2 参数2类型,...) (返回值类型1,返回值类型2,...) {
    函数体
    return var1, var2 ....
}
  -- 函数名:就是函数的名称, 由字母、数字、下划线组成,其中首个字母不能为数字。在同一个包内,函数名称不能重名.
  -- 参数:声明参数要指明类型,如果所有参数一致,则只要在最后加上1个类型声明就可以了。
    -- example
    func Sum(a, b int) int { //这边a,b是都是int型,所有在最后加上一个int就可以了。
        return a + b
    }

  -- 返回值:其中var1,var2,…的数据类型要分别和返回类型1,返回类型2,…相同.如果只有一个返回值,在声明返回值类型时可以不用小括号。
  -- 指明返回名称的函数示例:
    -- 指明了返回值的名称 在函数中可以不用声明result就直接使用,在函数返回时直接return就可以了。如果指明返回值名称,即使只有一个返回值,也要用小括号括起来。
    func Power(a int) (result int) { 
        result = a * a
        return 
    }

0.11 常量
-- 使用关键字const定义 用于存储不会改变的数据
  -- 常量中的数据只能是布尔型、数字型、字符串型
    -- 3.14 //浮点类型常量
    -- true //布尔类型常量
    -- "foo"//字符串常量

  -- 格式 const identifier [type] = value
    -- const b string = "abc" // 显式定义
    -- const b = "abc"        // 隐式定义

  -- 常量的值必须是能够在编译时就能够确定的
 
  -- 几种定义方式
    -- const Pi float64 = 3.14159265358979
    -- const zero = 0.0 // 无类型浮点常量
    -- const (
      size int64 = 1024
      eof = -1 // 无类型整型常量
    )

    -- const u,v float32 = 0,3 // u=0.0 v-3.0 多重赋值
    -- const a,b,c = 3,4,"foo" // 无类型常量和字符常量

-- 预定义常量
  -- go语言预定义了这些常量true,false,iota
  -- iota比较特殊 可以认为是一个可以被编译器修改的常量,在每一个const关键字出现时被重置为0,然后在下一个const出现之前,每出现一次iota,其所带便的数字会自动+1

  const (  //被重置为0
    c0 = iota //c0==0
    c1 = iota //c1==1
    c2 = iota //c2==2
  )

  const (
    a = 1 << iota //a==1
    b = 1 << iota //b==2
    c = 1 << iota //c==4
  )  
  
  const (
    u = iota * 42 //u==0
    v float64 = ioat * 42 //u==42
    w = ioat * 42 //w==84
  )
  
  const x = iota //x==0 被重置为0
  const y = iota //y==0 再次被重置为0

  -- 因为 第一个iota等于0,每当iota在新的一行被使用时,它的值都会自动加1;所以a=0,b=1,c=2可以简写为如下形式:
    const (
            a = iota
            b
            c
          )

--枚举
  const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    numberOfDays //这个常量没有导出 为包内私有
)

0.12 变量
--声明
  var v1 int
  var v2 string

--避免写做个var写法
  var (
    v1 int
    v2 string
  )

--变量被声明后,系统自动赋予它该类型的零值:
  --int 为 0,
  --float 为 0.0,
  --bool 为 false,
  --string 为空字符串,
  --指针为 nil。
  --(所有的内存在 Go 中都是经过初始化的)  

--变量的命名规则遵循驼峰式命名法(首个单词小写 每个新单词的首字母大写example: numShips and startDate)
--全局变量希望被外部包所使用,则需要将首个单词的首字母大写Add

--变量初始化
  var v1 int = 10
  var v2 = 10
  v3 := 10 //编译器可以自动推导出v3类型 变量不应该是被声明过的 否则会报错

--变量赋值
   var v3 int
   v3 = 124
  
--多重赋值 i,j=j,i

--匿名变量
    假设GetName()函数定义如下 返回三个值firstname,lastname,nickName
    func GetName() (firstname,lastname,nickname string) {
      return "zhang","luya","zhang luya" 
    }

    如果只想获取nickname 写法如下:
    _,_,nickname := GetName()

--其它方式获取变量

vim goos.go
############################################################
package main
import (
        "fmt"
        "os"
        "runtime"
       )

func main() {
       var goos string = runtime.GOOS
       fmt.Printf("The OPERATING SYSTEM IS: %s\n", goos)
       path := os.Getenv("PATH")
       fmt.Printf("Path is %s\n", path)
}
############################################################

-- printf
  -- %s // string
  -- %v // 代表使用类型的默认输出格式的标识符
  
-- 空白标识符_
  -- 也被用于抛弃值如5 在: _,b = 5,7中被抛弃

-- init函数 
 -- 变量除了可以在全局生命中初始化,也可以在init函数中初始化。这是一类页数函数,它不能被人为调用,而是在每个包完成初始化后自动执行,优先级比main函数高。
 -- 每一个源文件都可以包含一个或多个init函数,初始化总是以单线程执行,并且按照包的依赖关系顺序执行。
 -- 每个包可以拥有多个init函数。
 -- 包的每个源文件也可以拥有多个init函数。
 -- 同一个包中多个init函数的执行顺序go语言没有明确的定义(说明)。
 -- 不同包的init函数按照包导入的依赖关系决定该初始化函数的执行顺序。
 -- init函数不能被其他函数调用,而是在main函数执行之前,自动被调用。

-- 实例
root@hk.aliyun.web.01:~/go/1_初始go语言/code# cat init.go
package main
import "fmt"

func init() {
	fmt.Println("init1")
	testf()
}

func main() {
	fmt.Println("main")
}

func testf() {
	fmt.Println("do in testf")
}

-- 执行顺序
root@hk.aliyun.web.01:~/go/1_初始go语言/code# go run init.go
init1
do in testf
main

Posted in Go

发表评论

电子邮件地址不会被公开。 必填项已用*标注