国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Go語言的變量、函數(shù)、Socks5代理服務器

simon_chen / 3103人閱讀

摘要:還有一種情況就是當你在一行中寫了多個語句,也需要使用分號來分開由于語言詞法分析器添加分號的特殊性,所以在有些情況下需要注意你都不應該將一個控制結構或的左大括號放在下一行。

Go語言中變量的聲明和JavaScript很像,使用var關鍵字,變量的聲明、定義有好幾種形式

1. 變量和常量

// 聲明并初始化一個變量

var m int = 10

// 聲明初始化多個變量

var i, j, k = 1, 2, 3

// 多個變量的聲明(注意小括號的使用)

var(
no int
name string
)

// 聲明時不指明類型,通過初始化值來推導

var b = true // bool型

// := 隱含聲明變量并賦值

str := "mimvp.com" // 等價于var str string = "mimvp.com"

Go 語言中 = 和 := 有什么區(qū)別?

= 是賦值, := 是聲明變量并賦值

</>復制代碼

  1. // = 使用必須使用先var聲明例如:
  2. var a
  3. a = 100
  4. // 或
  5. var b = 100
  6. // 或
  7. var c int = 100
  8. // := 是聲明并賦值,并且系統(tǒng)自動推斷類型,不需要var關鍵字
  9. d := 100
  10. // Go中有一個特殊的變量下劃線"_" 表示任何賦給它的值將被丟棄
  11. _, Ret:= 2, 3 // 2賦值被丟棄

Go語言的編譯器,對聲明卻未使用的變量在報錯,因此變量聲明了就必須使用,如果要使用變量也必須先聲明

Go語言和C語言一樣,Go語言中也是使用分號來終結語句。但是和C語言不同的是,Go語言的詞法分析器在掃描源代碼的過程中使用簡單的規(guī)則自動插入分號,因此在編寫源代碼的多數(shù)時候就不需要加分號了

Go語言詞法分析器插入分號的規(guī)則:如果在一個新行前方的最后一個標記是一個標識符(包括像int和float64這樣的單詞)、一個基本的如數(shù)值這樣的文字、或以下標記中的一個時,會自動插入分號

Go語言通常僅在for語句中使用分號,以此來分開初始化器、添加和增量。還有一種情況就是當你在一行中寫了多個語句,也需要使用分號來分開

由于Go語言詞法分析器添加分號的特殊性,所以在有些情況下需要注意:

你都不應該將一個控制結構(if、for、switch或select)的左大括號放在下一行。

如果這樣做,將會在大括號的前方插入一個分號,這可能導致出現(xiàn)不想要的結果。

常量:在程序不能被改變的值,一般都定義為數(shù)值,布爾值,字符串等

格式:const constName [type] = val

1). var num = 3 // 實際上 3 也稱為常量

2). 格式中 val 可以是表達式,但不能為運行時才能知道結果的表達式

3). 預定義常量: true / false / iota

4). 定義多個常量時,也可用下面方式

</>復制代碼

  1. const (
  2. constName1 [type] = val1
  3. constName2 [type] = val2
  4. )

示例代碼:

</>復制代碼

  1. /**
  2. * mimvp.com
  3. * 2017.1.20
  4. */
  5. // 聲明當前文件所屬的包名,main是一個可獨立運行的包,編譯后會生成可執(zhí)行文件
  6. package main
  7. import "fmt" // 導入包
  8. var id = 123456
  9. /*
  10. id2 := 654321
  11. // 在函數(shù)外用 := ,編譯時會出現(xiàn)錯誤,局部變量聲明應在函數(shù)內(nèi)部
  12. // non-declaration statement outside function body
  13. */
  14. const PI = 3.14 // 常量聲明
  15. // 每個可獨立運行的程序,都包含入口函數(shù) main ,與其他語言相同,但無參數(shù)和返回值
  16. func main() {
  17. var num int
  18. num = 100
  19. fmt.Println(num) // 輸出 100
  20. var num1, num2 int
  21. num1, num2 = 1, 2
  22. fmt.Println(num1, num2) // 輸出 1 2
  23. var no1, no2 = 3, 4
  24. fmt.Println(no1, no2) // 輸出 3 4
  25. n1, n2 := 5, 6
  26. fmt.Println(n1, n2) // 輸出 5 6
  27. _, n := 7, 8
  28. fmt.Println(n) // 輸出 8
  29. var (
  30. key1 string
  31. key2 string
  32. )
  33. key1, key2 = "k1", "k2"
  34. fmt.Println(key1, key2) // 輸出 k1 k2
  35. var (
  36. a = 9
  37. b = 10
  38. )
  39. fmt.Println(a, b) // 輸出 9 10
  40. fmt.Println(id) // 輸出 123456
  41. fmt.Println(PI) // 輸出 3.14
  42. /*
  43. PI = 3.1415
  44. // 改變常量的值,編譯會出現(xiàn)錯誤
  45. // cannot assign to PI
  46. // cannot use 3.1415 (type float64) as type ideal in assignment
  47. */
  48. }

2. 函數(shù)使用

1)Go語言函數(shù)格式

</>復制代碼

  1. func GetMsg(i int) (str string) {
  2. fmt.Println(i)
  3. str = "hello mimvp.com"
  4. return str
  5. }

解釋說明:

func 說明這是個函數(shù)

GetMsg是函數(shù)名

(i int) 函數(shù)接收一個int參數(shù),是傳入?yún)?shù)

(str string) 函數(shù)返回一個string類型返回值,是返回參數(shù)

2)Go語言函數(shù)可返回多個值

函數(shù)返回多個值,跟Java、PHP、C等主流語言都不一樣,但和Python、lua等腳本語言是一樣的

</>復制代碼

  1. func GetMsg(i int) (str string, err string) {
  2. fmt.Println(i)
  3. str = "hello mimvp.com"
  4. err = "no err"
  5. return str, err
  6. }
  7. func main() {
  8. fmt.Println(GetMsg(100))
  9. }

編譯執(zhí)行:

</>復制代碼

  1. $ go build mimvp_func.go
  2. $ ./mimvp_func
  3. 100
  4. hello mimvp.com no err

3)defer的使用

defer的意思是"在函數(shù)退出時調(diào)用",特別用于對文件進行讀寫操作的時候,需要在open之后要調(diào)用close操作,將close操作使用defer

</>復制代碼

  1. func ReadFile(filePath string)(){
  2. file.Open(filePath)
  3. defer file.Close()
  4. if true {
  5. file.Read()
  6. } else {
  7. return false
  8. }
  9. }

上述代碼含義是在file.Open后不立即調(diào)用close,當return false的時候調(diào)用file.Close(),這樣就有效避免了C語言中的內(nèi)存泄露問題。

4)理解 panic,recover

上面講述了很多變量和函數(shù),還沒介紹 throw - try - catch 的用法

Go語言里,Panic和Recover就是其他語言中的throw和catch

示例代碼:

</>復制代碼

  1. package main
  2. import "fmt"
  3. func main() {
  4. f()
  5. fmt.Println("Returned normally from f.")
  6. }
  7. func f() {
  8. defer func() {
  9. if r := recover(); r != nil {
  10. fmt.Println("Recovered in f", r)
  11. }
  12. }()
  13. fmt.Println("Calling g.")
  14. g(0)
  15. fmt.Println("Returned normally from g.")
  16. }
  17. func g(i int) {
  18. if i > 3 {
  19. fmt.Println("Panicking!")
  20. panic(fmt.Sprintf("%v", i))
  21. }
  22. defer fmt.Println("Defer in g", i)
  23. fmt.Println("Printing in g", i)
  24. g(i + 1)
  25. }

運行結果:

</>復制代碼

  1. $ ./mimvp-try-catch
  2. Calling g.
  3. Printing in g 0
  4. Printing in g 1
  5. Printing in g 2
  6. Printing in g 3
  7. Panicking!
  8. Defer in g 3
  9. Defer in g 2
  10. Defer in g 1
  11. Defer in g 0
  12. Recovered in f 4
  13. Returned normally from f.

Panic拋出了信息,并且跳出函數(shù)。Recover接受到了信息,并且繼續(xù)處理。

這個例子理解了基本就掌握了Recover和Panic

3. Socks5代理服務器

</>復制代碼

  1. package main
  2. import (
  3. "net"
  4. "fmt"
  5. "io"
  6. "bytes"
  7. "encoding/binary"
  8. )
  9. type Methods struct{
  10. ver, nmethods uint8
  11. methods uint8
  12. }
  13. type sock5cmd struct{
  14. ver, cmd, rsv, atyp uint8
  15. dst [255]uint8
  16. }
  17. type proxyCoder struct {
  18. conn net.Conn
  19. }
  20. func (c *proxyCoder) readMethods() Methods {
  21. var m Methods
  22. b := make([]byte, 1024)
  23. n, err := c.conn.Read(b)
  24. if err != nil && err != io.EOF { panic(err) }
  25. buf := bytes.NewBuffer(b[0:n])
  26. err = binary.Read(buf, binary.LittleEndian, &m.ver)
  27. if err != nil {
  28. fmt.Println("binary.Read failed:", err)
  29. }
  30. err = binary.Read(buf, binary.LittleEndian, &m.nmethods)
  31. if err != nil {
  32. fmt.Println("binary.Read failed:", err)
  33. }
  34. err = binary.Read(buf, binary.BigEndian, &m.methods)
  35. if err != nil {
  36. fmt.Println("binary.Read failed:", err)
  37. }
  38. return m
  39. }
  40. func (c *proxyCoder) returnMethod() {
  41. buf := make([]byte, 2)
  42. buf[0] = 5
  43. buf[1] = 0
  44. c.conn.Write(buf)
  45. fmt.Println(buf)
  46. }
  47. func (c *proxyCoder) serve() {
  48. buf := make([]byte, 128)
  49. n, err := c.conn.Read(buf)
  50. if err != nil && err != io.EOF { panic(err) }
  51. fmt.Println(buf[:n])
  52. var s string
  53. var t string
  54. var i int
  55. if(buf[3] == 3){//domail
  56. for i = 4; i < n-2; i++ {
  57. s += fmt.Sprintf("%c", buf[i])
  58. }
  59. } else {//ip4 or ip6
  60. s += fmt.Sprintf("%d", buf[4])
  61. for i = 5; i < n-2; i++ {
  62. s += fmt.Sprintf(".%d", buf[i])
  63. }
  64. }
  65. p := make([]byte, 2)
  66. var port uint16
  67. p[1] = buf[n-1]
  68. p[0] = buf[n-2]
  69. b := bytes.NewBuffer(p)
  70. err = binary.Read(b, binary.BigEndian, &port)
  71. if err != nil {
  72. fmt.Println("binary.Read failed:", err)
  73. }
  74. s += fmt.Sprintf(":%d", port)
  75. switch buf[1] {
  76. case 1://TCP
  77. t = "tcp"
  78. case 2://BIND
  79. case 3://UDP
  80. t = "udp"
  81. }
  82. conn, err := net.Dial(t, s)
  83. if err != nil {
  84. fmt.Printf("%s connect error %s
  85. ", t, s)
  86. buf[1] = 4
  87. c.conn.Write(buf[:n])
  88. c.conn.Close()
  89. return
  90. }
  91. buf[1] = 0
  92. c.conn.Write(buf[:n])
  93. fmt.Printf("%s connect success %s
  94. ", t, s)
  95. go serv(conn, c.conn)
  96. go serv(c.conn, conn)
  97. }
  98. func serv(in net.Conn, out net.Conn){
  99. b := make([]byte, 10240)
  100. for ;;{
  101. n, err := in.Read(b)
  102. if( err != nil ){
  103. fmt.Printf("close
  104. ")
  105. in.Close()
  106. out.Close()
  107. return
  108. }
  109. fmt.Printf("serv %d
  110. ", n)
  111. out.Write(b[:n]);
  112. }
  113. }
  114. type Proxy struct {
  115. }
  116. func NewProxy() *Proxy {
  117. return &Proxy{}
  118. }
  119. var DefaultProxy = NewProxy()
  120. func (p *Proxy) ProxyConn(conn net.Conn ){
  121. c := &proxyCoder{conn}
  122. m := c.readMethods()
  123. fmt.Println(m)
  124. c.returnMethod()
  125. c.serve()
  126. }
  127. func handleConnection(conn net.Conn){
  128. buf := make([]byte, 1024)
  129. n, err := conn.Read(buf)
  130. if err != nil && err != io.EOF { panic(err) }
  131. fmt.Println(buf[:n])
  132. //answer
  133. buf[0] = 5
  134. buf[1] = 0
  135. conn.Write(buf[:2])
  136. fmt.Println(buf[:2])
  137. //serve
  138. n, err = conn.Read(buf)
  139. if err != nil && err != io.EOF { panic(err) }
  140. fmt.Println(buf[:n])
  141. conn.Close()
  142. }
  143. func main() {
  144. ln, err := net.Listen("tcp", ":1080")
  145. if err != nil {
  146. fmt.Printf("bind error
  147. ")
  148. return
  149. }
  150. for {
  151. conn, err := ln.Accept()
  152. if err != nil {
  153. fmt.Printf("accept error
  154. ")
  155. continue
  156. }
  157. go DefaultProxy.ProxyConn(conn)
  158. //go handleConnection(conn)
  159. }
  160. }

文章版權歸作者所有,未經(jīng)允許請勿轉載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/51334.html

相關文章

  • Go語言變量函數(shù)Socks5代理務器

    摘要:還有一種情況就是當你在一行中寫了多個語句,也需要使用分號來分開由于語言詞法分析器添加分號的特殊性,所以在有些情況下需要注意你都不應該將一個控制結構或的左大括號放在下一行。 Go語言中變量的聲明和JavaScript很像,使用var關鍵字,變量的聲明、定義有好幾種形式 1. 變量和常量 // 聲明并初始化一個變量 var m int = 10 // 聲明初始化多個變量 var i, j...

    Ajian 評論0 收藏0
  • Linux Shell curl 和 wget 使用代理IP

    摘要:米撲代理示例,測試使用的代理,全部來自于米撲代理,其覆蓋多個國家,中國個省市,支持等米撲代理示例官網(wǎng)參考推薦米撲代理之使用示例推薦抓取網(wǎng)頁實例代理篩選系統(tǒng) Linux Shell 提供兩個非常實用的命令來爬取網(wǎng)頁,它們分別是 curl 和 wget curl 和 wget 使用代理 curl 支持 http、https、socks4、socks5 wget 支持 http、https...

    microcosm1994 評論0 收藏0
  • Linux Shell curl 和 wget 使用代理IP

    摘要:米撲代理示例,測試使用的代理,全部來自于米撲代理,其覆蓋多個國家,中國個省市,支持等米撲代理示例官網(wǎng)參考推薦米撲代理之使用示例推薦抓取網(wǎng)頁實例代理篩選系統(tǒng) Linux Shell 提供兩個非常實用的命令來爬取網(wǎng)頁,它們分別是 curl 和 wget curl 和 wget 使用代理 curl 支持 http、https、socks4、socks5 wget 支持 http、https...

    BLUE 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<