Go語言中變量、函數(shù)、Socks5代理服務器的示例分析

小編給大家分享一下Go語言中變量、函數(shù)、Socks5代理服務器的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

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ū)別？

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

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

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

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

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

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

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

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

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

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

格式：const constName [type] = val

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

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

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

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

const ( 
 constName1 [type] = val1 
 constName2 [type] = val2 
)

示例代碼：

/**
* mimvp.com
* 2017.1.20
*/
// 聲明當前文件所屬的包名，main是一個可獨立運行的包，編譯后會生成可執(zhí)行文件 
package main 
import "fmt" // 導入包 
var id = 123456 
/* 
id2 := 654321 
// 在函數(shù)外用 := ，編譯時會出現(xiàn)錯誤，局部變量聲明應在函數(shù)內(nèi)部
// non-declaration statement outside function body 
*/ 
const PI = 3.14  // 常量聲明
// 每個可獨立運行的程序，都包含入口函數(shù) main ，與其他語言相同，但無參數(shù)和返回值 
func main() { 
 var num int 
 num = 100 
 fmt.Println(num)  // 輸出 100 
 var num1, num2 int 
 num1, num2 = 1, 2 
 fmt.Println(num1, num2) // 輸出 1 2 
 var no1, no2 = 3, 4 
 fmt.Println(no1, no2)  // 輸出 3 4 
 n1, n2 := 5, 6 
 fmt.Println(n1, n2)  // 輸出 5 6 
 _, n := 7, 8 
 fmt.Println(n)    // 輸出 8 
 var ( 
  key1 string 
  key2 string 
 ) 
 key1, key2 = "k1", "k2" 
 fmt.Println(key1, key2) // 輸出 k1 k2 
 var ( 
  a = 9 
  b = 10 
 ) 
 fmt.Println(a, b)   // 輸出 9 10 
 fmt.Println(id)   // 輸出 123456 
 fmt.Println(PI)   // 輸出 3.14 
 /* 
 PI = 3.1415 
 // 改變常量的值，編譯會出現(xiàn)錯誤 
 // cannot assign to PI 
 // cannot use 3.1415 (type float64) as type ideal in assignment 
 */ 
}

2. 函數(shù)使用

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

func GetMsg(i int) (str string) {
 fmt.Println(i)
 str = "hello mimvp.com"
 return str
}

解釋說明：

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等腳本語言是一樣的

<span >vim mimvp_func.go</span>
func GetMsg(i int) (str string, err string) {
 fmt.Println(i)
 str = "hello mimvp.com"
 err = "no err"
 return str, err
}
func main() {
 fmt.Println(GetMsg(100))
}

編譯執(zhí)行：

$ go build mimvp_func.go 
$ ./mimvp_func   
100
hello mimvp.com no err

3）defer的使用

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

func ReadFile(filePath string)(){
 file.Open(filePath)
 defer file.Close()
  
 if true {
  file.Read()
 } else {
  return false
 }
}

上述代碼含義是在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

示例代碼：

package main
import "fmt"
func main() {
 f()
 fmt.Println("Returned normally from f.")
}
func f() {
 defer func() {
  if r := recover(); r != nil {
   fmt.Println("Recovered in f", r)
  }
 }()
 fmt.Println("Calling g.")
 g(0)
 fmt.Println("Returned normally from g.")
}
func g(i int) {
 if i > 3 {
  fmt.Println("Panicking!")
  panic(fmt.Sprintf("%v", i))
 }
 defer fmt.Println("Defer in g", i)
 fmt.Println("Printing in g", i)
 g(i + 1)
}

運行結(jié)果：

$ ./mimvp-try-catch   
Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.

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

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

3. Socks5代理服務器

package main
import (
 "net"
 "fmt"
 "io"
 "bytes"
 "encoding/binary"
)
type Methods struct{
 ver, nmethods uint8
 methods uint8
}
type sock5cmd struct{
 ver, cmd, rsv, atyp uint8
 dst [255]uint8
}
type proxyCoder struct {
 conn net.Conn
}
func (c *proxyCoder) readMethods() Methods {
 var m Methods
 b := make([]byte, 1024)
 n, err := c.conn.Read(b)
 if err != nil && err != io.EOF { panic(err) }
 buf := bytes.NewBuffer(b[0:n])
 err = binary.Read(buf, binary.LittleEndian, &m.ver)
 if err != nil {
  fmt.Println("binary.Read failed:", err)
 }
 err = binary.Read(buf, binary.LittleEndian, &m.nmethods)
 if err != nil {
  fmt.Println("binary.Read failed:", err)
 }
 err = binary.Read(buf, binary.BigEndian, &m.methods)
 if err != nil {
  fmt.Println("binary.Read failed:", err)
 }
 return m
}
func (c *proxyCoder) returnMethod() {
 buf := make([]byte, 2)
 buf[0] = 5
 buf[1] = 0
 c.conn.Write(buf)
 fmt.Println(buf)
}
func (c *proxyCoder) serve() {
 buf := make([]byte, 128)
 n, err := c.conn.Read(buf)
 if err != nil && err != io.EOF { panic(err) }
 fmt.Println(buf[:n])
 var s string
 var t string
 var i int
 if(buf[3] == 3){//domail
  for i = 4; i < n-2; i++ {
   s += fmt.Sprintf("%c", buf[i])
  }
 } else {//ip4 or ip6
  s += fmt.Sprintf("%d", buf[4])
  for i = 5; i < n-2; i++ {
   s += fmt.Sprintf(".%d", buf[i])
  }
 }
 p := make([]byte, 2)
 var port uint16
 p[1] = buf[n-1]
 p[0] = buf[n-2]
 b := bytes.NewBuffer(p)
 err = binary.Read(b, binary.BigEndian, &port)
 if err != nil {
  fmt.Println("binary.Read failed:", err)
 }
 s += fmt.Sprintf(":%d", port)
 switch buf[1] {
  case 1://TCP
   t = "tcp"
  case 2://BIND
  case 3://UDP
   t = "udp"
 }
 conn, err := net.Dial(t, s)
 if err != nil {
  fmt.Printf("%s connect error %s\n", t, s)
  buf[1] = 4
  c.conn.Write(buf[:n])
  c.conn.Close()
  return
 }
 buf[1] = 0
 c.conn.Write(buf[:n])
 fmt.Printf("%s connect success %s\n", t, s)
 go serv(conn, c.conn)
 go serv(c.conn, conn)
}
func serv(in net.Conn, out net.Conn){
 b := make([]byte, 10240)
 for ;;{
  n, err := in.Read(b)
  if( err != nil ){
   fmt.Printf("close\n")
   in.Close()
   out.Close()
   return
  }
  fmt.Printf("serv %d\n", n)
  out.Write(b[:n]);
 }
}
type Proxy struct {
}
func NewProxy() *Proxy {
 return &Proxy{}
}
var DefaultProxy = NewProxy()
func (p *Proxy) ProxyConn(conn net.Conn ){
 c := &proxyCoder{conn}
 m := c.readMethods()
 fmt.Println(m)
 c.returnMethod()
 c.serve()
}
func handleConnection(conn net.Conn){
 buf := make([]byte, 1024)
 n, err := conn.Read(buf)
 if err != nil && err != io.EOF { panic(err) }
 fmt.Println(buf[:n])
 //answer
 buf[0] = 5
 buf[1] = 0
 conn.Write(buf[:2])
 fmt.Println(buf[:2])
 //serve
 n, err = conn.Read(buf)
 if err != nil && err != io.EOF { panic(err) }
 fmt.Println(buf[:n])
 conn.Close()
}
func main() {
 ln, err := net.Listen("tcp", ":1080")
 if err != nil {
  fmt.Printf("bind error\n")
  return
 }
 for {
  conn, err := ln.Accept()
  if err != nil {
   fmt.Printf("accept error\n")
   continue
  }
  go DefaultProxy.ProxyConn(conn)
  //go handleConnection(conn)
 }
}

以上是“Go語言中變量、函數(shù)、Socks5代理服務器的示例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業(yè)資訊頻道！