请选择 进入手机版 | 继续访问电脑版
 找回密码
 立即注册
搜索

本文来自

边缘计算专区

边缘计算专区

人已关注

请添加对本版块的简短描述

Go 语言学习案例

[复制链接]
410 abc 发表于 2019-2-27 16:20:51
本帖最后由 abc 于 2019-2-27 16:25 编辑
  1. 安装
  2. IDE 注册服务器
  3. http://btsha.com:41017
  4. 1
  5. IDE 配置




  6. API 地址
  7. https://studygolang.com/pkgdoc

  8. 环境变量介绍
  9. GOPATH
  10. 工程目录

  11. GOROOT
  12. Go软件的安装目录

  13. 经典程序 Hello World
  14. // 必须为main
  15. package main

  16. import "fmt"

  17. //程序入口
  18. func main() {
  19.     //打印输出
  20.     fmt.Println("Hello World")
  21. }
  22. 1
  23. 2
  24. 3
  25. 4
  26. 5
  27. 6
  28. 7
  29. 8
  30. 9
  31. 10
  32. 25关键字
  33. break        default        func        interface        select
  34. case        defer        go        map        struct
  35. chan        else        goto        package        switch
  36. const        fallthrough        if        range        type
  37. continue        for        import        return        var
  38. 36 个预定义标识符
  39. append        bool        byte        cap        close        complex        complex64        complex128        uint16
  40. copy        false        float32        float64        imag        int        int8        int16        uint32
  41. int32        int64        iota        len        make        new        nil        panic        uint64
  42. print        println        real        recover        string        true        uint        uint8        uintptr
  43. 变量
  44. package main

  45. import "fmt"

  46. // 变量  字符串
  47. var name = "ms~go"

  48. // 整数
  49. var age = 23

  50. //字符串
  51. var address = "beijing"

  52. // 布尔类型
  53. var sex = true

  54. //常量
  55. const year = 2018

  56. //字符
  57. var c = 'c'




  58. func main() {

  59.     fmt.Println(name)
  60.     fmt.Println(age)
  61.     fmt.Println(sex)
  62.     fmt.Println(year)

  63.     var a = 1.5
  64.     var b = 2.5
  65.     //计算加法
  66.     fmt.Println(a + b)

  67. }
  68. 1
  69. 2
  70. 3

  71. var (
  72.     a int     = 10
  73.     b float64 = 100
  74. )
  75. 1
  76. 2
  77. 3
  78. 4
  79. a, b := 20, 30
  80. 1
  81. _, b := 34, 35

  82. 丢弃34
  83. 1
  84. 2
  85. 3
  86. “_” 代表丢弃的意思

  87. 数学运算
  88. package main

  89. import "fmt"

  90. func main() {

  91.     var a = 0xff

  92.     var b = 10

  93.     fmt.Println(a + b)
  94.     fmt.Println(a - b)
  95.     fmt.Println(a * b)
  96.     fmt.Println(a / b)
  97.     fmt.Println(a % b)
  98.     fmt.Println(a > b)
  99.     fmt.Println(a < b)
  100.     fmt.Println(a <= b)
  101.     fmt.Println(a >= b)
  102.     fmt.Println(a >> 1)
  103.     fmt.Println(b << 1)
  104.     fmt.Println(b | 1)
  105.     fmt.Println(b & 1)
  106.     fmt.Println(b != 1)

  107. }
  108. 1
  109. 2
  110. 3
  111. 4
  112. 5
  113. 6
  114. 7
  115. 8
  116. 9
  117. 10
  118. 11
  119. 12
  120. 13
  121. 14
  122. 15
  123. 16
  124. 17
  125. 18
  126. 19
  127. 20
  128. 21
  129. 22
  130. 23
  131. 24
  132. 25
  133. 26
  134. 随机数
  135. package main

  136. import (
  137.     "fmt"
  138.     "time"
  139.     "math/rand"
  140. )

  141. func main() {
  142.     r := rand.New(rand.NewSource(time.Now().UnixNano()))
  143.     for i:=0; i<10; i++ {
  144.         fmt.Println(r.Intn(100))
  145.     }
  146. }
  147. 1
  148. 2
  149. 3
  150. 4
  151. 5
  152. 6
  153. 7
  154. 8
  155. 9
  156. 10
  157. 11
  158. 12
  159. 13
  160. 14
  161. 数组
  162. package main

  163. import (
  164.     "fmt"
  165.     "time"
  166.     "math/rand"
  167. )

  168. func main() {

  169.     // 常量数组长度
  170.     const N = 10
  171.     //声明数组
  172.     var arr = [N]int{}
  173.     //随机数
  174.     r := rand.New(rand.NewSource(time.Now().UnixNano()))
  175.     //循环赋值
  176.     for i := 0; i < len(arr); i++ {
  177.         //赋值
  178.         arr[i] = r.Intn(0xff)
  179.     }
  180.     //打印数组
  181.     fmt.Println(arr)

  182.     /*******************************************

  183.                     冒泡排序

  184.      ********************************************/

  185.     //:=自动匹配变量类型
  186.     num := len(arr)
  187.     //花括号{必须在这一行 if也一样
  188.     for i := 0; i < num; i++ {
  189.         for j := i + 1; j < num; j++ {
  190.             if arr[i] > arr[j] {
  191.                 //相比某语言不需要临时交换变量
  192.                 arr[i], arr[j] = arr[j], arr[i]
  193.             }
  194.         }
  195.     }
  196.     //输出排序后的数组
  197.     fmt.Println(arr)

  198. }
  199. 1
  200. 2
  201. 3
  202. 4
  203. 5
  204. 6
  205. 7
  206. 8
  207. 9
  208. 10
  209. 11
  210. 12
  211. 13
  212. 14
  213. 15
  214. 16
  215. 17
  216. 18
  217. 19
  218. 20
  219. 21
  220. 22
  221. 23
  222. 24
  223. 25
  224. 26
  225. 27
  226. 28
  227. 29
  228. 30
  229. 31
  230. 32
  231. 33
  232. 34
  233. 35
  234. 36
  235. 37
  236. 38
  237. 39
  238. 40
  239. 41
  240. 42
  241. 43
  242. 44
  243. 45
  244. 指针
  245. package main

  246. import "fmt"

  247. func main() {

  248.     // 声明变量
  249.     var a int = 10

  250.     var b int = 10

  251.     //打印地址
  252.     fmt.Println("pointer address : %x", &a)

  253.     fmt.Println("pointer address : %x", &b)

  254.     //判断地址是否相同
  255.     fmt.Println(&a == &b)

  256.     //值赋值
  257.     var c = a
  258.     //值赋值
  259.     var d = b

  260.     //打印值
  261.     fmt.Println(c)
  262.     //打印地址
  263.     fmt.Println("pointer address : %x", &c)
  264.     //打印值
  265.     fmt.Println(d)
  266.     //打印地址
  267.     fmt.Println("pointer address : %x", &d)

  268.     //取地址
  269.     var e = &a
  270.     //取地址
  271.     var f = &a
  272.     //输出地址
  273.     fmt.Println("pointer address : %x", &e)
  274.     //输出地址
  275.     fmt.Println("pointer address : %x", &f)
  276.     //输出值
  277.     fmt.Println(e)
  278.     //输出值
  279.     fmt.Println(f)
  280.     //判断地址是否相同
  281.     fmt.Println(e == f)
  282.     //指针类型
  283.     var ip *int = &a
  284.     //打印指针
  285.     fmt.Println(ip)

  286.     //二级指针
  287.     var jp **int = &ip
  288.     fmt.Println(jp)

  289.     //三级指针
  290.     var kp ***int = &jp;
  291.     fmt.Println(kp)

  292.     arr := []int{10, 100, 200}
  293.     var i int

  294.     for i = 0; i < len(arr); i++ {
  295.         fmt.Printf("a[%d] = %d  |  %x \n", i, arr[i], &arr[i])
  296.     }

  297. }
  298. 1
  299. 2
  300. 3
  301. 4
  302. 5
  303. 6
  304. 7
  305. 8
  306. 9
  307. 10
  308. 11
  309. 12
  310. 13
  311. 14
  312. 15
  313. 16
  314. 17
  315. 18
  316. 19
  317. 20
  318. 21
  319. 22
  320. 23
  321. 24
  322. 25
  323. 26
  324. 27
  325. 28
  326. 29
  327. 30
  328. 31
  329. 32
  330. 33
  331. 34
  332. 35
  333. 36
  334. 37
  335. 38
  336. 39
  337. 40
  338. 41
  339. 42
  340. 43
  341. 44
  342. 45
  343. 46
  344. 47
  345. 48
  346. 49
  347. 50
  348. 51
  349. 52
  350. 53
  351. 54
  352. 55
  353. 56
  354. 57
  355. 58
  356. 59
  357. 60
  358. 61
  359. 62
  360. 63
  361. 64
  362. 65
  363. 66
  364. 67
  365. 68
  366. MD5
  367. package main

  368. import (
  369.     "crypto/md5"
  370.     "fmt"
  371.     "encoding/hex"
  372. )

  373. func main() {
  374.     md5Ctx := md5.New()
  375.     md5Ctx.Write([]byte("ms~go"))
  376.     cipherStr := md5Ctx.Sum(nil)
  377.     fmt.Println(cipherStr)
  378.     fmt.Println(hex.EncodeToString(cipherStr))
  379. }
  380. 1
  381. 2
  382. 3
  383. 4
  384. 5
  385. 6
  386. 7
  387. 8
  388. 9
  389. 10
  390. 11
  391. 12
  392. 13
  393. 14
  394. 15
  395. sha 256
  396. package main

  397.     import (
  398.         "crypto/sha256"
  399.         "fmt"
  400.     )

  401.     func main() {
  402.         h := sha256.New()
  403.         h.Write([]byte("ms~go"))
  404.         fmt.Printf("%x", h.Sum(nil))
  405.     }
  406. 1
  407. 2
  408. 3
  409. 4
  410. 5
  411. 6
  412. 7
  413. 8
  414. 9
  415. 10
  416. 11
  417. 12
  418. iota
  419. package main

  420. import "fmt"

  421. func main() {

  422.     //为 0
  423.     const a = iota
  424.     const (
  425.         //没增加一行+1
  426.         b = iota
  427.         c = iota
  428.         d = iota

  429.         e, f = iota, iota
  430.         // 同一行数值相等
  431.         g, h, i, j, k = iota, iota, iota, iota, iota
  432.     )
  433.     fmt.Printf("a = %d , b = %d , c = %d , d = %d , e = %d , f = %d , g = %d , h = %d , i = %d , j = %d , k = %d ", a, b, c, d, e, f, g, h, i, j, k)
  434.     //每次 const 出现时,都会让 iota 初始化为0.
  435.     const l = iota

  436.     fmt.Println(l)

  437. }
  438. 1
  439. 2
  440. 3
  441. 4
  442. 5
  443. 6
  444. 7
  445. 8
  446. 9
  447. 10
  448. 11
  449. 12
  450. 13
  451. 14
  452. 15
  453. 16
  454. 17
  455. 18
  456. 19
  457. 20
  458. 21
  459. 22
  460. 23
  461. 24
  462. 25
  463. // 自增长类型
  464. const (
  465.     a = iota
  466.     b
  467.     c
  468.     d
  469. )
  470. 1
  471. 2
  472. 3
  473. 4
  474. 5
  475. 6
  476. 7
  477. 使用 “_” 可以跳过值

  478. const (
  479.     a = iota
  480.     b
  481.     c
  482.     // 使用 "_" 可以跳过值
  483.     _
  484.     _
  485.     d
  486. )
  487. 1
  488. 2
  489. 3
  490. 4
  491. 5
  492. 6
  493. 7
  494. 8
  495. 9
  496. 位掩码表达式

  497. const(
  498.     a=1<<iota
  499.     b
  500.     c
  501.     d
  502.     e
  503.     f
  504.     _
  505.     g
  506.     h
  507. )

  508. fmt.Println(a)
  509. fmt.Println(b)
  510. fmt.Println(c)
  511. fmt.Println(d)
  512. fmt.Println(e)
  513. fmt.Println(f)
  514. fmt.Println(g)
  515. fmt.Println(h)


  516. GOROOT=D:\Go #gosetup
  517. GOPATH=E:\GoProject;D:\Go #gosetup
  518. D:\Go\bin\go.exe build -i -o C:\Users\maohuawei\AppData\Local\Temp\___go_build_main_go.exe E:/GoProject/src/ExampleCode/main/main.go #gosetup
  519. "C:\Program Files\JetBrains\GoLand 2018.1.4\bin\runnerw.exe" C:\Users\maohuawei\AppData\Local\Temp\___go_build_main_go.exe #gosetup
  520. 1
  521. 2
  522. 4
  523. 8
  524. 16
  525. 32
  526. 128
  527. 256
  528. 1
  529. 2
  530. 3
  531. 4
  532. 5
  533. 6
  534. 7
  535. 8
  536. 9
  537. 10
  538. 11
  539. 12
  540. 13
  541. 14
  542. 15
  543. 16
  544. 17
  545. 18
  546. 19
  547. 20
  548. 21
  549. 22
  550. 23
  551. 24
  552. 25
  553. 26
  554. 27
  555. 28
  556. 29
  557. 30
  558. 31
  559. 32
  560. 33
  561. 34
  562. 定义数量级

  563. type ByteSize float64

  564. const (
  565.     _           = iota                   // ignore first value by assigning to blank identifier
  566.     KB ByteSize = 1 << (10 * iota) // 1 << (10*1)
  567.     MB                                   // 1 << (10*2)
  568.     GB                                   // 1 << (10*3)
  569.     TB                                   // 1 << (10*4)
  570.     PB                                   // 1 << (10*5)
  571.     EB                                   // 1 << (10*6)
  572.     ZB                                   // 1 << (10*7)
  573.     YB                                   // 1 << (10*8)
  574. )
  575. 1
  576. 2
  577. 3
  578. 4
  579. 5
  580. 6
  581. 7
  582. 8
  583. 9
  584. 10
  585. 11
  586. 12
  587. 13
  588. 文件
  589. package main

  590. import (
  591.     "bufio" //缓存IO
  592.     "fmt"
  593.     "io"
  594.     "io/ioutil" //io 工具包
  595.     "os"
  596. )

  597. func check(e error) {
  598.     if e != nil {
  599.         panic(e)
  600.     }
  601. }

  602. /**
  603. * 判断文件是否存在  存在返回 true 不存在返回false
  604. */
  605. func checkFileIsExist(filename string) bool {
  606.     var exist = true
  607.     if _, err := os.Stat(filename); os.IsNotExist(err) {
  608.         exist = false
  609.     }
  610.     return exist
  611. }

  612. /**
  613.   from: http://www.isharey.com/?p=143
  614. */

  615. func main() {
  616.     var wireteString = "测试n"
  617.     var filename = "./output1.txt"
  618.     var f *os.File
  619.     var err1 error
  620.     /***************************** 第一种方式: 使用 io.WriteString 写入文件 ***********************************************/
  621.     if checkFileIsExist(filename) { //如果文件存在
  622.         f, err1 = os.OpenFile(filename, os.O_APPEND, 0666) //打开文件
  623.         fmt.Println("文件存在")
  624.     } else {
  625.         f, err1 = os.Create(filename) //创建文件
  626.         fmt.Println("文件不存在")
  627.     }
  628.     check(err1)
  629.     n, err1 := io.WriteString(f, wireteString) //写入文件(字符串)
  630.     check(err1)
  631.     fmt.Printf("写入 %d 个字节n", n)

  632.     /*****************************  第二种方式: 使用 ioutil.WriteFile 写入文件 ***********************************************/
  633.     var d1 = []byte(wireteString)
  634.     err2 := ioutil.WriteFile("./output2.txt", d1, 0666) //写入文件(字节数组)
  635.     check(err2)

  636.     /*****************************  第三种方式:  使用 File(Write,WriteString) 写入文件 ***********************************************/
  637.     f, err3 := os.Create("./output3.txt") //创建文件
  638.     check(err3)
  639.     defer f.Close()
  640.     n2, err3 := f.Write(d1) //写入文件(字节数组)
  641.     check(err3)
  642.     fmt.Printf("写入 %d 个字节n", n2)
  643.     n3, err3 := f.WriteString("writesn") //写入文件(字节数组)
  644.     fmt.Printf("写入 %d 个字节n", n3)
  645.     f.Sync()

  646.     /***************************** 第四种方式:  使用 bufio.NewWriter 写入文件 ***********************************************/
  647.     w := bufio.NewWriter(f) //创建新的 Writer 对象
  648.     n4, err3 := w.WriteString("bufferedn")
  649.     fmt.Printf("写入 %d 个字节n", n4)
  650.     w.Flush()
  651.     f.Close()
  652. }
  653. 1
  654. 2
  655. 3

  656. 字典
  657. package main

  658. import "fmt"

  659. func main() {


  660.     m:=make(map[string]string)

  661.     m["a"]="a"
  662.     m["b"]="b"
  663.     m["c"]="c"

  664.     // 打印字典
  665.     fmt.Println(m)
  666.     //字典长度
  667.     fmt.Println(len(m))
  668.     //根据键取值
  669.     fmt.Println(m["c"])
  670.     //删除
  671.     delete(m,"b")

  672.     fmt.Println(m)

  673. }
  674. 1
  675. 2
  676. 3
  677. 4
  678. 5
  679. 6
  680. 7
  681. 8
  682. 9
  683. 10
  684. 11
  685. 12
  686. 13
  687. 14
  688. 15
  689. 16
  690. 17
  691. 18
  692. 19
  693. 20
  694. 21
  695. 22
  696. 23
  697. 24
  698. 25
  699. 字符串
  700. package main

  701. import (
  702.     "fmt"
  703.     "strings"
  704. )

  705. func main() {

  706.     var print = fmt.Println
  707.     print(strings.Contains("MS~GO","MS"))
  708.     print(strings.Join([]string{"a", "b", "c"}, "~"))
  709.     print(strings.Count("ms~go go go","go"))
  710.     print(strings.EqualFold("s","s"))
  711.     print(strings.Fields("abc"))
  712.     //比较
  713.     print(strings.Compare("aaa","aaa"))

  714. }
  715. 1
  716. 2
  717. 3
  718. 4
  719. 5
  720. 6
  721. 7
  722. 8
  723. 9
  724. 10
  725. 11
  726. 12
  727. 13
  728. 14
  729. 15
  730. 16
  731. 17
  732. 18
  733. 19
  734. 自定义排序
  735. package main
  736. import "sort"
  737. import "fmt"
  738. // 为了能够使用自定义函数来排序,我们需要一个
  739. // 对应的排序类型,比如这里我们为内置的字符串
  740. // 数组定义了一个别名ByLength
  741. type ByLength []string
  742. // 我们实现了sort接口的Len,Less和Swap方法
  743. // 这样我们就可以使用sort包的通用方法Sort
  744. // Len和Swap方法的实现在不同的类型之间大致
  745. // 都是相同的,只有Less方法包含了自定义的排序
  746. // 逻辑,这里我们希望以字符串长度升序排序
  747. func (s ByLength) Len() int {
  748.     return len(s)
  749. }
  750. func (s ByLength) Swap(i, j int) {
  751.     s[i], s[j] = s[j], s[i]
  752. }
  753. func (s ByLength) Less(i, j int) bool {
  754.     return len(s[i]) < len(s[j])
  755. }
  756. // 一切就绪之后,我们就可以把需要进行自定义排序
  757. // 的字符串类型fruits转换为ByLength类型,然后使用
  758. // sort包的Sort方法来排序
  759. func main() {
  760.     fruits := []string{"a", "bb", "ccc","dddd","ee","121212"}
  761.     sort.Sort(ByLength(fruits))
  762.     fmt.Println(fruits)
  763. }
  764. 1
  765. 2
  766. 3
  767. 4
  768. 5
  769. 6
  770. 7
  771. 8
  772. 9
  773. 10
  774. 11
  775. 12
  776. 13
  777. 14
  778. 15
  779. 16
  780. 17
  781. 18
  782. 19
  783. 20
  784. 21
  785. 22
  786. 23
  787. 24
  788. 25
  789. 26
  790. 27
  791. 28
  792. 29
  793. Base64
  794. package main

  795. import base64 "encoding/base64"
  796. import "fmt"
  797. func main() {

  798.     data := "ms~go"

  799.     sEnc := base64.StdEncoding.EncodeToString([]byte(data))
  800.     fmt.Println(sEnc)

  801.     sDec, _ := base64.StdEncoding.DecodeString(sEnc)
  802.     fmt.Println(string(sDec))
  803.     fmt.Println()

  804.     uEnc := base64.URLEncoding.EncodeToString([]byte(data))
  805.     fmt.Println(uEnc)
  806.     uDec, _ := base64.URLEncoding.DecodeString(uEnc)
  807.     fmt.Println(string(uDec))
  808. }
  809. 1
  810. 2
  811. 3

  812. for 循环
  813. package main

  814. import (
  815.     "math/rand"
  816.     "fmt"
  817. )

  818. func main() {

  819.     var i=0

  820.     for i<100 {
  821.         fmt.Println(rand.Intn(0xff))
  822.         i++
  823.     }

  824. }
  825. 1
  826. 2
  827. 3

  828. package main

  829. import (
  830.     "fmt"
  831. )


  832. func main() {

  833.     for i := 0; i <= 9; i++ {
  834.         fmt.Println(i)
  835.     }

  836. }
  837. 1
  838. 2
  839. 3

  840. 循环一次

  841. package main

  842. import (
  843.     "fmt"
  844. )

  845. func main() {

  846.     for {
  847.         fmt.Println("for")
  848.         break
  849.     }

  850. }
  851. 1
  852. 2
  853. 3

  854. if
  855. package main

  856. import (
  857.     "math/rand"
  858.     "fmt"
  859. )

  860. func main() {

  861.     var i=0

  862.     for i<100 {
  863.         fmt.Println(rand.Intn(0xff))
  864.         i++

  865.         if(i==2){
  866.             continue
  867.         }

  868.         if(i==10){
  869.             break
  870.         }

  871.     }

  872. }
  873. 1
  874. 2
  875. 3

  876. defer
  877. Defer 用来保证一个函数调用会在程序执行的最后被调用。通常用于资源清理工作。

  878. package main

  879. import "fmt"
  880. import "os"

  881. func main() {

  882.     f := createFile("defer.txt")

  883.     defer closeFile(f)

  884.     writeFile(f)
  885. }
  886. func createFile(p string) *os.File {

  887.     f, err := os.Create(p)

  888.     if err != nil {

  889.         panic(err)

  890.     }

  891.     return f
  892. }

  893. func writeFile(f *os.File) {

  894.     fmt.Fprintln(f, "hello world defer")

  895. }

  896. func closeFile(f *os.File) {
  897.     if f != nil {
  898.         f.Close()
  899.     }
  900. }
  901. 1
  902. 2
  903. 3
  904. 4
  905. 5
  906. 6
  907. 7
  908. 8
  909. 9
  910. 10
  911. 11
  912. 12
  913. 13
  914. 14
  915. 15
  916. 16
  917. 17
  918. 18
  919. 19
  920. 20
  921. 21
  922. 22
  923. 23
  924. 24
  925. 25
  926. 26
  927. 27
  928. 28
  929. 29
  930. 30
  931. 31
  932. 32
  933. 33
  934. 34
  935. 35
  936. 36
  937. 37
  938. Exit
  939. package main

  940. import (
  941.     "os"
  942.     "fmt"
  943. )

  944. func main() {

  945.     var i = 0

  946.     for i < 100 {
  947.         fmt.Println(i)
  948.         if i == 50 {
  949.             os.Exit(0)
  950.         }

  951.         i++
  952.     }

  953. }
  954. 1
  955. 2
  956. 3
  957. 4
  958. 5
  959. 6
  960. 7
  961. 8
  962. 9
  963. 10
  964. 11
  965. 12
  966. 13
  967. 14
  968. 15
  969. 16
  970. 17
  971. 18
  972. 19
  973. 20
  974. 21
  975. if else
  976. 可变参数
  977. package main

  978. import "fmt"

  979. func main() {

  980.     sop(123165,564,235235,5234234,54234,51,61,)
  981. }

  982. /**
  983.     可变参数
  984. */
  985. func sop(args ...int) {

  986.     for i := 0; i < len(args); i++ {
  987.         fmt.Println(args[i])
  988.     }

  989. }
  990. 1
  991. 2
  992. 3
  993. 4
  994. 5
  995. 6
  996. 7
  997. 8
  998. 9
  999. 10
  1000. 11
  1001. 12
  1002. 13
  1003. 14
  1004. 15
  1005. 16
  1006. 17
  1007. 18
  1008. 19
  1009. 函数作为返回值
  1010. package main

  1011. import "fmt"

  1012. func main() {

  1013.     hello := func() {
  1014.         println("hello")

  1015.     }
  1016.     hello()
  1017.     //打印类型
  1018.     fmt.Printf("%T", hello)
  1019. }
  1020. 1
  1021. 2
  1022. 3
  1023. 4
  1024. 5
  1025. 6
  1026. 7
  1027. 8
  1028. 9
  1029. 10
  1030. 11
  1031. 12
  1032. 13
  1033. 14
  1034. panic
  1035. package main

  1036. import "os"

  1037. func main() {
  1038.     // 我们使用panic来检查预期不到的错误
  1039.     panic("a problem")
  1040.     // Panic的通常使用方法就是如果一个函数
  1041.     // 返回一个我们不知道怎么处理的错误的
  1042.     // 时候,直接终止执行。
  1043.     _, err := os.Create("1.txt")
  1044.     if err != nil {
  1045.         panic(err)
  1046.     }
  1047. }
  1048. 1
  1049. 2
  1050. 3
  1051. 4
  1052. 5
  1053. 6
  1054. 7
  1055. 8
  1056. 9
  1057. 10
  1058. 11
  1059. 12
  1060. 13
  1061. 14
  1062. 15
  1063. 键盘输入
  1064. package main

  1065. import (
  1066.     "bufio"
  1067.     "os"
  1068.     "fmt"
  1069.     "strings"
  1070. )

  1071. func main() {
  1072.     // 键盘输入
  1073.     scanner := bufio.NewScanner(os.Stdin)
  1074.     //循环获取输入
  1075.     for scanner.Scan() {
  1076.         //打印  转换为大写
  1077.         fmt.Println(scanner.Text() + "   ||   " + strings.ToUpper(scanner.Text()))

  1078.     }
  1079.     //检查错误。文件结束不会被当作一个错误
  1080.     if err := scanner.Err(); err != nil {
  1081.         fmt.Fprintln(os.Stderr, "error:", err)
  1082.         os.Exit(0)
  1083.     }

  1084. }
  1085. 1
  1086. 2
  1087. 3

  1088. range
  1089. package main

  1090. import "fmt"

  1091. func main() {
  1092.     sop(1, 2, 4, 6, 8, 10)

  1093. }

  1094. func sop(args ...int) {
  1095.     for _, i := range args {
  1096.         fmt.Println(i)
  1097.     }
  1098. }
  1099. 1
  1100. 2
  1101. 3

  1102. for i, c := range "AB" {
  1103.     fmt.Println(i, c)
  1104. }
  1105. 1
  1106. 2
  1107. 3
  1108. SH1
  1109. package main

  1110. import (
  1111.     "crypto/sha1"
  1112.     "fmt"
  1113. )

  1114. func main() {

  1115.     s1 := sha1.New()

  1116.     s1.Write([]byte("ms~go"))

  1117.     bs := s1.Sum(nil)

  1118.     fmt.Printf("%x", bs)

  1119. }
  1120. 1
  1121. 2
  1122. 3

  1123. 结构体
  1124. package main
  1125. import "fmt"
  1126. // 这个person结构体有name和age成员
  1127. type person struct {
  1128.     name string
  1129.     age int
  1130. }
  1131. func main() {
  1132.     // 这个语法创建一个新结构体变量
  1133.     fmt.Println(person{"Bob", 20})
  1134.     // 可以使用"成员:值"的方式来初始化结构体变量
  1135.     fmt.Println(person{name: "Alice", age: 30})
  1136.     // 未显式赋值的成员初始值为零值
  1137.     fmt.Println(person{name: "Fred"})
  1138.     // 可以使用&来获取结构体变量的地址
  1139.     fmt.Println(&person{name: "Ann", age: 40})
  1140.     // 使用点号(.)来访问结构体成员
  1141.     s := person{name: "Sean", age: 50}
  1142.     fmt.Println(s.name)
  1143.     // 结构体指针也可以使用点号(.)来访问结构体成员
  1144.     // Go语言会自动识别出来
  1145.     sp := &s
  1146.     fmt.Println(sp.age)
  1147.     // 结构体成员变量的值是可以改变的
  1148.     sp.age = 51
  1149.     fmt.Println(sp.age)
  1150. }
  1151. 1
  1152. 2
  1153. 3
  1154. 4
  1155. 5
  1156. 6
  1157. 7
  1158. 8
  1159. 9
  1160. 10
  1161. 11
  1162. 12
  1163. 13
  1164. 14
  1165. 15
  1166. 16
  1167. 17
  1168. 18
  1169. 19
  1170. 20
  1171. 21
  1172. 22
  1173. 23
  1174. 24
  1175. 25
  1176. 26
  1177. 27
  1178. URL解析
  1179. package main
  1180. import "fmt"
  1181. import "net/url"
  1182. import "strings"
  1183. func main() {
  1184.     // 我们将解析这个URL,它包含了模式,验证信息,
  1185.     // 主机,端口,路径,查询参数和查询片段
  1186.     s := "postgres://user:pass@host.com:5432/path?k=v#f"
  1187.     // 解析URL,并保证没有错误
  1188.     u, err := url.Parse(s)
  1189.     if err != nil {
  1190.         panic(err)
  1191.     }
  1192.     // 可以直接访问解析后的模式
  1193.     fmt.Println(u.Scheme)
  1194.     // User包含了所有的验证信息,使用
  1195.     // Username和Password来获取单独的信息
  1196.     fmt.Println(u.User)
  1197.     fmt.Println(u.User.Username())
  1198.     p, _ := u.User.Password()
  1199.     fmt.Println(p)
  1200.     // Host包含了主机名和端口,如果需要可以
  1201.     // 手动分解主机名和端口
  1202.     fmt.Println(u.Host)
  1203.     h := strings.Split(u.Host, ":")
  1204.     fmt.Println(h[0])
  1205.     fmt.Println(h[1])
  1206.     // 这里我们解析出路径和`#`后面的片段
  1207.     fmt.Println(u.Path)
  1208.     fmt.Println(u.Fragment)
  1209.     // 为了得到`k=v`格式的查询参数,使用RawQuery。你可以将
  1210.     // 查询参数解析到一个map里面。这个map为字符串作为key,
  1211.     // 字符串切片作为value。
  1212.     fmt.Println(u.RawQuery)
  1213.     m, _ := url.ParseQuery(u.RawQuery)
  1214.     fmt.Println(m)
  1215.     fmt.Println(m["k"][0])
  1216. }
  1217. 1
  1218. 2
  1219. 3
  1220. 4
  1221. 5
  1222. 6
  1223. 7
  1224. 8
  1225. 9
  1226. 10
  1227. 11
  1228. 12
  1229. 13
  1230. 14
  1231. 15
  1232. 16
  1233. 17
  1234. 18
  1235. 19
  1236. 20
  1237. 21
  1238. 22
  1239. 23
  1240. 24
  1241. 25
  1242. 26
  1243. 27
  1244. 28
  1245. 29
  1246. 30
  1247. 31
  1248. 32
  1249. 33
  1250. 34
  1251. 35
  1252. 36
  1253. 37
  1254. 38
  1255. 内存分配
  1256. package main

  1257. import (
  1258.     "sync"
  1259.     "bytes"
  1260.     "fmt"
  1261. )

  1262. type SyncedBuffer struct {
  1263.     lock    sync.Mutex
  1264.     bbuffer bytes.Buffer
  1265. }

  1266. func main() {
  1267.     _ = new(SyncedBuffer)
  1268.     var _ SyncedBuffer

  1269.     var p1 *[]int = new([]int)
  1270.     var p2 []int = make([]int,10000)

  1271.     fmt.Printf("%p", p1)
  1272.     fmt.Printf("%p", p2)

  1273. }
  1274. 1
  1275. 2
  1276. 3
  1277. 4
  1278. 5
  1279. 6
  1280. 7
  1281. 8
  1282. 9
  1283. 10
  1284. 11
  1285. 12
  1286. 13
  1287. 14
  1288. 15
  1289. 16
  1290. 17
  1291. 18
  1292. 19
  1293. 20
  1294. 21
  1295. 22
  1296. 23
  1297. 24
  1298. 自定义类型
  1299. package main

  1300. import "fmt"

  1301. // 自定义类型
  1302. type ms string

  1303. //结构体
  1304. type person struct {
  1305.     name ms
  1306. }

  1307. func main() {

  1308.     var p1 = new(person)
  1309.     p1.name="ms"
  1310.     fmt.Println(p1)

  1311. }
  1312. 1
  1313. 2
  1314. 3

  1315. 类型转换
  1316. package main

  1317. import "fmt"

  1318. func main(){


  1319.     var a int = 10
  1320.     fmt.Println(a)
  1321.     var b float64=float64(a)
  1322.     fmt.Println(b)

  1323. }
  1324. 1
  1325. 2
  1326. 3
  1327. 4
  1328. 5
  1329. 6
  1330. 7
  1331. 8
  1332. 9
  1333. 10
  1334. 11
  1335. 12
  1336. 13
  1337. 接口
  1338. package main

  1339. import "fmt"

  1340. import "math"

  1341. // 这里定义了一个最基本的表示几何形状的方法的接口
  1342. type geometry interface {

  1343.     area() float64

  1344.     perim() float64

  1345. }

  1346. // 这里我们要让正方形square和圆形circle实现这个接口

  1347. type square struct {

  1348.     width, height float64

  1349. }

  1350. type circle struct {

  1351.     radius float64

  1352. }

  1353. // 在Go中实现一个接口,只要实现该接口定义的所有方法即可

  1354. // 下面是正方形实现的接口

  1355. func (s square) area() float64 {

  1356.     return s.width * s.height

  1357. }

  1358. func (s square) perim() float64 {

  1359.     return 2*s.width + 2*s.height

  1360. }

  1361. // 圆形实现的接口

  1362. func (c circle) area() float64 {

  1363.     return math.Pi * c.radius * c.radius

  1364. }

  1365. func (c circle) perim() float64 {

  1366.     return 2 * math.Pi * c.radius

  1367. }

  1368. // 如果一个函数的参数是接口类型,那么我们可以使用命名接口

  1369. // 来调用这个函数

  1370. // 比如这里的正方形square和圆形circle都实现了接口geometry,

  1371. // 那么它们都可以作为这个参数为geometry类型的函数的参数。

  1372. // 在measure函数内部,Go知道调用哪个结构体实现的接口方法。

  1373. func measure(g geometry) {

  1374.     fmt.Println(g)

  1375.     fmt.Println(g.area())

  1376.     fmt.Println(g.perim())

  1377. }

  1378. func main() {

  1379.     s := square{width: 3, height: 4}

  1380.     c := circle{radius: 5}

  1381.     // 这里circle和square都实现了geometry接口,所以

  1382.     // circle类型变量和square类型变量都可以作为measure

  1383.     // 函数的参数

  1384.     measure(s)

  1385.     measure(c)
  1386. }
  1387. 1
  1388. 2
  1389. 3
  1390. 4
  1391. 5
  1392. 6
  1393. 7
  1394. 8
  1395. 9
  1396. 10
  1397. 11
  1398. 12
  1399. 13
  1400. 14
  1401. 15
  1402. 16
  1403. 17
  1404. 18
  1405. 19
  1406. 20
  1407. 21
  1408. 22
  1409. 23
  1410. 24
  1411. 25
  1412. 26
  1413. 27
  1414. 28
  1415. 29
  1416. 30
  1417. 31
  1418. 32
  1419. 33
  1420. 34
  1421. 35
  1422. 36
  1423. 37
  1424. 38
  1425. 39
  1426. 40
  1427. 41
  1428. 42
  1429. 43
  1430. 44
  1431. 45
  1432. 46
  1433. 47
  1434. 48
  1435. 49
  1436. 50
  1437. 51
  1438. 52
  1439. 53
  1440. 54
  1441. 55
  1442. 56
  1443. 57
  1444. 58
  1445. 59
  1446. 60
  1447. 61
  1448. 62
  1449. 63
  1450. 64
  1451. 65
  1452. 66
  1453. 67
  1454. 68
  1455. 69
  1456. 70
  1457. 71
  1458. 72
  1459. 73
  1460. 74
  1461. 75
  1462. 76
  1463. 77
  1464. 78
  1465. 79
  1466. 80
  1467. 81
  1468. 82
  1469. 83
  1470. 84
  1471. 85
  1472. 86
  1473. 87
  1474. 88
  1475. 89
  1476. 90
  1477. 91
  1478. 92
  1479. 93
  1480. 94
  1481. 95
  1482. 数组和冒泡
  1483. package main

  1484. import "fmt"

  1485. func main() {

  1486.     arr := []int{10, 12, 33, 14, 65}
  1487.     for _, i := range arr {
  1488.         fmt.Printf("%d  ",i)

  1489.     }

  1490.     fmt.Println()

  1491.     bubblesort(arr)
  1492.     for _, i := range arr {
  1493.         fmt.Printf("%d  ",i)
  1494.     }

  1495. }

  1496. func bubblesort(n[]int) {
  1497.     for i := 0; i < len(n)-1; i++ {
  1498.         for j := i + 1; j < len(n); j++ {
  1499.             if n[j] < n[i] {
  1500.                 n[i], n[j] = n[j], n[i]
  1501.             }
  1502.         }
  1503.     }
  1504. }
  1505. 1
  1506. 2
  1507. 3
  1508. 4
  1509. 5
  1510. 6
  1511. 7
  1512. 8
  1513. 9
  1514. 10
  1515. 11
  1516. 12
  1517. 13
  1518. 14
  1519. 15
  1520. 16
  1521. 17
  1522. 18
  1523. 19
  1524. 20
  1525. 21
  1526. 22
  1527. 23
  1528. 24
  1529. 25
  1530. 26
  1531. 27
  1532. 28
  1533. 29
  1534. 30
  1535. 一维数组,二位数组,二维数组的转置
  1536. package main

  1537. import "fmt"

  1538. func main() {

  1539.     var a [5]int

  1540.     a[0] = 1024 >> 10

  1541.     fmt.Printf("%d  \n", a)

  1542.     var c = 0
  1543.     var b [3][3]int
  1544.     var d [3][3]int
  1545.     for i := 0; i < 3; i++ {
  1546.         for j := 0; j < 3; j++ {
  1547.             c++
  1548.             b[i][j] = c
  1549.         }
  1550.     }
  1551.     for i := 0; i < 3; i++ {
  1552.         for j := 0; j < 3; j++ {
  1553.             fmt.Printf("%d  ", b[i][j])
  1554.         }
  1555.         fmt.Println()
  1556.     }

  1557.     fmt.Println("----------")

  1558.     for i := 0; i < len(b); i++ {
  1559.         for j := 0; j < len(b[0]); j++ {
  1560.             d[i][j] = b[j][i]
  1561.         }
  1562.     }

  1563.     for i := 0; i < 3; i++ {
  1564.         for j := 0; j < 3; j++ {
  1565.             fmt.Printf("%d  ", d[i][j])
  1566.         }
  1567.         fmt.Println()
  1568.     }
  1569. }
  1570. 1
  1571. 2
  1572. 3
  1573. 4
  1574. 5
  1575. 6
  1576. 7
  1577. 8
  1578. 9
  1579. 10
  1580. 11
  1581. 12
  1582. 13
  1583. 14
  1584. 15
  1585. 16
  1586. 17
  1587. 18
  1588. 19
  1589. 20
  1590. 21
  1591. 22
  1592. 23
  1593. 24
  1594. 25
  1595. 26
  1596. 27
  1597. 28
  1598. 29
  1599. 30
  1600. 31
  1601. 32
  1602. 33
  1603. 34
  1604. 35
  1605. 36
  1606. 37
  1607. 38
  1608. 39
  1609. 40
  1610. 41
  1611. 42
  1612. 43
  1613. 超时时间
  1614. package main

  1615. import "time"

  1616. func main() {
  1617.     c := make(chan int)
  1618.     o := make(chan bool)
  1619.     go func() {
  1620.         for {
  1621.             select {
  1622.             case v := <-c:
  1623.                 println(v)
  1624.             case <-time.After(5 * time.Second):
  1625.                 println("timeout")
  1626.                 o <- true
  1627.                 break
  1628.             }
  1629.         }
  1630.     }()
  1631.     <-o
  1632. }
  1633. 1
  1634. 2
  1635. 3
  1636. 4
  1637. 5
  1638. 6
  1639. 7
  1640. 8
  1641. 9
  1642. 10
  1643. 11
  1644. 12
  1645. 13
  1646. 14
  1647. 15
  1648. 16
  1649. 17
  1650. 18
  1651. 19
  1652. 20
  1653. 21
  1654. json 编码与解析
  1655. package main

  1656. import "encoding/json"
  1657. import "fmt"

  1658. type Person struct {
  1659.     Name string
  1660.     Age  int
  1661.     Sex  bool
  1662. }

  1663. func main() {
  1664.     /*****json转换*****/

  1665.     //创建对象
  1666.     person := Person{

  1667.         "ms~go",
  1668.         23,
  1669.         true,
  1670.     }
  1671.     //json编码
  1672.     personjson, _ := json.Marshal(person)
  1673.     //输出json字符串
  1674.     fmt.Println(string(personjson))

  1675.     /*****json解析*****/
  1676.     strjson := `{"Name":"ms~go","Age":23,"Sex":true}`
  1677.     r := &Person{}
  1678.     json.Unmarshal([]byte(strjson), &r)
  1679.     fmt.Println(r)
  1680.     fmt.Println(r.Name)
  1681.     fmt.Println(r.Age)
  1682.     fmt.Println(r.Sex)

  1683. }
  1684. 1
  1685. 2
  1686. 3
  1687. 4
  1688. 5
  1689. 6
  1690. 7
  1691. 8
  1692. 9
  1693. 10
  1694. 11
  1695. 12
  1696. 13
  1697. 14
  1698. 15
  1699. 16
  1700. 17
  1701. 18
  1702. 19
  1703. 20
  1704. 21
  1705. 22
  1706. 23
  1707. 24
  1708. 25
  1709. 26
  1710. 27
  1711. 28
  1712. 29
  1713. 30
  1714. 31
  1715. 32
  1716. 33
  1717. 34
  1718. 35
  1719. 36
  1720. 查看某个环境变量
  1721. package main

  1722. import (
  1723.     "os"
  1724.     "fmt"
  1725. )

  1726. func main() {


  1727.     ANDROID_HOME,AB:=os.LookupEnv("ANDROID_HOME")
  1728.     fmt.Println(ANDROID_HOME)
  1729.     fmt.Println(AB)

  1730.     JAVA_HOME,JB:=os.LookupEnv("JAVA_HOME")
  1731.     fmt.Println(JAVA_HOME)
  1732.     fmt.Println(JB)

  1733.     PATH,PB:=os.LookupEnv("PATH")
  1734.     fmt.Println(PATH)
  1735.     fmt.Println(PB)

  1736. }
  1737. 1
  1738. 2
  1739. 3
  1740. 4
  1741. 5
  1742. 6
  1743. 7
  1744. 8
  1745. 9
  1746. 10
  1747. 11
  1748. 12
  1749. 13
  1750. 14
  1751. 15
  1752. 16
  1753. 17
  1754. 18
  1755. 19
  1756. 20
  1757. 21
  1758. 22
  1759. 23
  1760. 执行CMD命令
  1761. package main

  1762. import "os/exec"

  1763. func main() {
  1764.     cmdcalc := exec.Command("calc")
  1765.     cmdcalc.Start()

  1766.     cmdnotepad := exec.Command("notepad")
  1767.     cmdnotepad.Start()

  1768.     cmdmspaitn := exec.Command("mspaint")
  1769.     cmdmspaitn.Start()
  1770. }
  1771. 1
  1772. 2
  1773. 3
  1774. 4
  1775. 5
  1776. 6
  1777. 7
  1778. 8
  1779. 9
  1780. 10
  1781. 11
  1782. 12
  1783. 13
  1784. 14
  1785. http get 请求
  1786. package main

  1787. import (
  1788.     "net/http"
  1789.     "fmt"
  1790.     "io/ioutil"
  1791.     "os"
  1792. )

  1793. func main() {
  1794.     //http 请求
  1795.     resp, _ := http.Get("http://www.baidu.com/")
  1796.     //defer 打开
  1797.     defer resp.Body.Close()
  1798.     //获取请求体
  1799.     body, _ := ioutil.ReadAll(resp.Body)
  1800.     //打印请求到的数据
  1801.     fmt.Println(string(body))
  1802.     //创建文件
  1803.     os.Create("baidu.html")
  1804.     //写入数据
  1805.     ioutil.WriteFile("baidu.html", body, 777)

  1806. }
  1807. 1
  1808. 2
  1809. 3

  1810. goroutine
  1811. package main

  1812. import (
  1813.     "fmt"
  1814.     "time"
  1815. )

  1816. func main() {
  1817.     //必须先运行ms和ms1
  1818.     //如果先运行for{} 则执行不到 ms() ms1()
  1819.     go ms()
  1820.     go ms1()
  1821.     for {
  1822.         fmt.Println("this is main ")
  1823.         time.Sleep(time.Second)
  1824.     }

  1825. }

  1826. // 函数1
  1827. func ms() {

  1828.     for {
  1829.         fmt.Println("this is ms")
  1830.         time.Sleep(time.Second)
  1831.     }
  1832. }

  1833. //函数2
  1834. func ms1() {

  1835.     for {
  1836.         fmt.Println("this is ms1")
  1837.         time.Sleep(time.Second)
  1838.     }
  1839. }
  1840. 1
  1841. 2
  1842. 3

  1843. 文件创建
  1844. package main

  1845. import (
  1846.     "os"
  1847.     "bufio"
  1848. )

  1849. func main() {

  1850.     // 创建文件
  1851.     f, _ := os.Create("hello world.txt")
  1852.     //defer关闭文件
  1853.     defer f.Close()
  1854.     //写入文件 方法1
  1855.     f.Write([]byte("hello world "))
  1856.     //写入文件 方法2
  1857.     f.WriteString("你是我的眼")
  1858.     //同步文件
  1859.     f.Sync()
  1860.     //写入文件方法3
  1861.     w := bufio.NewWriter(f)
  1862.     //写入数据
  1863.     w.WriteString("哈哈哈哈哈哈")
  1864.     //刷新
  1865.     w.Flush()

  1866. }
  1867. 1
  1868. 2
  1869. 3

  1870. 文件写入
  1871. package main

  1872. import "io/ioutil"

  1873. func main() {

  1874.     var str = "File Writer"

  1875.     ioutil.WriteFile("fw.txt", []byte(str), 0777)

  1876. }
  1877. 1
  1878. 2
  1879. 3
  1880. 4
  1881. 5
  1882. 6
  1883. 7
  1884. 8
  1885. 9
  1886. 10
  1887. 11
  1888. 文件读取
  1889. package main

  1890. import (
  1891.     "io/ioutil"
  1892.     "fmt"
  1893. )

  1894. func main() {

  1895.     fr, _ := ioutil.ReadFile("fw.txt")
  1896.     fmt.Println(string(fr))

  1897. }
  1898. 1
  1899. 2
  1900. 3

  1901. 读取文件的方法速度比较
  1902. package main

  1903. import (
  1904.     "bufio"
  1905.     "fmt"
  1906.     "io"
  1907.     "io/ioutil"
  1908.     "os"
  1909.     "time"
  1910.     "net/http"
  1911. )

  1912. func read0(path string) string {
  1913.     f, err := ioutil.ReadFile(path)
  1914.     if err != nil {
  1915.         fmt.Printf("%s\n", err)
  1916.         panic(err)
  1917.     }
  1918.     return string(f)
  1919. }

  1920. func read1(path string) string {
  1921.     fi, err := os.Open(path)
  1922.     if err != nil {
  1923.         panic(err)
  1924.     }
  1925.     defer fi.Close()

  1926.     chunks := make([]byte, 1024, 1024)
  1927.     buf := make([]byte, 1024)
  1928.     for {
  1929.         n, err := fi.Read(buf)
  1930.         if err != nil && err != io.EOF {
  1931.             panic(err)
  1932.         }
  1933.         if 0 == n {
  1934.             break
  1935.         }
  1936.         chunks = append(chunks, buf[:n]...)
  1937.     }
  1938.     return string(chunks)
  1939. }

  1940. func read2(path string) string {
  1941.     fi, err := os.Open(path)
  1942.     if err != nil {
  1943.         panic(err)
  1944.     }
  1945.     defer fi.Close()
  1946.     r := bufio.NewReader(fi)

  1947.     chunks := make([]byte, 1024, 1024)

  1948.     buf := make([]byte, 1024)
  1949.     for {
  1950.         n, err := r.Read(buf)
  1951.         if err != nil && err != io.EOF {
  1952.             panic(err)
  1953.         }
  1954.         if 0 == n {
  1955.             break
  1956.         }
  1957.         chunks = append(chunks, buf[:n]...)
  1958.     }
  1959.     return string(chunks)
  1960. }

  1961. func read3(path string) string {
  1962.     fi, err := os.Open(path)
  1963.     if err != nil {
  1964.         panic(err)
  1965.     }
  1966.     defer fi.Close()
  1967.     fd, err := ioutil.ReadAll(fi)
  1968.     return string(fd)
  1969. }

  1970. func main() {

  1971.     str, _ := http.Get("http://pic.sogou.com/pics/channel/getAllRecomPicByTag.jsp?category=%E5%A3%81%E7%BA%B8&tag=%E5%85%A8%E9%83%A8&start=0&len=100000")

  1972.     html, _ := ioutil.ReadAll(str.Body)

  1973.     ioutil.WriteFile("fw.json", html, 0777)

  1974.     file := "fw.json"

  1975.     start := time.Now()

  1976.     read0(file)
  1977.     t0 := time.Now()
  1978.     fmt.Printf("Cost time %v\n", t0.Sub(start))

  1979.     read1(file)
  1980.     t1 := time.Now()
  1981.     fmt.Printf("Cost time %v\n", t1.Sub(t0))

  1982.     read2(file)
  1983.     t2 := time.Now()
  1984.     fmt.Printf("Cost time %v\n", t2.Sub(t1))

  1985.     read3(file)
  1986.     t3 := time.Now()
  1987.     fmt.Printf("Cost time %v\n", t3.Sub(t2))

  1988. }
  1989. 1
  1990. 2
  1991. 3

  1992. 递归遍历目录
  1993. GO语言获取目录列表用 ioutil.ReadDir(),遍历目录用 filepath.Walk()
  1994. 1
  1995. web 服务
  1996. package main

  1997. import (
  1998.     "fmt"
  1999.     "log"
  2000.     "net/http"
  2001. )

  2002. func main() {
  2003.     http.HandleFunc("/", handler) // each request calls handler
  2004.     log.Fatal(http.ListenAndServe("localhost:9512", nil))
  2005. }

  2006. // handler echoes the Path component of the request URL r.
  2007. func handler(w http.ResponseWriter, r *http.Request) {
  2008.     fmt.Fprintf(w, "你是我的眼")
  2009. }
  2010. 1
  2011. 2
  2012. 3

  2013. Go 操作Excel文件
  2014. https://github.com/360EntSecGroup-Skylar/excelize

  2015. 写入文件
  2016. package main

  2017. import (
  2018.     "fmt"

  2019.     "strconv"
  2020.     "github.com/360EntSecGroup-Skylar/excelize"
  2021. )

  2022. func main() {

  2023.     // 创建XMLS文件
  2024.     xlsx := excelize.NewFile()
  2025.     //循环写入数据
  2026.     for i := 1; i < 1000; i++ {
  2027.         //拼接字符串
  2028.         //位子
  2029.         axis := "B" + strconv.Itoa(i)
  2030.         //在指定的位置写入数据
  2031.         xlsx.SetCellValue("Sheet1", axis, 1024*i)

  2032.     }
  2033.     //创建sheet
  2034.     index := xlsx.NewSheet("Sheet2")
  2035.     //循环写入数据
  2036.     for i := 1; i < 1000; i++ {
  2037.         axis := "A" + strconv.Itoa(i)
  2038.         //写入
  2039.         xlsx.SetCellValue("Sheet2", axis, 1024*i)

  2040.     }
  2041.     //保存
  2042.     xlsx.SetActiveSheet(index)
  2043.     //保存文件
  2044.     err := xlsx.SaveAs("hello.xlsx")
  2045.     if err != nil {
  2046.         fmt.Println(err)
  2047.     }

  2048. }
  2049. 1
  2050. 2
  2051. 3

  2052. 将数字转化为字符串
  2053. strconv.Itoa(i)
  2054. 1
  2055. 读取Excel文件
  2056. package main

  2057. import (
  2058.     "fmt"
  2059.     "github.com/360EntSecGroup-Skylar/excelize"
  2060.     "strconv"
  2061. )

  2062. func main() {
  2063.     xlsx, err := excelize.OpenFile("1.xlsx")
  2064.     if err != nil {
  2065.         fmt.Println(err)
  2066.         return
  2067.     }


  2068.     for i := 1; i < 100; i++ {
  2069.         //读取
  2070.         axisa := "A" + strconv.Itoa(i)
  2071.         cella := xlsx.GetCellValue("06-08", axisa)
  2072.         fmt.Println(cella)

  2073.         axisb := "B" + strconv.Itoa(i)
  2074.         cellb := xlsx.GetCellValue("06-08", axisb)
  2075.         fmt.Println(cellb)
  2076.     }

  2077.     //读取指定sheet的所有信息
  2078.     rows := xlsx.GetRows("06-08")
  2079.     for _, row := range rows {
  2080.         for _, colCell := range row {
  2081.             fmt.Print(colCell, "\t")
  2082.         }
  2083.         fmt.Println()
  2084.     }
  2085. }
  2086. 1
  2087. 2
  2088. 3

  2089. Excel 写入图片
  2090. package main

  2091. import (
  2092.     "fmt"
  2093.     _ "image/gif"
  2094.     _ "image/jpeg"
  2095.     _ "image/png"

  2096.     "github.com/360EntSecGroup-Skylar/excelize"
  2097.     "strconv"
  2098. )

  2099. func main() {
  2100.     xlsx, err := excelize.OpenFile("1.xlsx")
  2101.     if err != nil {
  2102.         fmt.Println(err)
  2103.         return
  2104.     }

  2105.     for i := 1; i < 200; i++ {

  2106.         if (i%23 == 0) {

  2107.             xlsx.AddPicture("Sheet1", "A"+strconv.Itoa(i), "hai.png", `{"x_scale": 0.5, "y_scale": 0.5}`)

  2108.         }
  2109.     }

  2110.     //xlsx.AddPicture("Sheet1", "A22", "hai.png", `{"x_scale": 0.5, "y_scale": 0.5}`)

  2111.     //xlsx.AddPicture("Sheet1", "F1", "hai.png", `{"x_scale": 0.5, "y_scale": 0.5}`)
  2112.     //
  2113.     //
  2114.     //xlsx.AddPicture("Sheet1", "H2", "hai.png", `{"x_offset": 15, "y_offset": 10, "print_obj": true, "lock_aspect_ratio": false, "locked": false}`)

  2115.     err = xlsx.Save()
  2116.     if err != nil {
  2117.         fmt.Println(err)
  2118.     }
  2119. }
  2120. 1
  2121. 2
  2122. 3

  2123. MP3播放
  2124. package main

  2125. import (
  2126.     "io/ioutil"

  2127.     "github.com/hajimehoshi/oto"
  2128.     "github.com/tosone/minimp3"
  2129. )

  2130. func main() {
  2131.     var file, _ = ioutil.ReadFile("杨坤 - 那一天.mp3")
  2132.     dec, data, _ := minimp3.DecodeFull(file)

  2133.     player, _ := oto.NewPlayer(dec.SampleRate, dec.Channels, 2, 1024*8)
  2134.     player.Write(data)
  2135. }
  2136. 1
  2137. 2
  2138. 3

  2139. 文件切割
  2140. package main

  2141. import (
  2142.     "math"
  2143.     "os"
  2144.     "strconv"
  2145. )

  2146. const chunkSize int64 = 1024 * 1024 * 64

  2147. func main() {

  2148.     // 获取文件的信息
  2149.     fileInfo, _ := os.Stat("27_运算符(上).avi")
  2150.     //计算每一个区块的大小
  2151.     num := int(math.Ceil(float64(fileInfo.Size()) / float64(chunkSize)))
  2152.     //打开文件
  2153.     fi, _ := os.OpenFile("27_运算符(上).avi", os.O_RDONLY, os.ModePerm)
  2154.     //
  2155.     b := make([]byte, chunkSize)
  2156.     //
  2157.     var i int64 = 1
  2158.     //
  2159.     for ; i <= int64(num); i++ {
  2160.         //移动指针
  2161.         fi.Seek((i-1)*(chunkSize), 0)

  2162.         if len(b) > int((fileInfo.Size() - (i-1)*chunkSize)) {
  2163.             //分配内存
  2164.             b = make([]byte, fileInfo.Size()-(i-1)*chunkSize)
  2165.         }

  2166.         //
  2167.         fi.Read(b)
  2168.         // 创建块的文件
  2169.         f, _ := os.OpenFile(strconv.Itoa(int(i))+".db", os.O_CREATE|os.O_WRONLY, os.ModePerm)
  2170.         //写入块文件
  2171.         f.Write(b)
  2172.         //关闭文件
  2173.         f.Close()
  2174.     }

  2175. }
  2176. 1
  2177. 2
  2178. 3

  2179. 文件合并
  2180. package main

  2181. import (
  2182.     "os"
  2183.     "fmt"
  2184.     "strconv"
  2185.     "io/ioutil"
  2186. )

  2187. func main() {

  2188.     fii, _ := os.OpenFile("1.avi", os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)

  2189.     for i := 1; i <= 33; i++ {
  2190.         f, err := os.OpenFile(strconv.Itoa(int(i))+".db", os.O_RDONLY, os.ModePerm)
  2191.         if err != nil {
  2192.             fmt.Println(err)
  2193.             return
  2194.         }
  2195.         b, _ := ioutil.ReadAll(f)
  2196.         fii.Write(b)
  2197.         f.Close()
  2198.     }

  2199. }
  2200. 1
  2201. 2
  2202. 3

  2203. http 请求
  2204. package main

  2205. import (
  2206.     "fmt"
  2207.     "net/http"
  2208.     "io"
  2209.     "os"
  2210.     "sync/atomic"
  2211.     "runtime"
  2212.     "time"
  2213. )

  2214. func main() {

  2215.     //生成client 参数为默认
  2216.     client := &http.Client{}

  2217.     //生成要访问的url
  2218.     url := "http://www.baidu.com"

  2219.     //提交请求
  2220.     reqest, _ := http.NewRequest("GET", url, nil)

  2221.     //处理返回结果
  2222.     response, _ := client.Do(reqest)

  2223.     //将结果定位到标准输出 也可以直接打印出来 或者定位到其他地方进行相应的处理
  2224.     stdout := os.Stdout

  2225.     //输出请求体
  2226.     _, _ = io.Copy(stdout, response.Body)

  2227.     //返回的状态码
  2228.     status := response.StatusCode

  2229.     //打印输出状态
  2230.     fmt.Println(status)

  2231. }
  2232. 1
  2233. 2
  2234. 3

  2235. 原子计数器
  2236. package main

  2237. import "fmt"
  2238. import "time"
  2239. import "sync/atomic"
  2240. import "runtime"

  2241. func main() {
  2242.     // 我们使用一个无符号整型来代表一个永远为正整数的counter
  2243.     var ops uint64 = 0
  2244.     // 为了模拟并行更新,我们使用50个协程来每隔1毫秒来
  2245.     // 增加一下counter值,注意这里的50协程里面的for循环,
  2246.     // 也就是说如果主协程不退出,这些协程将永远运行下去
  2247.     // 所以这个程序每次输出的值有可能不一样
  2248.     for i := 0; i < 50; i++ {
  2249.         go func() {
  2250.             for {
  2251.                 // 为了能够保证counter值增加的原子性,我们使用
  2252.                 // atomic包中的AddUint64方法,将counter的地址和
  2253.                 // 需要增加的值传递给函数即可
  2254.                 atomic.AddUint64(&ops, 1)
  2255.                 // 允许其他的协程来处理
  2256.                 runtime.Gosched()
  2257.             }
  2258.         }()
  2259.     }
  2260.     //等待1秒中,让协程有时间运行一段时间
  2261.     time.Sleep(time.Second)
  2262.     // 为了能够在counter仍被其他协程更新值的同时安全访问counter值,
  2263.     // 我们获取一个当前counter值的拷贝,这里就是opsFinal,需要把
  2264.     // ops的地址传递给函数`LoadUint64`
  2265.     opsFinal := atomic.LoadUint64(&ops)
  2266.     fmt.Println("ops:", opsFinal)
  2267. }
  2268. 1
  2269. 2
  2270. 3

  2271. 信号
  2272. package main
  2273. import "fmt"
  2274. import "os"
  2275. import "os/signal"
  2276. import "syscall"
  2277. func main() {
  2278.     // Go信号通知通过向一个channel发送``os.Signal`来实现。
  2279.     // 我们将创建一个channel来接受这些通知,同时我们还用
  2280.     // 一个channel来在程序可以退出的时候通知我们
  2281.     sigs := make(chan os.Signal, 1)
  2282.     done := make(chan bool, 1)
  2283.     // `signal.Notify`在给定的channel上面注册该channel
  2284.     // 可以接受的信号
  2285.     signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
  2286.     // 这个goroutine阻塞等待信号的到来,当信号到来的时候,
  2287.     // 输出该信号,然后通知程序可以结束了
  2288.     go func() {
  2289.         sig := <-sigs
  2290.         fmt.Println()
  2291.         fmt.Println(sig)
  2292.         done <- true
  2293.     }()
  2294.     // 程序将等待接受信号,然后退出
  2295.     fmt.Println("awaiting signal")
  2296.     <-done
  2297.     fmt.Println("exiting")
  2298. }
  2299. 1
  2300. 2
  2301. 3

  2302. chan
  2303. package main

  2304. import (
  2305.     "fmt"
  2306. )

  2307. func main() {

  2308.     str1 := make(chan int, 2)
  2309.     str2 := make(chan int, 2)

  2310.     str1 <- 100
  2311.     str2 <- 0xff

  2312.     c1 := <-str1
  2313.     c2 := <-str2

  2314.     fmt.Printf("%d   %d", c1, c2)
  2315. }
  2316. 1
  2317. 2
  2318. 3

  2319. 账单的写入
  2320. package main

  2321. import (
  2322.     "fmt"
  2323.     _ "image/gif"
  2324.     _ "image/jpeg"
  2325.     _ "image/png"

  2326.     "github.com/360EntSecGroup-Skylar/excelize"
  2327.     "strconv"
  2328.     "io/ioutil"
  2329. )

  2330. var i = 1
  2331. var xlsx, _ = excelize.OpenFile("1.xlsx")

  2332. func main() {

  2333.     readDir("F:\\初见文件\\初见\\支付测试")

  2334.     xlsx.Save()

  2335. }

  2336. func readDir(dirPath string) {
  2337.     flist, e := ioutil.ReadDir(dirPath)

  2338.     if e != nil {
  2339.         fmt.Println("Read file error")
  2340.         return
  2341.     }

  2342.     for _, f := range flist {
  2343.         if f.IsDir() {

  2344.             readDir(dirPath + "/" + f.Name())
  2345.         } else {
  2346.             xlsx.AddPicture("Sheet1", "A"+strconv.Itoa(i), dirPath+"/"+f.Name(), `{"x_scale": 0.5, "y_scale": 0.5}`)
  2347.             i += 49
  2348.         }

  2349.     }
  2350. }
  2351. 1
  2352. 2
  2353. 3

  2354. 文件重命名
  2355. // 文件重命名
  2356. syscall.Rename("新建文本文档.txt","ms.txt")
  2357. 1
  2358. 2
  2359. 环境变量
  2360. //获取环境变量
  2361. fs := syscall.Environ()

  2362. //循环输出
  2363. for i = 0; i < len(fs); i++ {
  2364.     fmt.Println(fs[i])
  2365. }
  2366. 1
  2367. 2
  2368. 3
  2369. 4
  2370. 5
  2371. 6
  2372. 7
  2373. 删除文件
  2374. os.Remove("ms2.txt")
  2375. 1
  2376. 连接MySQL
  2377. package main

  2378. import (
  2379.     "database/sql"
  2380.     "fmt"
  2381.     _ "github.com/go-sql-driver/mysql"
  2382. )

  2383. func main() {
  2384.     db, err := sql.Open("mysql", "root:2018@/ms")//对应数据库的用户名和密码
  2385.     defer db.Close()
  2386.     if err != nil {
  2387.         panic(err)
  2388.     } else {
  2389.         fmt.Println("success")
  2390.     }
  2391.     rows, err := db.Query("SELECT * from tb_user ")
  2392.     if err != nil {
  2393.         panic(err)
  2394.         return
  2395.     }
  2396.     for rows.Next() {
  2397.         var name int
  2398.         err = rows.Scan(&name)
  2399.         if err != nil {
  2400.             panic(err)
  2401.         }
  2402.         fmt.Println(name)
  2403.     }
  2404. }
  2405. 1
  2406. 2
  2407. 3

  2408. Mysql 查询
  2409. package main

  2410. import (
  2411.     "database/sql"
  2412.     "fmt"
  2413.     _ "github.com/go-sql-driver/mysql"
  2414. )

  2415. func main() {
  2416.     db, _ := sql.Open("mysql", "root:2018@/ms")

  2417.     defer db.Close()

  2418.     rows, _ := db.Query("select * from tb_user;")

  2419.     defer rows.Close()

  2420.     cloumns, _ := rows.Columns()

  2421.     values := make([]sql.RawBytes, len(cloumns))

  2422.     scanArgs := make([]interface{}, len(values))

  2423.     for i := range values {
  2424.         scanArgs[i] = &values[i]
  2425.     }

  2426.     for rows.Next() {

  2427.         rows.Scan(scanArgs...)

  2428.         var value string

  2429.         for i, col := range values {

  2430.             if col == nil {

  2431.                 value = "NULL"

  2432.             } else {

  2433.                 value = string(col)

  2434.             }

  2435.             fmt.Println(cloumns[i], " --- ", value)
  2436.         }

  2437.     }

  2438. }
  2439. 1
  2440. 2
  2441. 3

  2442. 增删改
  2443. package main

  2444. import (
  2445.     "database/sql"
  2446.     _ "github.com/go-sql-driver/mysql"
  2447. )

  2448. func main() {
  2449.     db, _ := sql.Open("mysql", "root:2018@/ms")

  2450.     defer db.Close()

  2451.     stmt, _ := db.Prepare("INSERT INTO ms VALUES ('MS-1GOGOGO')")

  2452.     stmt.Exec()

  2453. }
  2454. 1
  2455. 2
  2456. 3

  2457. 正则表达式
  2458. package main
  2459. import "bytes"
  2460. import "fmt"
  2461. import "regexp"
  2462. func main() {
  2463.     // 测试模式是否匹配字符串,括号里面的意思是
  2464.     // 至少有一个a-z之间的字符存在
  2465.     match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
  2466.     fmt.Println(match)
  2467.     // 上面我们直接使用了字符串匹配的正则表达式,
  2468.     // 但是对于其他的正则匹配任务,你需要使用
  2469.     // `Compile`来使用一个优化过的正则对象
  2470.     r, _ := regexp.Compile("p([a-z]+)ch")
  2471.     // 正则结构体对象有很多方法可以使用,比如上面的例子
  2472.     // 也可以像下面这么写
  2473.     fmt.Println(r.MatchString("peach"))
  2474.     // 这个方法检测字符串参数是否存在正则所约束的匹配
  2475.     fmt.Println(r.FindString("peach punch"))
  2476.     // 这个方法查找第一次匹配的索引,并返回匹配字符串
  2477.     // 的起始索引和结束索引,而不是匹配的字符串
  2478.     fmt.Println(r.FindStringIndex("peach punch"))
  2479.     // 这个方法返回全局匹配的字符串和局部匹配的字符,比如
  2480.     // 这里会返回匹配`p([a-z]+)ch`的字符串
  2481.     // 和匹配`([a-z]+)`的字符串
  2482.     fmt.Println(r.FindStringSubmatch("peach punch"))
  2483.     // 和上面的方法一样,不同的是返回全局匹配和局部匹配的
  2484.     // 起始索引和结束索引
  2485.     fmt.Println(r.FindStringSubmatchIndex("peach punch"))
  2486.     // 这个方法返回所有正则匹配的字符,不仅仅是第一个
  2487.     fmt.Println(r.FindAllString("peach punch pinch", -1))
  2488.     // 这个方法返回所有全局匹配和局部匹配的字符串起始索引
  2489.     // 和结束索引
  2490.     fmt.Println(r.FindAllStringSubmatchIndex("peach punch pinch", -1))
  2491.     // 为这个方法提供一个正整数参数来限制匹配数量
  2492.     fmt.Println(r.FindAllString("peach punch pinch", 2))

  2493.     //上面我们都是用了诸如`MatchString`这样的方法,其实
  2494.     // 我们也可以使用`[]byte`作为参数,并且使用`Match`
  2495.     // 这样的方法名
  2496.     fmt.Println(r.Match([]byte("peach")))
  2497.     // 当使用正则表达式来创建常量的时候,你可以使用`MustCompile`
  2498.     // 因为`Compile`返回两个值
  2499.     r = regexp.MustCompile("p([a-z]+)ch")
  2500.     fmt.Println(r)
  2501.     // regexp包也可以用来将字符串的一部分替换为其他的值
  2502.     fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))
  2503.     // `Func`变量可以让你将所有匹配的字符串都经过该函数处理
  2504.     // 转变为所需要的值
  2505.     in := []byte("a peach")
  2506.     out := r.ReplaceAllFunc(in, bytes.ToUpper)
  2507.     fmt.Println(string(out))
  2508. }
  2509. 1
  2510. 2
  2511. 3
  2512. 4
  2513. 5
  2514. 6
  2515. 7
  2516. 8
  2517. 9
  2518. 10
  2519. 11
  2520. 12
  2521. 13
  2522. 14
  2523. 15
  2524. 16
  2525. 17
  2526. 18
  2527. 19
  2528. 20
  2529. 21
  2530. 22
  2531. 23
  2532. 24
  2533. 25
  2534. 26
  2535. 27
  2536. 28
  2537. 29
  2538. 30
  2539. 31
  2540. 32
  2541. 33
  2542. 34
  2543. 35
  2544. 36
  2545. 37
  2546. 38
  2547. 39
  2548. 40
  2549. 41
  2550. 42
  2551. 43
  2552. 44
  2553. 45
  2554. 46
  2555. 47
  2556. 48
  2557. 49
  2558. 50
  2559. 51
  2560. 52
  2561. 闭包
  2562. package main

  2563. import "fmt"

  2564. // 这个"intSeq"函数返回另外一个在intSeq内部定义的匿名函数,  
  2565. // 这个返回的匿名函数包住了变量i,从而形成了一个闭包  
  2566. func intSeq() func() int {
  2567.     i := 0
  2568.     return func() int {
  2569.         i += 1
  2570.         return i
  2571.     }
  2572. }
  2573. func main() {
  2574.     // 我们调用intSeq函数,并且把结果赋值给一个函数nextInt,  
  2575.     // 这个nextInt函数拥有自己的i变量,这个变量每次调用都被更新。  
  2576.     // 这里i的初始值是由intSeq调用的时候决定的。  
  2577.     nextInt := intSeq()
  2578.     // 调用几次nextInt,看看闭包的效果  
  2579.     fmt.Println(nextInt())
  2580.     fmt.Println(nextInt())
  2581.     fmt.Println(nextInt())
  2582.     // 为了确认闭包的状态是独立于intSeq函数的,再创建一个。  
  2583.     newInts := intSeq()
  2584.     fmt.Println(newInts())
  2585. }
  2586. 1
  2587. 2
  2588. 3
  2589. 4
  2590. 5
  2591. 6
  2592. 7
  2593. 8
  2594. 9
  2595. 10
  2596. 11
  2597. 12
  2598. 13
  2599. 14
  2600. 15
  2601. 16
  2602. 17
  2603. 18
  2604. 19
  2605. 20
  2606. 21
  2607. 22
  2608. 23
  2609. 24
  2610. 25
  2611. 26
  2612. sync
  2613. package main

  2614. import (
  2615.     "sync"
  2616.     "time"
  2617. )

  2618. var m *sync.RWMutex

  2619. var val = 0

  2620. func main() {

  2621.     m = new(sync.RWMutex)

  2622.     go read(1)

  2623.     go write(2)

  2624.     go read(3)

  2625.     time.Sleep(time.Second * 2)

  2626. }
  2627. func read(i int) {

  2628.     m.RLock()

  2629.     println("val: ", val)

  2630.     m.RUnlock()
  2631. }
  2632. func write(i int) {

  2633.     m.Lock()

  2634.     val = 10

  2635.     m.Unlock()
  2636. }
  2637. 1
  2638. 2
  2639. 3
  2640. 4
  2641. 5
  2642. 6
  2643. 7
  2644. 8
  2645. 9
  2646. 10
  2647. 11
  2648. 12
  2649. 13
  2650. 14
  2651. 15
  2652. 16
  2653. 17
  2654. 18
  2655. 19
  2656. 20
  2657. 21
  2658. 22
  2659. 23
  2660. 24
  2661. 25
  2662. 26
  2663. 27
  2664. 28
  2665. 29
  2666. 30
  2667. 31
  2668. 32
  2669. 33
  2670. 34
  2671. 35
  2672. 36
  2673. 37
  2674. 38
  2675. 39
  2676. 40
  2677. 创建文件夹
  2678. package main

  2679. import "os"

  2680. func main() {
  2681.     os.Mkdir("hello", 0777)
  2682. }
  2683. 1
  2684. 2
  2685. 3
  2686. 4
  2687. 5
  2688. 6
  2689. 7
  2690. 创建1024个文件夹,然后在删除
  2691. package main

  2692. import (
  2693.     "os"
  2694.     "strconv"
  2695.     "time"
  2696. )

  2697. func main() {
  2698.     for i := 0; i < 1024; i++ {
  2699.         os.Mkdir("hello"+strconv.Itoa(i), 0777)
  2700.     }

  2701.     time.Sleep(time.Second * 30)

  2702.     for i := 0; i < 1024; i++ {
  2703.         os.Remove("hello" + strconv.Itoa(i))
  2704.     }
  2705. }
  2706. 1
  2707. 2
  2708. 3
  2709. 4
  2710. 5
  2711. 6
  2712. 7
  2713. 8
  2714. 9
  2715. 10
  2716. 11
  2717. 12
  2718. 13
  2719. 14
  2720. 15
  2721. 16
  2722. 17
  2723. 18
  2724. 19
  2725. 简单的爬虫(抓取搜狗图片)
  2726. package main

  2727. import (
  2728.     "net/http"
  2729.     "strconv"
  2730.     "io/ioutil"
  2731.     "os"
  2732.     "fmt"
  2733. )

  2734. var start = 0

  2735. var len = start + 10

  2736. func main() {

  2737.     for {
  2738.         var url = "http://pic.sogou.com/pics/channel/getAllRecomPicByTag.jsp?category=%E5%A3%81%E7%BA%B8&tag=%E5%85%A8%E9%83%A8&start=" + strconv.Itoa(start) + "&len=" + strconv.Itoa(len)
  2739.         fmt.Println(url)
  2740.         res, _ := http.Get(url)
  2741.         reader, _ := ioutil.ReadAll(res.Body)
  2742.         var filename = strconv.Itoa(start) + ".json"
  2743.         os.Create(filename)
  2744.         ioutil.WriteFile(filename, reader, 0777)
  2745.         start = len
  2746.         len = start + 10
  2747.         if len > 1024 {
  2748.             break
  2749.         }

  2750.     }
  2751. }
  2752. 1
  2753. 2
  2754. 3
  2755. 4
  2756. 5
  2757. 6
  2758. 7
  2759. 8
  2760. 9
  2761. 10
  2762. 11
  2763. 12
  2764. 13
  2765. 14
  2766. 15
  2767. 16
  2768. 17
  2769. 18
  2770. 19
  2771. 20
  2772. 21
  2773. 22
  2774. 23
  2775. 24
  2776. 25
  2777. 26
  2778. 27
  2779. 28
  2780. 29
  2781. 30
  2782. 31
  2783. 32
  2784. 生成RSA 公钥和私钥
  2785. package main

  2786. import (
  2787.     "crypto/rsa"
  2788.     "crypto/x509"
  2789.     "encoding/pem"
  2790.     "crypto/rand"
  2791.     "flag"
  2792.     "log"
  2793.     "os"
  2794. )

  2795. func main() {
  2796.     var bits int
  2797.     flag.IntVar(&bits, "b", 2048, "密钥长度,默认为1024位")
  2798.     if err := GenRsaKey(bits); err != nil {
  2799.         log.Fatal("密钥文件生成失败!")
  2800.     }
  2801.     log.Println("密钥文件生成成功!")
  2802. }

  2803. func GenRsaKey(bits int) error {
  2804.     // 生成私钥文件
  2805.     privateKey, err := rsa.GenerateKey(rand.Reader, bits)
  2806.     if err != nil {
  2807.         return err
  2808.     }
  2809.     derStream := x509.MarshalPKCS1PrivateKey(privateKey)
  2810.     block := &pem.Block{
  2811.         Type:  "私钥",
  2812.         Bytes: derStream,
  2813.     }
  2814.     file, err := os.Create("private.pem")
  2815.     if err != nil {
  2816.         return err
  2817.     }
  2818.     err = pem.Encode(file, block)
  2819.     if err != nil {
  2820.         return err
  2821.     }
  2822.     // 生成公钥文件
  2823.     publicKey := &privateKey.PublicKey
  2824.     derPkix, err := x509.MarshalPKIXPublicKey(publicKey)
  2825.     if err != nil {
  2826.         return err
  2827.     }
  2828.     block = &pem.Block{
  2829.         Type:  "公钥",
  2830.         Bytes: derPkix,
  2831.     }
  2832.     file, err = os.Create("public.pem")
  2833.     if err != nil {
  2834.         return err
  2835.     }
  2836.     err = pem.Encode(file, block)
  2837.     if err != nil {
  2838.         return err
  2839.     }
  2840.     return nil
  2841. }
  2842. 1
  2843. 2
  2844. 3

  2845. 测试RSA
  2846. package main

  2847. import (
  2848.     "crypto/rand"
  2849.     "crypto/rsa"
  2850.     "crypto/x509"
  2851.     _ "encoding/base64"
  2852.     "encoding/pem"
  2853.     "errors"
  2854.     "flag"
  2855.     "fmt"
  2856.     "io/ioutil"
  2857.     "os"
  2858. )

  2859. var decrypted string
  2860. var privateKey, publicKey []byte

  2861. func init() {
  2862.     var err error
  2863.     flag.StringVar(&decrypted, "d", "", "加密过的数据")
  2864.     flag.Parse()
  2865.     publicKey, err = ioutil.ReadFile("public.pem")
  2866.     if err != nil {
  2867.         os.Exit(-1)
  2868.     }
  2869.     privateKey, err = ioutil.ReadFile("private.pem")
  2870.     if err != nil {
  2871.         os.Exit(-1)
  2872.     }
  2873. }

  2874. func main() {
  2875.     var data []byte
  2876.     var err error
  2877.     data, err = RsaEncrypt([]byte("ms~go"))
  2878.     if err != nil {
  2879.         panic(err)
  2880.     }
  2881.     origData, err := RsaDecrypt(data)
  2882.     if err != nil {
  2883.         panic(err)
  2884.     }
  2885.     fmt.Println(string(origData))
  2886. }

  2887. // 加密
  2888. func RsaEncrypt(origData []byte) ([]byte, error) {
  2889.     block, _ := pem.Decode(publicKey)
  2890.     if block == nil {
  2891.         return nil, errors.New("public key error")
  2892.     }
  2893.     pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
  2894.     if err != nil {
  2895.         return nil, err
  2896.     }
  2897.     pub := pubInterface.(*rsa.PublicKey)
  2898.     return rsa.EncryptPKCS1v15(rand.Reader, pub, origData)
  2899. }

  2900. // 解密
  2901. func RsaDecrypt(ciphertext []byte) ([]byte, error) {
  2902.     block, _ := pem.Decode(privateKey)
  2903.     if block == nil {
  2904.         return nil, errors.New("private key error!")
  2905.     }
  2906.     priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
  2907.     if err != nil {
  2908.         return nil, err
  2909.     }
  2910.     return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
  2911. }
  2912. 1
  2913. 2
  2914. 3

  2915. init 函数
  2916. package main

  2917. import "fmt"

  2918. func init() {
  2919.     fmt.Println("Hello INIT")
  2920. }

  2921. func main() {

  2922.     fmt.Println("main")
  2923. }
  2924. 1
  2925. 2
  2926. 3

  2927. init 优先执行main函数

  2928. 单例模式
  2929. package main

  2930. import (
  2931.     "fmt"
  2932. )

  2933. var m *Manager

  2934. func GetInstance() *Manager {
  2935.     if m == nil {
  2936.         m = &Manager{}
  2937.     }
  2938.     return m
  2939. }

  2940. type Manager struct{}

  2941. func (p Manager) Manage() {
  2942.     fmt.Println("manage...")
  2943. }

  2944. func main() {

  2945.     fmt.Printf("%p\n", GetInstance())
  2946.     fmt.Printf("%p\n", GetInstance())
  2947.     fmt.Printf("%p\n", GetInstance())
  2948.     fmt.Printf("%p\n", GetInstance())
  2949.     fmt.Printf("%p\n", GetInstance())

  2950. }
  2951. 1
  2952. 2
  2953. 3

  2954. 单例加锁
  2955. package main

  2956. import (
  2957.     "fmt"
  2958.     "sync"
  2959.     "time"
  2960. )

  2961. var m *Manager
  2962. var lock *sync.Mutex = &sync.Mutex{}

  2963. func GetInstance() *Manager {
  2964.     lock.Lock()
  2965.     defer lock.Unlock()
  2966.     if m == nil {
  2967.         m = &Manager{}
  2968.     }
  2969.     return m
  2970. }

  2971. type Manager struct{}

  2972. func (p Manager) Manage() {
  2973.     fmt.Println("manage...")
  2974. }
  2975. func main() {

  2976.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  2977.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  2978.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  2979.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  2980.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  2981.     fmt.Printf("%p\n", GetInstance())
  2982.     fmt.Printf("%p\n", GetInstance())
  2983.     fmt.Printf("%p\n", GetInstance())
  2984.     fmt.Printf("%p\n", GetInstance())
  2985.     time.Sleep(time.Second)

  2986. }
  2987. 1
  2988. 2
  2989. 3

  2990. 双重锁机制来提高效率
  2991. package main

  2992. import (
  2993.     "fmt"
  2994.     "sync"
  2995.     "time"
  2996. )

  2997. var m *Manager
  2998. var lock *sync.Mutex = &sync.Mutex {}

  2999. func GetInstance() *Manager {
  3000.     if m == nil {
  3001.         lock.Lock()
  3002.         defer lock.Unlock()
  3003.         if m == nil {
  3004.             m = &Manager {}
  3005.         }
  3006.     }

  3007.     return m
  3008. }

  3009. type Manager struct {}

  3010. func (p Manager) Manage() {
  3011.     fmt.Println("manage...")
  3012. }
  3013. func main() {

  3014.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3015.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3016.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3017.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3018.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3019.     fmt.Printf("%p\n", GetInstance())
  3020.     fmt.Printf("%p\n", GetInstance())
  3021.     fmt.Printf("%p\n", GetInstance())
  3022.     fmt.Printf("%p\n", GetInstance())
  3023.     time.Sleep(time.Second)

  3024. }
  3025. 1
  3026. 2
  3027. 3

  3028. sync.Once
  3029. package main

  3030. import (
  3031.     "fmt"
  3032.     "sync"
  3033.     "time"
  3034. )

  3035. var m *Manager
  3036. var once sync.Once

  3037. func GetInstance() *Manager {
  3038.     once.Do(func() {
  3039.         m = &Manager{}
  3040.     })
  3041.     return m
  3042. }

  3043. type Manager struct{}

  3044. func (p Manager) Manage() {
  3045.     fmt.Println("manage...")
  3046. }
  3047. func main() {

  3048.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3049.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3050.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3051.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3052.     go func() { fmt.Printf("%p\n", GetInstance()) }()
  3053.     fmt.Printf("%p\n", GetInstance())
  3054.     fmt.Printf("%p\n", GetInstance())
  3055.     fmt.Printf("%p\n", GetInstance())
  3056.     fmt.Printf("%p\n", GetInstance())
  3057.     time.Sleep(time.Second)

  3058. }
  3059. 1
  3060. 2
  3061. 3

  3062. 文件拷贝
  3063. package main

  3064. import (
  3065.     "fmt"
  3066.     "io"
  3067.     "os"
  3068. )

  3069. func main() {
  3070.     CopyFile("1private.pem", "private.pem") // os.Args[1]为目标文件,os.Args[2]为源文件
  3071.     fmt.Println("复制完成")
  3072. }
  3073. func CopyFile(dstName, srcName string) (written int64, err error) {
  3074.     src, err := os.Open(srcName)
  3075.     if err != nil {
  3076.         return
  3077.     }
  3078.     defer src.Close()
  3079.     dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
  3080.     if err != nil {
  3081.         return
  3082.     }
  3083.     defer dst.Close()
  3084.     return io.Copy(dst, src)
  3085. }
  3086. ---------------------
  3087. 作者:ms-go
  3088. 来源:CSDN
  3089. 原文:https://blog.csdn.net/mhw828/article/details/80703706
  3090. 版权声明:本文为博主原创文章,转载请附上博文链接!
复制代码

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

快速回复 返回顶部 返回列表