go语言之行--包与变量

日期: 2019-12-06 15:29 浏览次数 :

前言

一、包的概念

1. Go项目标目录构造

正文重要介绍了关于go语言之包和变量的有关内容,分享出去供我们参谋学习,上面话没有多少说了,来二只会见详细的牵线吧。

包是go语言中不得缺点和失误部分,在各样go源码的第生机勃勃行举办定义,定义格局是:package "包名",何况该名称是作为调用该包时候所利用的称呼。

  平常的,多个Go项目在GOPATH下,会好似下四个目录:

生机勃勃、包的概念

包的概念总计:

  project

包是go语言中不得缺点和失误部分,在每一种go源码的首先行举行定义,定义方式是:package "包名",而且该名称是作为调用该包时候所采取的名号。

  • 各个 Go 文件都归属且仅归于一个包。叁个包能够由多数以.go为扩展名的源文件组成,由此文件名和包名大概两样,为了规范,成效肖似或然归属同生机勃勃属性的源码归集到相近的包名中。
  • 各类应用程序都必得有且只有二个包名为main,他是该程序的输入,推行时候会寻觅包名称为main的代码
  • 包与包里面可以被相互调用,主要为了减削代码重复性
  • 包后生可畏旦被引进就供给被利用,除非引进的时候忽视它(前边加_表示忽视它,只是用它来开头化),借使引进了包,而在代码中没用利用,运维时候会报错

     --- bin

包的定义计算:

二、包的引入

     --- pkg

  • 各种 Go 文件都归于且仅归于三个包。七个包能够由众多以 .go 为扩张名的源文件组成,由此文件名和包名或然不一样,为了规范,成效相通也许归属同风流倜傥属性的源码归集到平等的包名中。
  • 种种应用程序都必得有且独有一个包名称叫main,他是该程序的入口,施行时候会搜索包名叫main的代码
  • 包与包里面能够被互相调用,主要为了裁减代码重复性
  • 包风流浪漫旦被引进就需求被应用,除非引进的时候忽略它(后面加_意味着忽视它,只是用它来初步化),要是引进了包,而在代码中没用利用,运维时候会报错

1.包引进的诀窍

方法一:

import "fmt"import "os"

方法二:

import "fmt"; import "os"

方法三

import (   "fmt"   "os")

     --- src

二、包的引进

2.引进其他包

go语言中,引进包的不二秘技是基于GOPATH/src 那么些情形变量作为相对路线进行引进的,即使GOPATH存在五个,那么go将相继找出路线,直到找到,若GOPATH/src未找到则编译出错。

示例:

我的GOPATH为:C:Users17647Desktopgo_worksrc

率先创制包文件1:C:Users17647Desktopgo_worksrcday02eg1pkg.go(相对于GOPATH/src的渠道为day02eg1pkg.go)

内容如下:

package add   import "fmt"func Sum(a int,b int)  {    var c int    c = a + b    fmt.Println("res",c) }

在main进行引进如下:

package mainimport (    "fmt"    "day02/eg1"  /* 引入包 */)func main() {    add.Sum(2,3) /* 调用包 */    fmt.Println("Hello, World!")}

图示:

图片 1

二、变量

  此中,bin 寄存编写翻译后的可试行文件;pkg 寄存编写翻译后的包文件;src 寄存项目源文件。常常,bin 和 pkg 目录能够不创制,go 命令会自动创建(如 go install),只须求成立 src 目录就可以。对于 pkg 中的文件是 Go 编写翻译生成的,实际不是手动放进去的(平时文件后缀.a)对此 src 目录,寄存源文件,Go 中源文件以包(package)的花样协会。常常,新建贰个包就在src目录中新建贰个文书夹。

1.包引进的点子

1.单个变量的宣示

go语言中,全部变量都一定要先评释在选取,下边是宣称变量和赋值方法:

  • 先表明后赋值: var <变量名称> <变量类型> 赋值:变量的赋值格式: <变量名称> = <表明式>
  • 宣称的还要赋值:var <变量名称> <变量类型> = <表达式> (简写为 变量名称 := 说明式)

示例:

package mainimport "fmt"func main() {    var a string  /* 声明一个变量名为a,类型为字符串的变量 */    a = "wd"      /* 对a变量赋值*/    var age int = 22  /* 声明并赋值变量 */    fmt.Println}

注意:GOPATH 允许三个目录存在和安顿,当有多个目录时,请介意分隔符,四个 GOPATH 的时候 windows 是分号,linux 和 mac 系统时冒号,当有两个 GOPATH 时,暗中认可会将 go get 的从头到尾的经过放在第一个目录下。

方法一:

2.四个变量注解

  • 先注脚后赋值:var <变量1>,<变量2>,<变量3> <变量类型> 赋值 :<变量1>,<变量2> = 值1,值2
  • 声称同偶然间赋值 :var<变量1>,<变量2> = 值1,值2 可简写为:<变量1>,<变量2> = 值1,值2
  • 多少个变量还足以选择var(卡塔尔(قطر‎申明

示例:

package mainimport "fmt"func main() {    var a,b int    a,b = 1,2    var c,d = 3,"wd" /* 类型自动推断 */    e, f := 4, "hello"  /* 简写 */    fmt.Println(a,b,c,d,e,f)}

使用var()声明

package mainimport "fmt"func main()  {    var (        a int   //默认值为0        b string // 默认值为空字符串        c = 3     )    fmt.Println}

  在最后产生项目后(大概还有可能会依赖github上的局地包)全体构造图如下所示:

import "fmt"
import "os"

3.变量名

命名法规:

  1. 首字符能够是随便的Unicode字符或许下划线
  2. 剩余字符能够是Unicode字符、下划线、数字
  3. 无法作为用以下重点字作为变量名
break        default      func         interface    selectcase         defer        go           map          structchan         else         goto         package      switchconst        fallthrough  if           range        typecontinue     for          import       return       var

  图片 2

方法二:

4.可见性

可以见到性即对包外可以看到,当其余包调用当下包的变量时候是还是不是允许可以看到。

  • 变量开端字符大写,表示可以知道
  • 变量最先字母非大写,则意味私有,不可以知道

2. 行分隔符

import "fmt"; import "os"

5.变量的成效域

  • 函数钦赐义的变量称为局地变量,其功效域在函数内
  • 函数外定义的变量称为全局变量,功能于豆蔻梢头体包,并且该变量首字母大写,则对别的包可知。
三、常量

常量是一个简单值的标志符,在程序运营时,不会被涂改的量。

常量中的数据类型只可以够是布尔型、数字型(整数型、浮点型和复数)和字符串型。

概念常量语法:

const 名称 类型 = value

三个常量定义语法:

const (    a = 0  //类型自动推倒    b = 1   c = 2)

iota解释:

iota,特殊常量,能够认为是三个方可被编写翻译器更改的常量。

在每一种const关键字现身时,被重置为0,然后再下一个const现身早前,每现身一回iota,其所代表的数字会自动扩大1。

iota 能够被用作枚举值:

const (    a = iota    b = iota    c = iota)

首先个 iota 等于 0,每当 iota 在新的生龙活虎行被应用时,它的值都会活动加 1;所以 a=0, b=1, c=2 足以简写为如下情势:

const (    a = iota    b    c)

用法:

package mainimport "fmt"func main() {    const (            a = iota   //0            b          //1            c          //2            d = "ha"   //独立值,iota += 1            e          //"ha"   iota += 1            f = 100    //iota +=1            g          //100  iota +=1            h = iota   //7,恢复计数            i          //8    )    fmt.Println(a,b,c,d,e,f,g,h,i)}

  在 Go 程序中,生龙活虎行代表一个讲话甘休。各种语句不供给像 C 宗族中的其余语言相同以总局( ; 卡塔尔(英语:State of Qatar) 结尾,因为这几个工作都将由 Go 编写翻译器自动达成。假使您筹划将七个语句写在同一行,它们则必须使用分号( ; 卡塔尔(英语:State of Qatar)人为区分,但在实质上支出中我们并不激励这种做法。

方法三(推荐!)

3. 注释

import (
 "fmt"
 "os"
)

  注释不会被编写翻译,每三个包应该有连带注释。

2.引进其余包

  单行注释是最见怪不怪的笺注形式,你能够在任哪里方使用以 // 先河的单行注释。多行注释也叫块注释,均已以 /* 开头,并以 */ 结尾。如:

go语言中,引进包的门径是依附GOPATH/src 这些情状变量作为相对路线实行引进的,假使GOPATH存在多少个,那么go将依次寻找路线,直到找到,若GOPATH/src未找到则编写翻译出错。

    // 单行注释
    /*
         Author by liangyongxing
         我是多行注释
     */

示例:

4. 放置关键字(二十二个都小写卡塔尔

我的GOPATH为:C:Users17647Desktopgo_worksrc

    break    default    const    interface    select    case    defer     go       map    struct    chan    
    goto     package    switch   fallthrouth   func    return  range    type    continue     import 
    else     for    var

第一建立包文件1:C:Users17647Desktopgo_worksrcday02eg1pkg.go(相对于GOPATH/src的路径为day02eg1pkg.go)

5. Go程序的依次构造

剧情如下:

  要想写出让人瞧着恬适的代码,且独具自然的企业规范标准,平日都以索要有自然的正统技艺达到钦定的须求,上边就来讲说那一个正式到底是怎样?

package add 

import "fmt"

func Sum(a int,b int) {
 var c int
 c = a + b
 fmt.Println("res",c) 

}

  1. 率先行鲜明是透过 package 来组织的,是透过注重词 import 来引进所信任的包(与 python 相相同)  ps: import "fmt"

在main实行引入如下:

  2. 静心:独有 package 名称叫 main 的包才足以分包 main 函数

package main

import (
 "fmt"
 "day02/eg1" /* 引入包 */
)

func main() {
 add.Sum(2,3) /* 调用包 */
 fmt.Println("Hello, World!")
}

  3. 在引入包之后紧接着是透过 const 关键字来举办常量的概念          ps: const PI = 3.14

图示:

  4. 在函数体外部通过采纳 var 关键字来进行全局变量的扬言和赋值        ps: var name = "liang"

图片 3

  5. 由此 type 关键字展开布局struct 或 接口interface 的宣示          ps: type Manager struct {}  或  type formatter interface {}

二、变量

  6. 通过 func 关键字来进行函数的申明                     ps: func main(卡塔尔 {}

1.单个变量的宣示

依据上述顺序规范,编写的演示代码如下所示:

go语言中,全数变量都一定要先评释在采取,下边是声称变量和赋值方法:

// 当前程序的包名
package main

/**
 导入其他的包
 */
import (
    std "fmt"
)

// 常量定义
const PI = 3.14

// 全局变量的声明和赋值
var name = "liang"

// 一般类型声明
type newType int

// 结构声明
type Manager struct {
}

// 接口声明
type formatter interface {
}

// 由 main 函数作为程序入口点启动
func main() {
    std.Println("Hello World ! MyName is : " + name)
}
  • 先证明后赋值: var <变量名称> <变量类型>         赋值:变量的赋值格式: <变量名称> = <表明式>
  • 声称的还要赋值:var <变量名称> <变量类型> = <表达式>   (简写为 变量名称 :=  表达式)

 6. package 使用

示例:

1. 健康引用

package main

import "fmt"
func main() {

 var a string /* 声明一个变量名为a,类型为字符串的变量 */
 a = "wd" /* 对a变量赋值*/
 var age int = 22 /* 声明并赋值变量 */
 fmt.Println(a,age)
}
import "fmt"

2.多少个变量申明

 在这里时期也足以采用小名,别称的要紧功效正是当使用第三方包时,包名可能会非常临近或然同后生可畏,那时候就可以利用小名来拓宽区分和调用,举个例子:

  • 先注脚后赋值:var <变量1>,<变量2>,<变量3>  <变量类型>     赋值 : <变量1>,<变量2> =  值1,值2
  • 宣称同不日常间赋值 :var  <变量1>,<变量2> = 值1,值2   可简写为: <变量1>,<变量2> = 值1,值2
  • 几个变量还足以行使var(卡塔尔表明
import std "fmt"
// 使用时可以通过别名直接调用
std.Println("Hello World!")

示例:

2. 批量引进

package main

import "fmt"
func main() {

 var a,b int
 a,b = 1,2
 var c,d = 3,"wd" /* 类型自动推断 */
 e, f := 4, "hello" /* 简写 */
 fmt.Println(a,b,c,d,e,f)
}
import (
    std "fmt"
    "io"
    str "strings"      
)

使用var()声明

此间能够引伸一下,既然导入三个包时能够举行简写,那么表明多少个常量、全局变量 或 平时品种(非接口、非组织)是还是不是也能够用同朝气蓬勃的格局吧?

package main

import "fmt"

func main() {
 var (
 a int //默认值为0
 b string // 默认值为空字符串("")
 c = 3 
 )
 fmt.Println(a,b,c)
}

答案是一定的,具体可以预知下边包车型客车案例:

3.变量名

// 批量常量定义
const (
    PI = 3.14
    CONSTA = "str"
    CONSTB = 1
    CONSTC = 2
)

// 批量全局变量的声明
var (
    name = "liang"
    name1 = "abc"
    name2 = 3
)

// 批量一般类型声明
type (
    newType int
    type_a float32
    type_b string
    type_c byte
)

命名准绳:

3. 省略调用

  • 首字符能够是随便的Unicode字符或许下划线
  • 剩余字符可以是Unicode字符、下划线、数字
  • 不可能作为用以下重点字作为变量名

注意:

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

  1. 不建议使用,易混淆

4.可见性

  2. 不得以和小名同有时候接受

可以知道性即对包外可知,当其余包调用当下包的变量时候是还是不是同意可以知道(可访谈)。

import (
    . "fmt"
)

func main() {
    // 使用省略调用
    Println("Hello World!")  
}
  • 变量起头字符大写,表示可知
  • 变量伊始字母非大写,则象征私有,不可以知道

4. _ 操作

 5.变量的功用域

  以此操作平常是让众多少人费解的二个操作符,请看上面这么些import

  • 函数钦赐义的变量称为局地变量,其功效域在函数内
  • 函数外定义的变量称为全局变量,成效于任何包,何况该变量首字母大写,则对别的包可以见到。
import(
    "database/sql"
    _ "github.com/ziutek/mymysql/godrv"
)

三、常量

  _  操作符其实是引进该包,而不直接采纳包里面包车型客车函数,而是调用了该包里面的init 函数

常量是三个轻巧值的标记符,在程序运维时,不会被改变的量。

7. 可以预知性法规

常量中的数据类型只可以够是布尔型、数字型(整数型、浮点型和复数)和字符串型。

  Go 语言中,使用 大小写 来决定该 常量、变量、类型、接口、接口 或 函数 是或不是足以被外表包所调用

概念常量语法:

  依据预订:

const 名称 类型 = value

  1. 函数名 首字母 小写 即为 private