go语言基础知识

最新推荐文章于 2023-10-26 21:19:42 发布
最新推荐文章于 2023-10-26 21:19:42 发布
阅读量207 收藏
点赞数
文章标签： 数据结构与算法 操作系统 c/c++
原文链接：http://www.cnblogs.com/wudiffs/p/11576650.html
版权

一、一个简单的Go程序

下面这个程序是一个http请求，输出返回的body字段。panic会立即中断函数流程，执行延时调用。从下面这个程序可以看出通过go访问http非常简洁。

package main

import (
    "net/http"
    "io/ioutil"
    "fmt"
)

func main() {

    r, err := http.Get("http://httpbin.org/anything?hello=world")
    if err != nil {
        panic(err)
    }
    defer r.Body.Close()

    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }
    fmt.Printf("body = %s\n", string(body))
    
}

二、Go语言数据类型

  • uint 32位或64位
  • uint8 无符号 8 位整型 (0 到 255)
  • uint16 无符号 16 位整型 (0 到 65535)
  • uint32 无符号 32 位整型 (0 到 4294967295)
  • uint64 无符号 64 位整型 (0 到 18446744073709551615)
  • int 32位或64位
  • int8 有符号 8 位整型 (-128 到 127)
  • int16 有符号 16 位整型 (-32768 到 32767)
  • int32 有符号 32 位整型 (-2147483648 到 2147483647)
  • int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
  • byte uint8的别名(type byte = uint8)
  • rune int32的别名(type rune = int32)，表示一个unicode码
  • uintptr "无符号整型，用于存放一个指针是一种无符号的整数类型，没有指定具体的bit大小但是足以容纳指针。uintptr类型只有在底层编程是才需要，特别是Go语言和C语言函数库或操作系统接口相交互的地方。"
  • float32 IEEE-754 32位浮点型数
  • float64 IEEE-754 64位浮点型数
  • complex64 32 位实数和虚数
  • complex128 64 位实数和虚数
  • string 字符串，默认值是空字符串，而非NULL
  • array 数组
  • struct 结构体，类似java里面的对象
  • function 函数，默认值nil
  • interface 接口，默认值nil
  • map 字典，引用类型，默认值nil
  • slice 切片，动态的数组，引用类型，默认值nil
  • channel 通道，引用类型，默认值nil

三、 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

四、Go语言预定标识符

  • append bool byte cap close complex
  • complex64 complex128 uint16 copy FALSE float32
  • float64 imag int int8 int16 uint32
  • int32 int64 iota len make new
  • nil panic uint64 print println real
  • recover string TRUE uint uint8 uintprt

五、Go语言变量

package main

import "fmt"

func main() {
    // 使用var定义变量，支持类型推断
    var x int32
    var s = "hello,world"
    fmt.Println(x, s)

    // 在函数内部，可以省略var关键字
    y := 100
    fmt.Println(y)

    // 编译器将未使用的局部变量定义当作错误
    //z := 200
}

六、Go语言--表达式

package main

import "fmt"

func main() {

    x := 100
    if x > 0 {
        fmt.Println("x")
    } else if x < 0 {
        fmt.Println("-x")
    } else {
        fmt.Println("0")
    }

    switch {
    case x > 0:
        fmt.Println("x")
    case x < 0:
        fmt.Println("-x")
    default:
        fmt.Println("0")
    }

    for i:=0; i <5; i++ {
        fmt.Println(i)
    }

    // 相当于while (x < 5) { ... }
    for x < 5 {
        fmt.Println(x)
        x++
    }
    // 相当于while (true) { ... }
    for {
        fmt.Println(x)
        x--
        if x < 0 {
            break
        }
    }
    // 迭代遍历，除返回元素外，还返回索引
    s := []int{100, 200, 300}
    for i, n := range s {
        fmt.Println(i, n)
    }
}

七、Go语言--函数

package main

import (
    "errors"
    "fmt"
)

// 定义多个变量接受，多返回值
func div(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// 函数作为第一类型，可作为参数或返回值
func test(x int) func() {
    // 匿名函数
    return func() {
        fmt.Println(x)


    }
}

func main() {
    a , b := 10, 2
    c, err := div(a, b)
    fmt.Println(c, err)

    x := 100
    f := test(x)
    f()
}

八、Go语言--slice

切片是有三个字段的数据结构，指向底层数组的指针，切片访问元素的个数（长度），切片允许增长到的元素的个数（容量）,这种数据结构便于使用和管理数据集。切片围绕动态数组的概念构建的，可以按需自动增长和缩小。切片是一个很小的对象，对底层数组进行了抽象，并提供相关的操作方法，切片的底层内存是在连续块中分配的。

package main

import "fmt"

func main() {
    // 创建一个整型切片，其长度为3，容量为5
    s := make([]int, 3, 5)
    for i := 0; i < 3; i++ {
        s[i] = i
    }
    // 创建一个整型切片,其长度和容量都是5
    slice := []int{10, 20, 30, 40, 50}
    // 创建一个新切片，其长度为2，容量为4
    newslice := slice[1:3]
    // 使用原有的容量来分配一个新元素
    // 如果切片的底层数组没有足够的容量，append会创建一个新的底层数组，这个数组容量是原来的两倍
    newslice = append(newslice, 60)
    // 5 5
    fmt.Println(cap(slice), len(slice))
    // 4 3
    fmt.Println(cap(newslice), len(newslice))
    // 迭代切片,第一个值当前迭代索引位置，第二个该元素对应值的一份副本
    for index, value := range newslice {
        fmt.Printf("index:%d value:%d\n", index, value)
    }
}

1406089-20190924100013099-1024693507.png

九、Go语言--map

map(映射)是一种数据结构，用于存储一系列无序的键值对。

package main

import "fmt"

func main() {

    // 创建一个映射，键的类型是string，值的类型是int
    dict := make(map[string]int)
    // map[]
    fmt.Println(dict)
    // 创建一个映射，键和值的类型都是string，使用两个键值对初始化映射
    colors := map[string]string{"red":"red","blue":"blue"}
    // map[red:red blue:blue]
    fmt.Println(colors)
    // 从映射获取值并判断键是否存在
    value, exits := colors["blue"]
    if exits {
        // blue
        fmt.Println(value)
    }
    //删除键为blue的键值对
    delete(colors, "blue")
    // 使用range迭代映射
    for key, value := range colors {
        // key:red value:red
        fmt.Printf("key:%s value:%s\n", key, value)
    }
}

十、Go语言--结构体

结构类型可以用来描述一组数据值，这组值的本质既可以是原始的，也可以是非原始的。

package main

import "fmt"
// 结构体类型
type user struct {
    name string
    age byte
}

type manager struct {
    // 匿名嵌入其他类型
    user
    title string
}

func main() {
    var m manager
    // 直接访问匿名字段成员
    m.name = "james"
    m.age = 34
    m.title = "CTO"
    fmt.Println(m)
}

十一、Go语言--指针

package main

// 内存地址是内存中每个字节单元的唯一编号
// 指针是一个实体，指针会分配内存空间，相当于一个专门用来保存地址的整型变量
func main() {
    x := 10
    // 获取地址保存到指针变量
    var p *int = &x
    // 用指针间接引用，并更新对象
    *p +=10
    // 0xc00002bf70 20
    println(&x, x)
    // 0xc00002bf70 20 0xc00002bf80
    println(p, *p, &p)
    
}

十二、Go语言--方法

package main

import "fmt"

type student struct {
    name string
    age byte
}
// 方法能给用户定义的类型添加新的行为，方法实际上也是函数
// 只是在声明时，在func和方法名之间增加一个参数,成为recevier
func (s student) toString() string {
    return fmt.Sprintf("%+v", s)
}

func main() {
    s := student{"james", 34}
    fmt.Println(s.toString())
}

十三、Go语言--接口

接口是用来定义行为的类型，这些被定义的行为不由接口直接实现，而是通过方法由用户定义的类型实现。
Go接口实现机制很简洁，只要目标类型方法包含接口声明的全部方法，就被视为实现了该接口，无需做显示声明。当然，目标类可以实现多个接口。
如果接口没有任何方法声明，那么就是一个空接口（interface{}），它的用途类似Object，可被赋值为任何类型的对象。

package main

import "fmt"

// 定义tester接口，定义两个方法
type tester interface {
    test()
    string() string
}
// 顶一个结构体data，实现接口tester
type data struct {}

func (d *data) test() {}

func (d data) string() string {
    return "I Love China"
}
func main() {

    var d data
    // data没有实现tester，test()是指针接收者声明
    var t tester = &d
    t.test()
    fmt.Println(t.string())
}

go多态的例子:

package main

import "fmt"

// notifer是一个定义了通知类行为的接口
type notifer interface {
    notify()
}
// user定义了一个用户类型
type user struct {
    name string
    email string
}
// notify使用指针接收者实现了notifier的接口
func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n", u.name, u.email)
}
// admin定义了程序的管理员
type admin struct {
    name string
    email string
}
// notify使用指针接收者实现了notifier的接口
func (a *admin) notify() {
    fmt.Printf("Sending user email to %s<%s>\n", a.name, a.email)
}
// sendNotification接受了一个实现notifer的值，并发送通知
func sendNotification(n notifer) {
    n.notify()
}
func main() {
    jack := user{"jack","jack@jd.com"}
    // 创建一个user值并传给sendNotification
    sendNotification(&jack)
    rose := admin{"rose", "rose@jd.com"}
    // 创建一个admin值并传给sendNotification
    sendNotification(&rose)
    
}

转载于:https://www.cnblogs.com/wudiffs/p/11576650.html

z-pan
关注
Go语言基础知识
yx5666的博客
04-16 472
Go语言基础知识
Go语言 基础知识汇总大全
最新发布
08-21
1.基础知识 基本类型 复合类型 流程控制Switch 2.函数 函数定义 函数类型 匿名函数 defer 闭包 错误处理 panic和recover error错误类型 go 汇编 3.类型系统 类型简介 声明类型 结构体类型 函数类型 类型组合和方法集...
go语言 基础知识 思维导图
07-12
go语言 基础知识 思维导图
GO语言（golang）基础知识
01-21
今天说一些golang的基础知识，还有你们学习会遇到的问题，先讲解hello word 代码如下: package main import “fmt” func main() {  fmt.Println(“你好，软件开发网”); } package name 包机制，每一个独立的go...
GO语言基础知识一
03-26 487
1.go语言关键字 2.go语言预定义的标识符 3.常量与变量
go语言--基础知识
deapou的博客
02-23 406
基础知识 语言特点： 兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性 不但能让你访问底层操作系统，还提供了强大的网络编程和并发编程支持 通过接口（interface）的概念来实现多态性 Go语言正是在多核和网络化的时代背景下诞生的原生支持并发的编程语言。 go擅长： 鉴于Go语言的特点和设计的初衷，从以下几个方面来分析Go语言擅长的领域： 在服务器编程方面...
【Go入门】Go语言基础知识
weixin_44211968的博客
11-08 6546
Go语言中那些有趣的语法
Go语言基础知识点分享
北桥源木
04-22 214
最近在加深对GO语言基础知识学习，巩固下基础，同时分享给朋友们 go中单元测试 通过 go test 进行测试 go 中给我们提供一个包：testing,Go 为我们提供一些很好的功能，我们可以在不需要太多学习的情况下使用它们。 若要在 Go 中开始使用测试，首先需要定义要测试的包。如果还没有，请创建一个名为 testing101 的包，并创建文件 sum.go，添加上下面的代码： p...
Go语言基础知识（一）简单入门
HJ
10-28 518
package main //第一行 定义了包名 必须在源文件中非注释的第一行指明这个文件属于哪个包; //注意：每个Go应用程序都包含一个名为main的包 import "fmt" //告诉Go编译器这个程序需要使用fmt包（的函数，或其他元素），其中fmt包实现了格式化IO的函数 /* func main()是程序开始执行的函数，main函数是每一个可执行程序所必须包含的; ...
GO语言基础
~
10-26 290
Go 对于值之间的比较有非常严格的限制，只有两个类型相同的值才可以进行比较，如果值的类型是接口，它们也必须都实现了相同的接口。map是一种特殊的数据结构：一种元素对 (pair) 的无序集合，pair 的一个元素是 key，对应的另一个元素是 value，所以这个结构也称为关联数组或字典。make也是用于内存分配的，但是和new不同，它只用于chan、 map以及切片的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。
Go语言基础知识（二）基本知识梳理
HJ
11-04 432
Go简单介绍（补充） Go是编译型语言，Go的工具链将程序的源文件转变成机器相关的原生二进制指令，这些工具可以通过单一的go命令配合其子命令进行使用，Go原生支持Unicode，所以它可以处理所有国家的语言； 包的认识（补充） fmt 包 其中的函数用来格式化输出和扫描输入，gofmt工具将代码以标准格式重写； os包 提供一些函数和变量，以与平台的方式和操作系统打交道； （接上） ...
go语言基础知识6
jgn_123的博客
04-03 364
Go 语言函数 unc：函数由 func 开始声明 function_name：函数名称，函数名和参数列表一起构成了函数签名。 parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。 return_types：返回类型，函数返回一列值。retur...
Go语言运算符
weixin_34342905的博客
04-29 181
算数运算符 下表列出了所有Go语言的算术运算符。假定 A 值为 10，B 值为 20。 运算符 描述 实例 + 相加 A + B 输出结果 30 - 相减 A - B 输出结果 -10 * 相乘 A * B 输出结果 200 / 相除 B / A 输出结果 2 % 求余 B % A 输出结果 0 ++ 自增 A++ 输出结果 11 -- 自减 A-- 输出结...
Golang语言基础知识点总结
weixin_58439331的博客
01-29 1374
Golang语言基础知识点小总结 1.go语言有两大类型： 值类型：数值类型，bool，string，数组，struct结构体 变量直接存储值，内存通常在栈中分配, 修改值, 不会对源对象产生影响 引用类型：指针，slice切片，管道chan，map，interface 变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收，同时，当地址指向的数据值改变时，会对源对象产生影响。 2.变量的定义： 局部变
Go语言基础知识：关键字与编程规则详解
Go语言，也称为Golang，是由Google开发的一种静态类型、编译型、并发型且具有垃圾回收功能的编程语言。本资料详细阐述了Go语言的基础语法和核心概念，适合初学者入门及进阶学习。 首先，Go语言有25个关键字，包括`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值