关于golang:Go-Lang

1 Go 的根底组成有以下几局部

  • 包申明
  • 引入包
  • 函数
  • 变量
  • 语句&表达式
  • 正文
package main

import "fmt"

func main(){
 /**/
   fmt.Println("hello,world!")
}
  • 每个 Go 应用程序都蕴含一个名为 main 的包
  • fmt 包实现了格式化 IO(输出/输入)的函数
  • 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须蕴含的,一般来说都是在启动后第一个执行的函数(如果有 init() 函数则会先执行该函数)。
  • 当标识符(包含常量、变量、类型、函数名、构造字段等等)以一个大写字母结尾,如:Group1,那么应用这种模式的标识符的对象就能够被内部包的代码所应用(客户端程序须要先导入这个包),这被称为导出(像面向对象语言中的 public);标识符如果以小写字母结尾,则对包外是不可见的,然而他们在整个包的外部是可见并且可用的(像面向对象语言中的 protected )
  • 须要留神的是 { 不能独自放在一行,所以以下代码在运行时会产生谬误:

···
文件名与包名没有间接关系,不肯定要将文件名与包名定成同一个。
文件夹名与包名没有间接关系,并非须要统一。
同一个文件夹下的文件只能有一个包名,否则编译报错。
···

Go 语法根底

Go 程序能够由多个标记组成,能够是关键字,标识符,常量,字符串,符号。如以下 GO 语句由 6 个标记组成:

数据类型

Go语言变量

申明变量的个别模式是应用 var 关键字:

var identifier type
package main

import "fmt"
function main(){
    var a string = "Runoob"
    fmt.Println(a)
    
    var b,c int = 1,2
    fmt.Println(b,c)

变量申明

  • 第一种,指定变量类型,如果没有初始化,则变量默认为零值
  • 第二种,依据值自行判断变狼类型
  • 第三种,省略var,留神:=左侧如果没有申明新的变量,就产生编译谬误
intVal := 1 // 此时不会产生编译谬误,因为有申明新的变量,因为 := 是一个申明语句

相当于

var intVal int 
intVal =1 

多变量申明

//类型雷同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不须要显示申明类型,主动推断

vname1, vname2, vname3 := v1, v2, v3 // 呈现在 := 左侧的变量不应该是曾经被申明过的,否则会导致编译谬误


// 这种因式分解关键字的写法个别用于申明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

值类型和援用类型

Go语言常量

const identifier [type] = value

多个雷同类型的申明能够简写为:

const c_name1, c_name2 = value1, value2

常量还能够用作枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota

iota,非凡常量,能够认为是一个能够被编译器批改的常量。

iota 在 const关键字呈现时将被重置为 0(const 外部的第一行之前),const 中每新增一行常量申明将使 iota 计数一次(iota 可了解为 const 语句块中的行索引)。

iota 能够被用作枚举值:

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

import "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)
}
package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}


以上实例运行后果为
i= 1
j= 6
k= 12
l= 24

Go 语言运算符

其余运算符

Go 语言条件语句

switch

switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是惟一的,从上至下逐个测试,直到匹配为止。

switch 语句执行的过程从上至下,直到找到匹配项,匹配项前面也不须要再加 break。

switch 默认状况下 case 最初自带 break 语句,匹配胜利后就不会执行其余 case,如果咱们须要执行前面的 case,能够应用 fallthrough

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

Go语言循环

for 循环

for init; condition; post{}
for condition{}
for{}

for 循环的range格局能够对slice、map、数组、字符串等进行迭代循环

for key,value := range oldMap{
    newMap[key] = vaule
}
package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

Go 语言函数

func function_name( [parameter list] ) [return_types] {
   函数体
}

返回多个值

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

函数参数

默认状况下, Go语言应用的事值传递,即再调用过程中不会影响到理论参数

函数用法

  • 函数作为另外一个函数的实参

    package main
    
    import (
      "fmt"
      "math
    )
    
    func main(){
      getSquareRoot := func(x float64) float64{
        return math.Sqrt(x)
      }
      
      fmt.Println(getSquareRoot(9))
    }
  • 闭包
    Go 语言反对匿名函数,可作为闭包。 匿名函数是一个”内联“语句或表达式。匿名函数的优越性在于能够间接应用函数外部的变量,不用申明。
package main

import "fmt"

func getSequence() func() int {
  i:=0
  
  return func() int {
    i+=1
    return i
  }
}

func main(){
  nextNumber := getSequence()
  
  fmt.Println(nextNumber())
  fmt.Println(nextNumber())
  fmt.Println(nextNumber())
  
  nextNumber1 := getSequence()
  fmt.Println(nextNumber1())
  fmt.Println(nextNumber1())
  • 办法

Go语言变量作用域

作用域为以生命标识符所示意的常量、类型、变量、函数或包再源代码中的作用范畴。

int -> 0
float32 -> 0
pointer -> nil

Go语言数组

申明数组

var variable_name [size] variable_type
var balance [10] float32

初始化数组

var balance = [5]float32{100.0,2.0.3.4,7.0,50.0}
balance := [5]float32{1000.0,2.0,3.4,6.0,50.0}

如果数组长度不确定,能够应用 … 代替数组的长度,编译器会依据元素个数自行推断数组的长度:

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度,咱们还能够通过指定下标来初始化元素:

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

多维数组

var variable_name [size1][size2]...[sizeN] variable_type
var threadim [5][10][4]int

初始化二维数组

a := [3][4]int{
 {0,1,2,3},
 {4,5,6,7},
 {8,9,10,11},
}

留神:以上代码中倒数第二行的 } 必须要有逗号,因为最初一行的 } 不能独自一行,也能够写成这样:

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}}   /* 第三行索引为 2 */

向函数传递数组

形式一
设置形参大小

void myFunction(param [10]int)
{
...
}

形式二
未设置数组大小

void myFunction(param []int)
{
...
}

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

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

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据