GO语言获取系统蒙受变量的法门

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

本文主要讲解Go语言中的函数式编程概念和使用,分享给大家,具体如下:

1. map

本文实例讲述了GO语言获取系统环境变量的方法。分享给大家供大家参考。具体实现方法如下:

主要知识点:

  1. 类似其它语言中的哈希表活着字典,以 key-value 形式存储数据

复制代码 代码如下:

  1. Go语言对函数式编程的支持主要体现在闭包上面
  2. 闭包就是能够读取其他函数内部变量的函数。只有函数内部的子函数才能读取局部变量,所以闭包可以理解成“定义在一个函数内部的函数“。在本质上,闭包是将函数内部和函数外部连接起来的桥梁。
  3. 学习闭包的基本使用
  4. 标准的闭包具有不可变性:不能有状态,只能有常量和函数,而且函数只能有一个参数,但是一般可以不用严格遵守
  5. 使用闭包 实现 斐波那契数列
  6. 学习理解函数实现接口
  7. 使用函数遍历二叉树

  2. key 必须是支持 == 或 != 比较运算的类型,不可以是函数、map 或 slice

package main
import (
 "fmt"
 "os"  //我们要用到os包中的env
)
func main() {
 //os.Getenv检索环境变量并返回值,如果变量是不存在的,这将是空的。
 HOME:= os.Getenv("HOME")
 fmt.Println(HOME)
 fmt.Printf(os.Getenv("JAVA_HOME"))
}

具体代码示例如下:

  3. map 查找比线性搜索快很多,但比使用索引访问数据的类型慢100倍

希望本文所述对大家的Go语言程序设计有所帮助。

package main

import (
 "fmt"
 "io"
 "strings"
 "bufio"
)

//普通闭包
func adder() func(int) int {
 sum := 0
 return func(v int) int {
 sum += v
 return sum
 }
}

//无状态 无变量的闭包
type iAdder func(int) (int, iAdder)
func adder2(base int) iAdder {
 return func(v int) (int, iAdder) {
 return base + v, adder2(base + v)
 }
}

//使用闭包实现 斐波那契数列
func Fibonacci() func() int {
 a, b := 0, 1
 return func() int {
 a, b = b, a+b
 return a
 }
}

//为函数 实现 接口,将上面的方法 当作一个文件进行读取
type intGen func() int
//为所有上面这种类型的函数 实现接口
func (g intGen) Read(
 p []byte) (n int, err error) {
 next := g()
 if next > 10000 {
 return 0, io.EOF
 }
 s := fmt.Sprintf("%dn", next)

 // TODO: incorrect if p is too small!
 return strings.NewReader(s).Read(p)
}
//通过 Reader读取文件
func printFileContents(reader io.Reader) {
 scanner := bufio.NewScanner(reader)
 for scanner.Scan() {
 fmt.Println(scanner.Text())
 }
}

func main() {
 //普通闭包调用
 a := adder()
 for i := 0; i < 10; i++ {
 var s int =a(i)
 fmt.Printf("0 +...+ %d = %dn",i, s)
 }
 //状态 无变量的闭包 调用
 b := adder2(0)
 for i := 0; i < 10; i++ {
 var s int
 s, b = b(i)
 fmt.Printf("0 +...+ %d = %dn",i, s)
 }

 //调用 斐波那契数列 生成
 fib:=Fibonacci()
 fmt.Println(fib(),fib(),fib(),fib(),fib(),fib(),fib(),fib())


 var f intGen = Fibonacci()
 printFileContents(f)
}

  4. map使用 make() 创建,支持 := 这种简写方式

您可能感兴趣的文章:

  • GO语io包的常用接口
  • Go语言的os包中常用函数初步归纳
  • 举例讲解Go语言中函数的闭包使用
  • 深入理解Go语言中的闭包
  • go语言里包的用法实例
  • Go语言声明一个多行字符串的变量
  • Go语言基础知识总结(语法、变量、数值类型、表达式、控制结构等)
  • Go语言中的变量声明和赋值
  • 详解Golang编程中的常量与变量
  • go语言学习之包和变量详解

以下代码演示函数遍历二叉树:

  5. make([keyType]valueType, cap),cap表示容量,可省略。超出容量时会自动扩容,但尽量提供一个合理的初始值  make([int]string, 10)

package main
import "fmt"
type Node struct {
 Value  int
 Left, Right *Node
}

func (node Node) Print() {
 fmt.Print(node.Value, " ")
}

func (node *Node) SetValue(value int) {
 if node == nil {
 fmt.Println("Setting Value to nil " +
 "node. Ignored.")
 return
 }
 node.Value = value
}

func CreateNode(value int) *Node {
 return &Node{Value: value}
}

//为 TraverseFunc 方法提供 实现
func (node *Node) Traverse() {
 node.TraverseFunc(func(n *Node) {
 n.Print()
 })
 fmt.Println()
}
//为 Node 结构增加一个方法 TraverseFunc ,
//此方法 传入一个方法参数,在遍历是执行
func (node *Node) TraverseFunc(f func(*Node)) {
 if node == nil {
 return
 }
 node.Left.TraverseFunc(f)
 f(node)
 node.Right.TraverseFunc(f)
}


func main() {
 var root Node
 root = Node{Value: 3}
 root.Left = &Node{}
 root.Right = &Node{5, nil, nil}
 root.Right.Left = new(Node)
 root.Left.Right = CreateNode(2)
 root.Right.Left.SetValue(4)
 root.Traverse() // 进行了 打印封装

 //以下通过匿名函数,实现了 自定义实现
 nodeCount := 0
 root.TraverseFunc(func(node *Node) {
 nodeCount++
 })
 fmt.Println("Node count:", nodeCount) //Node count: 5
}

  6. 使用 len() 获取元素个数

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

  7. 键值对儿不存在时自动添加,使用 delete() 删除某键值对儿,使用 for range 对 map 和 slice 进行迭代操作

您可能感兴趣的文章:

  • 深入解析golang编程中函数的用法
  • 利用GO语言实现多人聊天室实例教程
  • 使用Go语言实现配置文件热加载功能
  • Go语言中slice作为参数传递时遇到的一些“坑”
  • Go语言实现自动填写古诗词实例代码
  • Go语言中你不知道的Interface详解
  • 在Go语言中使用JSON的方法
  • Go语言 channel如何实现归并排序中的merge函数详解
package main

import (
    "fmt"
)

func main() {
    // map正常初始化
    m := make(map[string]string)
    m["k1"] = "a"
    m["k2"] = "b"

    fmt.Println("map:", m)

    v1 := m["k1"]    // map中获取数据
    fmt.Println("get map k1:", v1)

    fmt.Println("map len:", len(m)) // 取得map对长度

    delete(m, "k2") // 删除map中指定对key值
    fmt.Println("deleted map:", m)

    _, prs := m["k2"] // map通过key取对应对value会返回多值,其中第一个为value值,第二个为状态码(有值返回tru,无值为false)
    fmt.Println("prs:", prs)

    // map初始化的时候进行赋值
    n := map[string]int{"foo":1, "bar":2}
    fmt.Println("map:", n)
}

以上代码运行结果如下所示:

map: map[k1:a k2:b]
get map k1: a
map len: 2
deleted map: map[k1:a]
prs: false
map: map[foo:1 bar:2]

2. 使用 range 遍历 slice 和 map

使用for range 对 slice 和 map进行遍历举例

 1 package main
 2 
 3 import "fmt"
 4 
 5 // for ... range 类似与其他语言中对foreach
 6 func main() {
 7     // 对切片的循环遍历
 8     s := []int{1, 3, 5}
 9     fmt.Println("loop slice begin:=================")
10     // i为切片的下标值,v为对应的值。其中v是对应slice的副本值,对它的修改不会影响原始内容,要想修改原始内容通过指定下标进行覆盖:s[1] = 9
11     for i, v := range s {
12         fmt.Println(i, v)
13     }
14 
15     // 对map对循环遍历
16     m := map[string]string{"a" : "liang", "b" : "xuli", "c" : "liguang"}
17     fmt.Println("loop map begin:===================")
18     for k, v := range m {  // k为map对key值,v为对应对value值。其中都为map对拷贝,改变它们对值不会对原始内容造成影响
19         fmt.Println(k, v)
20     }
21 
22     // 对slice-map进行循环遍历(终极版)
23     sm := make([]map[int]string, 5) //创建了有5个长度对slice,其中值类型为 map[int]string
24     fmt.Println("loop slice-map warn begin:========")
25     for _, v := range sm {  // 此时i为slice对下标,v为对应内容即map.这里不需要取key值故使用 _ 表示空白
26         v = make(map[int]string, 1) // 初始化长度为 1 的map
27         v[1] = "OK"
28         fmt.Println(v)
29     }
30     fmt.Println(sm)  // 这里打印的结果和循环体中打印的结果有差别,是因为循环体中对应的 v 为slice的拷贝,这点一定要注意
31 
32     fmt.Println("loop slice-map normal begin:======")
33     for i := range sm { // 要想改变其中slice内容,则只需要得到下标值通过对下标内容赋值改变原始slice内容,故这里没有去取value
34         sm[i] = make(map[int]string, 1)
35         sm[i][0] = "OK"
36         fmt.Println(sm[i])
37     }
38     fmt.Println(sm)
39 }

以上代码运行结果如下所示:

loop slice begin:=================
0 1
1 3
2 5
loop map begin:===================
a liang
b xuli
c liguang
loop slice-map warn begin:========
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[] map[] map[] map[] map[]]
loop slice-map normal begin:======
map[0:OK]
map[0:OK]
map[0:OK]
map[0:OK]
map[0:OK]
[map[0:OK] map[0:OK] map[0:OK] map[0:OK] map[0:OK]]

2.1 对map进行排序

那我们直接上代码,具体的解释和上面一样,在代码中做了详细的介绍,具体代码示例如下:

package main

import (
    "fmt"
    "sort"
)

func main() {
    // 对map的排序
    m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
    s := make([]int, len(m))
    i := 0
    for k, _ := range m {
        s[i] = k
        i++
    }
    fmt.Println("排序前顺序为:", s)
    sort.Ints(s)
    fmt.Println("排序后顺序为:", s)
}

以上代码运行结果如下:

排序前顺序为: [3 4 5 1 2]
排序后顺序为: [1 2 3 4 5]

2.2

  使用 for range 尝试将类型为 map[int]string 的键和值进行交换,变为类型 map[string]int

package main

import "fmt"

func main() {
    m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
    fmt.Println("对调前的map为:", m)
    exchangeMap := make(map[string]int, len(m))
    for k, v := range m {
        exchangeMap[v] = k
    }
    fmt.Println("对调后的map为:", exchangeMap)
}

以上运行代码结果如下所示:

对调前的map为: map[1:a 2:b 3:c 4:d 5:e]
对调后的map为: map[e:5 a:1 b:2 c:3 d:4]

Slice在应用中可能遇到的坑