zoukankan      html  css  js  c++  java
  • Golang基础

    Go语言基础

    关键字

    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

    定义变量

    • var variablename type = value

    • var vname1, vname2, vname3 type = v1, v2, v3

    • 可以忽略类型声明,Go会根据相应值得类型来初始化:var vname1, vname2, vname3 = v1, v2, v3

    • 继续简化:vname1, vname2, vname3 := v1, v2, v3, :=取代了vartype,这种形式叫做简短声明。不过它有一个限制,只能用在函数内部;在函数外部使用则会无法编译通过,所以一般用var定义全局变量

    • _下划线是一个特殊的变量名,任何赋予它的值都会被丢弃:_, b := 1, 2

    • Go对已声明但未使用的变量会在编译阶段报错

        package main
      
        func main() {
            var i int //报错,声明了i但未使用
        }
      

    常量

    • 常量可以定义为数值、布尔值或字符串等类型

        const constantName = value  
        //如果需要也可以明确指定常量的类型  
        const Pi float32 = 3.1415926
      

    内置基础类型

    • Boolean

        var isActive bool //全局变量
        var enable, disable = true, false //忽略类型的声明  
        func test() {
            var available bool //一般声明
            valid := false //简短声明
            vaailable = true //赋值操作
        }
      
    • 数值类型

    1. 整数类型有无符号和带符号两种。有符号:rune, int8, int16, int32, int64;无符号:byte, uint8, uint16, uint32, uint64。其中runeint32的别称,byteuint8的别称

    2. 浮点数的类型有float32float64两种,默认是float64

    3. 复数,默认类型为complex128(64位实数 + 64位虚数),complex64(32位实数 + 32位虚数);复数形式:RE + IMi

       var c complex64 = 5 + 5i
      
    4. 这些类型的变量之间不允许互相赋值或操作,不然会在编译时引起编译器报错

    • 字符串
    1. 声明

       var sName string //声明变量为字符串的一般方法
       var sName1 string = "" //声明一个字符串变量,并赋值为空
       func test() {
           a, b, c := "no", "yes", "maybe"//简短声明
       }
      
    2. Go中字符串是不可改变的

       var s string = "hello"
       s[0] = "c" //cannot assign to s[0]
      
    3. 如何改变字符串

       s := "hello"
       c := []byte(s) //将字符串 s 转换为 []byte 类型
       c[0] = "c"
       s2 := string(c) //再转换为 string 类型
       fmt.Printf("%s
      ", s2)
      
    4. 字符串连接+

    5. 字符串切片s[start: end]

    6. 声明多行的字符串

       m := `hello
               world`
      
    • 分组声明

        import(
            "fmt"
            "os"
        )
        const(
            i = 100
            pi = 3.1415
            s = "hello"
        )
        var(
            i int
            pi float32
            s string
        )
      
    • iota枚举,这个关键字用来声明enum时使用,默认开始值为0const中每增加一行加1

        package main
      
        import (
            "fmt"
        )
      
        const (
            x = iota // x == 0
            y = iota // y == 1
            z = iota // z == 2
            w //常量声明省略值时,默认和之前一个值的字面意思相同。这里隐式表达`w = iota`,因此`w == 3`。
        )
      
        const v = iota //每遇到一个const关键字,iota就会重置,此时v == 0
      
        const (
            h, j, k = iota, iota, iota //h==0, j == 0, k == 0 iota在同一行
        )
      
        const (
            a = iota // a == 0
            b = "hi"
            c = iota // c == 2
            d, e, f := iota, iota, iota // d == 3, e == 3, f == 3
            g = iota // g == 4
        )
      
    • 数组

    1. 声明

       var arr [n]type //n-->length, type-->存储元素的类型
       a := [3]int{1, 2, 3} //声明一个长度为3的int数组
       b := [10]int{1, 2, 3} //声明一个长度为10的int数组,其中前三个元素赋值1、2、3,其他默认为0
       c := [...]int{4,5,6} //省略长度,go会根据元素个数来计算长度
       twoDarr := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}} //声明二维数组
       simple := [2][4]int{{1,2,3,4},{5,6,7,8}} //简化声明,忽略内部类型
      
    • slice
    1. 在很多应用场景中,数组并不能满足我们的需求。在初始定义数组时,我们并不知道需要多大的数组,因此我们需要“动态数组”。在GO里面这种数据结构叫slice

    2. slice并不是真正意义上的动态数组,而是一个引用类型。slice总是指向一个底层arrayslice的声明也可以像array一样,只是不需要长度

       var fslice []int //和声明数组一样,只是少了长度  
       //声明一个slice,并初始化数据
       slice := []byte{"a", "b", "c", "d"}
       //slice可以从一个数组或一个已经存在的slice中再次声明
       var arr = [6]byte{"a", "b", "c", "d", "e", "f"}
       var a, b []byte
       a = arr[1:3]
       b = arr[3:]
      
    3. slice内置函数
      len获取slice长度
      cap获取slice容量
      appendslice里面追加一个或多个元素,然后返回一个和slice一样类型的slice
      copy函数复制从源slicesrc中复制元素到目标dst,并且返回复制的元素的个数
      append函数会改变slice所引用的数组的内容,从而影响到引用同一数组的其他slice

       //三参数的slice
       var arr [10]int
       slice := arr[2:4] //slice的容量为10-2=8
       newSlice := arr[2:4:7] //slice的容量为7-2=5,无法访问最后的三个元素
      
    • map格式为map[keyType]valueType,和python中字典的概念类似

        //声明一个key是字符串,值为int的字典,这种方式的声明需要在使用之前使用make初始化
        var number map[string]int
        //另一种map的声明方式
        numbers = make(map[string]int)
        numbers["one"] = 1 //赋值
      
    1. map是无序的,每次打印出来的map都会不一样,必须通过key获取
    2. 长度不固定,是一种引用类型,如果两个map同时指向一个底层,那么一个改变,另一个也相应改变
    3. 内置的len函数同样适用于map,返回map拥有的key的数量
    4. 可以通过delete删除map的元素
    • makenew操作
      make用于内建类型(map,slice,channel)的内存分配。new用于各种类型的内存分配
  • 相关阅读:
    java版二维码实例(非安卓版)
    Java—SSH(MVC)
    关于flex里面mousedown 和click事件冲突问题的解决办法
    navicat ssh通道受限问题处理
    如何更改linux文件目录拥有者及用户组
    如何查看linux中的ssh端口开启状态
    centos linux mysql 10060远程错误代码
    Navicat for MySQL 使用SSH方式链接远程数据库(二)
    Petri Net 的形式化定义
    如何做鲫鱼豆腐汤
  • 原文地址:https://www.cnblogs.com/yfife/p/9012898.html
Copyright © 2011-2022 走看看