go語言中的Sprintf,是否是安全的

printf函數與sprintf不同之處有： （1）函數的聲明不同 int printf(const char *format [, argument]);int sprintf(char *buffer, const char *format [, argument] );sprintf比printf多一個參數buffer，這個參數的作用見（2）的描述。 （

創(chuàng)新互聯(lián)成立十年來，這條路我們正越走越好，積累了技術與客戶資源，形成了良好的口碑。為客戶提供網站設計制作、做網站、網站策劃、網頁設計、國際域名空間、網絡營銷、VI設計、網站改版、漏洞修補等服務。網站是否美觀、功能強大、用戶體驗好、性價比高、打開快等等，這些對于網站建設都非常重要，創(chuàng)新互聯(lián)通過對建站技術性的掌握、對創(chuàng)意設計的研究為客戶提供一站式互聯(lián)網解決方案，攜手廣大客戶，共同發(fā)展進步。

基礎知識 - Golang 中的格式化輸入輸出

【格式化輸出】

// 格式化輸出：將 arg 列表中的 arg 轉換為字符串輸出

// 使用動詞 v 格式化 arg 列表，非字符串元素之間添加空格

Print(arg列表)

// 使用動詞 v 格式化 arg 列表，所有元素之間添加空格，結尾添加換行符

Println(arg列表)

// 使用格式字符串格式化 arg 列表

Printf(格式字符串, arg列表)

// Print 類函數會返回已處理的 arg 數量和遇到的錯誤信息。

【格式字符串】

格式字符串由普通字符和占位符組成，例如：

"abc%+ #8.3[3]vdef"

其中 abc 和 def 是普通字符，其它部分是占位符，占位符以 % 開頭（注：%% 將被轉義為一個普通的 % 符號，這個不算開頭），以動詞結尾，格式如下：

%[旗標][寬度][.精度][arg索引]動詞

方括號中的內容可以省略。

【旗標】

旗標有以下幾種：

空格：對于數值類型的正數，保留一個空白的符號位（其它用法在動詞部分說明）。

0 ：用 0 進行寬度填充而不用空格，對于數值類型，符號將被移到所有 0 的前面。

其中 "0" 和 "-" 不能同時使用，優(yōu)先使用 "-" 而忽略 "0"。

【寬度和精度】

“寬度”和“精度”都可以寫成以下三種形式：

數值 | * | arg索引*

其中“數值”表示使用指定的數值作為寬度值或精度值，“ ”表示使用當前正在處理的 arg 的值作為寬度值或精度值，如果這樣的話，要格式化的 arg 將自動跳轉到下一個。“arg索引 ”表示使用指定 arg 的值作為寬度值或精度值，如果這樣的話，要格式化的 arg 將自動跳轉到指定 arg 的下一個。

寬度值：用于設置最小寬度。

精度值：對于浮點型，用于控制小數位數，對于字符串或字節(jié)數組，用于控制字符數量（不是字節(jié)數量）。

對于浮點型而言，動詞 g/G 的精度值比較特殊，在適當的情況下，g/G 會設置總有效數字，而不是小數位數。

【arg 索引】

“arg索引”由中括號和 arg 序號組成（就像上面示例中的 [3]），用于指定當前要處理的 arg 的序號，序號從 1 開始：

'[' + arg序號 + ']'

【動詞】

“動詞”不能省略，不同的數據類型支持的動詞不一樣。

[通用動詞]

v：默認格式，不同類型的默認格式如下：

布爾型：t

整　型：d

浮點型：g

復數型：g

字符串：s

通　道：p

指　針：p

無符號整型：x

T：輸出 arg 的類型而不是值（使用 Go 語法格式）。

[布爾型]

t：輸出 true 或 false 字符串。

[整型]

b/o/d：輸出 2/8/10 進制格式

x/X ：輸出 16 進制格式（小寫/大寫）

c ：輸出數值所表示的 Unicode 字符

q ：輸出數值所表示的 Unicode 字符（帶單引號）。對于無法顯示的字符，將輸出其轉義字符。

U ：輸出 Unicode 碼點（例如 U+1234，等同于字符串 "U+%04X" 的顯示結果）

對于 o/x/X：

如果使用 "#" 旗標，則會添加前導 0 或 0x。

對于 U：

如果使用 "#" 旗標，則會在 Unicode 碼點后面添加相應的 '字符'（前提是該字符必須可顯示）

[浮點型和復數型]

b ：科學計數法（以 2 為底）

e/E：科學計數法（以 10 為底，小寫 e/大寫 E）

f/F：普通小數格式（兩者無區(qū)別）

g/G：大指數（指數 = 6）使用 %e/%E，其它情況使用 %f/%F

[字符串或字節(jié)切片]

s ：普通字符串

q ：雙引號引起來的 Go 語法字符串

x/X：十六進制編碼（小寫/大寫，以字節(jié)為元素進行編碼，而不是字符）

對于 q：

如果使用了 "+" 旗標，則將所有非 ASCII 字符都進行轉義處理。

如果使用了 "#" 旗標，則輸出反引號引起來的字符串（前提是

字符串中不包含任何制表符以外的控制字符，否則忽略 # 旗標）

對于 x/X：

如果使用了 " " 旗標，則在每個元素之間添加空格。

如果使用了 "#" 旗標，則在十六進制格式之前添加 0x 前綴。

[指針類型]

p ：帶 0x 前綴的十六進制地址值。

[符合類型]

復合類型將使用不同的格式輸出，格式如下：

結　構　體：{字段1 字段2 ...}

數組或切片：[元素0 元素1 ...]

映　射：map[鍵1:值1 鍵2:值2 ...]

指向符合元素的指針：{}, [], map[]

復合類型本身沒有動詞，動詞將應用到復合類型的元素上。

結構體可以使用 "+v" 同時輸出字段名。

【注意】

1、如果 arg 是一個反射值，則該 arg 將被它所持有的具體值所取代。

2、如果 arg 實現(xiàn)了 Formatter 接口，將調用它的 Format 方法完成格式化。

3、如果 v 動詞使用了 # 旗標（%#v），并且 arg 實現(xiàn)了 GoStringer 接口，將調用它的 GoString 方法完成格式化。

如果格式化操作指定了字符串相關的動詞（比如 %s、%q、%v、%x、%X），接下來的兩條規(guī)則將適用：

4。如果 arg 實現(xiàn)了 error 接口，將調用它的 Error 方法完成格式化。

5。如果 arg 實現(xiàn)了 string 接口，將調用它的 String 方法完成格式化。

在實現(xiàn)格式化相關接口的時候，要避免無限遞歸的情況，比如：

type X string

func (x X) String() string {

return Sprintf("%s", x)

}

在格式化之前，要先轉換數據類型，這樣就可以避免無限遞歸：

func (x X) String() string {

return Sprintf("%s", string(x))

}

無限遞歸也可能發(fā)生在自引用數據類型上面，比如一個切片的元素引用了切片自身。這種情況比較罕見，比如：

a := make([]interface{}, 1)

a[0] = a

fmt.Println(a)

【格式化輸入】

// 格式化輸入：從輸入端讀取字符串（以空白分隔的值的序列），

// 并解析為具體的值存入相應的 arg 中，arg 必須是變量地址。

// 字符串中的連續(xù)空白視為單個空白，換行符根據不同情況處理。

// \r\n 被當做 \n 處理。

// 以動詞 v 解析字符串，換行視為空白

Scan(arg列表)

// 以動詞 v 解析字符串，換行結束解析

Scanln(arg列表)

// 根據格式字符串中指定的格式解析字符串

// 格式字符串中的換行符必須和輸入端的換行符相匹配。

Scanf(格式字符串, arg列表)

// Scan 類函數會返回已處理的 arg 數量和遇到的錯誤信息。

【格式字符串】

格式字符串類似于 Printf 中的格式字符串，但下面的動詞和旗標例外：

p ：無效

T ：無效

e/E/f/F/g/G：功能相同，都是掃描浮點數或復數

s/v ：對字符串而言，掃描一個被空白分隔的子串

對于整型 arg 而言，v 動詞可以掃描帶有前導 0 或 0x 的八進制或十六進制數值。

寬度被用來指定最大掃描寬度（不會跨越空格），精度不被支持。

如果 arg 實現(xiàn)了 Scanner 接口，將調用它的 Scan 方法掃描相應數據。只有基礎類型和實現(xiàn)了 Scanner 接口的類型可以使用 Scan 類方法進行掃描。

【注意】

連續(xù)調用 FScan 可能會丟失數據，因為 FScan 中使用了 UnreadRune 對讀取的數據進行撤銷，而參數 io.Reader 只有 Read 方法，不支持撤銷。比如：

Go語言輸出打印--排坑

一.幾種公共方法

1)Print:???輸出到控制臺(不接受任何格式化，它等價于對每一個操作數都應用?%v)

print 在golang中?是屬于輸出到標準錯誤流中并打印,官方不建議寫程序時候用它。可以再debug時候用

2)Println:?輸出到控制臺并換行

3)Printf :?只可以打印出格式化的字符串。只可以直接輸出字符串類型的變量（不可以輸出整形變量和整形等）

4)Sprintf：格式化并返回一個字符串而不帶任何輸出

5)Fprintf：來格式化并輸出到 io.Writers 而不是 os.Stdout

二.帶占位符輸出--網址：? ??

和python差不多的道理，這里簡單補充

v ????值的默認格式

%+v???添加字段名(如結構體)

%#v　?相應值的Go語法表示?

%T????相應值的類型的Go語法表示?

%%????字面上的百分號，并非值的占位符

%c?????相應Unicode碼點所表示的字符?

%x?????十六進制表示，字母形式為小寫 a-f

%X?????十六進制表示，字母形式為大寫 A-F

%U???? Unicode格式：U+1234，等同于?"U+%04X"

Go 語言內存管理（三）：逃逸分析

Go 語言較之 C 語言一個很大的優(yōu)勢就是自帶 GC 功能，可 GC 并不是沒有代價的。寫 C 語言的時候，在一個函數內聲明的變量，在函數退出后會自動釋放掉，因為這些變量分配在棧上。如果你期望變量的數據可以在函數退出后仍然能被訪問，就需要調用 malloc 方法在堆上申請內存，如果程序不再需要這塊內存了，再調用 free 方法釋放掉。Go 語言不需要你主動調用 malloc 來分配堆空間，編譯器會自動分析，找出需要 malloc 的變量，使用堆內存。編譯器的這個分析過程就叫做逃逸分析。

所以你在一個函數中通過 dict := make(map[string]int) 創(chuàng)建一個 map 變量，其背后的數據是放在棧空間上還是堆空間上，是不一定的。這要看編譯器分析的結果。

可逃逸分析并不是百分百準確的，它有缺陷。有的時候你會發(fā)現(xiàn)有些變量其實在棧空間上分配完全沒問題的，但編譯后程序還是把這些數據放在了堆上。如果你了解 Go 語言編譯器逃逸分析的機制，在寫代碼的時候就可以有意識地繞開這些缺陷，使你的程序更高效。

Go 語言雖然在內存管理方面降低了編程門檻，即使你不了解堆棧也能正常開發(fā)，但如果你要在性能上較真的話，還是要掌握這些基礎知識。

這里不對堆內存和棧內存的區(qū)別做太多闡述。簡單來說就是， 棧分配廉價，堆分配昂貴。 棧空間會隨著一個函數的結束自動釋放，堆空間需要時間 GC 模塊不斷地跟蹤掃描回收。如果對這兩個概念有些迷糊，建議閱讀下面 2 個文章：

這里舉一個小例子，來對比下堆棧的差別：

stack 函數中的變量 i 在函數退出會自動釋放；而 heap 函數返回的是對變量 i 的引用，也就是說 heap() 退出后，表示變量 i 還要能被訪問，它會自動被分配到堆空間上。

他們編譯出來的代碼如下：

邏輯的復雜度不言而喻，從上面的匯編中可看到， heap() 函數調用了 runtime.newobject() 方法，它會調用 mallocgc 方法從 mcache 上申請內存，申請的內部邏輯前面文章已經講述過。堆內存分配不僅分配上邏輯比棧空間分配復雜，它最致命的是會帶來很大的管理成本，Go 語言要消耗很多的計算資源對其進行標記回收（也就是 GC 成本）。

Go 編輯器會自動幫我們找出需要進行動態(tài)分配的變量，它是在編譯時追蹤一個變量的生命周期，如果能確認一個數據只在函數空間內訪問，不會被外部使用，則使用棧空間，否則就要使用堆空間。

我們在 go build 編譯代碼時，可使用 -gcflags '-m' 參數來查看逃逸分析日志。

以上面的兩個函數為例，編譯的日志輸出是：

日志中的 i escapes to heap 表示該變量數據逃逸到了堆上。

需要使用堆空間，所以逃逸，這沒什么可爭議的。但編譯器有時會將 不需要 使用堆空間的變量，也逃逸掉。這里是容易出現(xiàn)性能問題的大坑。網上有很多相關文章，列舉了一些導致逃逸情況，其實總結起來就一句話：

多級間接賦值容易導致逃逸 。

這里的多級間接指的是，對某個引用類對象中的引用類成員進行賦值。Go 語言中的引用類數據類型有 func , interface , slice , map , chan , *Type(指針) 。

記住公式 Data.Field = Value ，如果 Data , Field 都是引用類的數據類型，則會導致 Value 逃逸。這里的等號 = 不單單只賦值，也表示參數傳遞。

根據公式，我們假設一個變量 data 是以下幾種類型，相應的可以得出結論：

下面給出一些實際的例子：

如果變量值是一個函數，函數的參數又是引用類型，則傳遞給它的參數都會逃逸。

上例中 te 的類型是 func(*int) ，屬于引用類型，參數 *int 也是引用類型，則調用 te(j) 形成了為 te 的參數(成員) *int 賦值的現(xiàn)象，即 te.i = j 會導致逃逸。代碼中其他幾種調用都沒有形成 多級間接賦值 情況。

同理，如果函數的參數類型是 slice , map 或 interface{} 都會導致參數逃逸。

匿名函數的調用也是一樣的，它本質上也是一個函數變量。有興趣的可以自己測試一下。

只要使用了 Interface 類型(不是 interafce{} )，那么賦值給它的變量一定會逃逸。因為 interfaceVariable.Method() 先是間接的定位到它的實際值，再調用實際值的同名方法，執(zhí)行時實際值作為參數傳遞給方法。相當于 interfaceVariable.Method.this = realValue

向 channel 中發(fā)送數據，本質上就是為 channel 內部的成員賦值，就像給一個 slice 中的某一項賦值一樣。所以 chan *Type , chan map[Type]Type , chan []Type , chan interface{} 類型都會導致發(fā)送到 channel 中的數據逃逸。

這本來也是情理之中的，發(fā)送給 channel 的數據是要與其他函數分享的，為了保證發(fā)送過去的指針依然可用，只能使用堆分配。

可變參數如 func(arg ...string) 實際與 func(arg []string) 是一樣的，會增加一層訪問路徑。這也是 fmt.Sprintf 總是會使參數逃逸的原因。

例子非常多，這里不能一一列舉，我們只需要記住分析方法就好，即，2 級或更多級的訪問賦值會 容易 導致數據逃逸。這里加上 容易 二字是因為隨著語言的發(fā)展，相信這些問題會被慢慢解決，但現(xiàn)階段，這個可以作為我們分析逃逸現(xiàn)象的依據。

下面代碼中包含 2 種很常規(guī)的寫法，但他們卻有著很大的性能差距，建議自己想下為什么。

Benchmark 和 pprof 給出的結果:

熟悉堆棧概念可以讓我們更容易看透 Go 程序的性能問題，并進行優(yōu)化。

多級間接賦值會導致 Go 編譯器出現(xiàn)不必要的逃逸，在一些情況下可能我們只需要修改一下數據結構就會使性能有大幅提升。這也是很多人不推薦在 Go 中使用指針的原因，因為它會增加一級訪問路徑，而 map , slice , interface{} 等類型是不可避免要用到的，為了減少不必要的逃逸，只能拿指針開刀了。

大多數情況下，性能優(yōu)化都會為程序帶來一定的復雜度。建議實際項目中還是怎么方便怎么寫，功能完成后通過性能分析找到瓶頸所在，再對局部進行優(yōu)化。

如何使用Go語言實現(xiàn)遠程執(zhí)行命令

連接包含了認證，可以使用 password 或者 sshkey 2種方式來認證。下面的示例為了簡單，使用了密碼認證的方式來完成連接。

import (

"fmt"

"time"

"golang.org/x/crypto/ssh"

)

func connect(user, password, host string, port int) (*ssh.Session, error) {

var (

auth []ssh.AuthMethod

addr string

clientConfig *ssh.ClientConfig

client *ssh.Client

session *ssh.Session

err error

)

// get auth method

auth = make([]ssh.AuthMethod, 0)

auth = append(auth, ssh.Password(password))

clientConfig = ssh.ClientConfig{

User: user,

Auth: auth,

Timeout: 30 * time.Second,

}

// connet to ssh

addr = fmt.Sprintf("%s:%d", host, port)

if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {

return nil, err

}

// create session

if session, err = client.NewSession(); err != nil {

return nil, err

}

return session, nil

}

連接的方法很簡單，只要提供登錄主機的 用戶*， *密碼*， *主機名或者IP*， *SSH端口

執(zhí)行，命令獲取結果

連接成功后，執(zhí)行命令很簡單

import (

"fmt"

"log"

"os"

"time"

"golang.org/x/crypto/ssh"

)

func main() {

session, err := connect("root", "xxxxx", "127.0.0.1", 22)

if err != nil {

log.Fatal(err)

}

defer session.Close()

session.Run("ls /; ls /abc")

}

上面代碼運行之后，雖然命令正常執(zhí)行了，但是沒有正常輸出的結果，也沒有異常輸出的結果。 要想顯示結果，需要將 session 的 Stdout 和 Stderr 重定向 修改 func main 為如下：

func main() {

session, err := connect("root", "xxxxx", "127.0.0.1", 22)

if err != nil {

log.Fatal(err)

}

defer session.Close()

session.Stdout = os.Stdout

session.Stderr = os.Stderr

session.Run("ls /; ls /abc")

}

這樣就能在屏幕上顯示正常，異常的信息了。

交互式命令

上面的方式無法遠程執(zhí)行交互式命令，比如 top ， 遠程編輯一個文件，比如 vi /etc/nginx/nginx.conf如果要支持交互式的命令，需要當前的terminal來接管遠程的 PTY。

func main() {

session, err := connect("root", "olordjesus", "dockers.iotalabs.io", 2210)

if err != nil {

log.Fatal(err)

}

defer session.Close()

fd := int(os.Stdin.Fd())

oldState, err := terminal.MakeRaw(fd)

if err != nil {

panic(err)

}

defer terminal.Restore(fd, oldState)

// excute command

session.Stdout = os.Stdout

session.Stderr = os.Stderr

session.Stdin = os.Stdin

termWidth, termHeight, err := terminal.GetSize(fd)

if err != nil {

panic(err)

}

// Set up terminal modes

modes := ssh.TerminalModes{

ssh.ECHO: 1, // enable echoing

ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud

ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud

}

// Request pseudo terminal

if err := session.RequestPty("xterm-256color", termHeight, termWidth, modes); err != nil {

log.Fatal(err)

}

session.Run("top")

}

go語言string之Buffer與Builder

操作字符串離不開字符串的拼接，但是Go中string是只讀類型，大量字符串的拼接會造成性能問題。

拼接字符串，無外乎四種方式，采用“+”，“fmt.Sprintf()”,"bytes.Buffer","strings.Builder"

上面我們創(chuàng)建10萬字符串拼接的測試，可以發(fā)現(xiàn)"bytes.Buffer","strings.Builder"的性能最好，約是“+”的1000倍級別。

這是由于string是不可修改的，所以在使用“+”進行拼接字符串，每次都會產生申請空間，拼接，復制等操作，數據量大的情況下非常消耗資源和性能。而采用Buffer等方式，都是預先計算拼接字符串數組的總長度（如果可以知道長度），申請空間，底層是slice數組，可以以append的形式向后進行追加。最后在轉換為字符串。這申請了不斷申請空間的操作，也減少了空間的使用和拷貝的次數，自然性能也高不少。

bytes.buffer是一個緩沖byte類型的緩沖器存放著都是byte

是一個變長的 buffer，具有 Read 和Write 方法。 Buffer 的 零值 是一個 空的 buffer，但是可以使用，底層就是一個 []byte， 字節(jié)切片。

向Buffer中寫數據，可以看出Buffer中有個Grow函數用于對切片進行擴容。

從Buffer中讀取數據

strings.Builder的方法和bytes.Buffer的方法的命名幾乎一致。

但實現(xiàn)并不一致，Builder的Write方法直接將字符拼接slice數組后。

其沒有提供read方法，但提供了strings.Reader方式

Reader 結構:

Buffer:

Builder:

可以看出Buffer和Builder底層都是采用[]byte數組進行裝載數據。

先來說說Buffer:

創(chuàng)建好Buffer是一個empty的，off 用于指向讀寫的尾部。

在寫的時候，先判斷當前寫入字符串長度是否大于Buffer的容量，如果大于就調用grow進行擴容，擴容申請的長度為當前寫入字符串的長度。如果當前寫入字符串長度小于最小字節(jié)長度64，直接創(chuàng)建64長度的[]byte數組。如果申請的長度小于二分之一總容量減去當前字符總長度，說明存在很大一部分被使用但已讀，可以將未讀的數據滑動到數組頭。如果容量不足，擴展2*c + n 。

其String()方法就是將字節(jié)數組強轉為string

Builder是如何實現(xiàn)的。

Builder采用append的方式向字節(jié)數組后添加字符串。

從上面可以看出，[]byte的內存大小也是以倍數進行申請的，初始大小為 0，第一次為大于當前申請的最大 2 的指數，不夠進行翻倍.

可以看出如果舊容量小于1024進行翻倍，否則擴展四分之一。（2048 byte 后，申請策略的調整）。

其次String()方法與Buffer的string方法也有明顯區(qū)別。Buffer的string是一種強轉，我們知道在強轉的時候是需要進行申請空間，并拷貝的。而Builder只是指針的轉換。

這里我們解析一下 *(*string)(unsafe.Pointer(b.buf)) 這個語句的意思。

先來了解下unsafe.Pointer 的用法。

也就是說，unsafe.Pointer 可以轉換為任意類型，那么意味著，通過unsafe.Pointer媒介，程序繞過類型系統(tǒng)，進行地址轉換而不是拷貝。

即*A = Pointer = *B

就像上面例子一樣，將字節(jié)數組轉為unsafe.Pointer類型，再轉為string類型，s和b中內容一樣，修改b,s也變了，說明b和s是同一個地址。但是對s重新賦值后，意味著s的地址指向了“WORLD”,它們所使用的內存空間不同了，所以s改變后，b并不會改變。

所以他們的區(qū)別就在于 bytes.Buffer 是重新申請了一塊空間，存放生成的string變量， 而strings.Builder直接將底層的[]byte轉換成了string類型返回了回來，去掉了申請空間的操作。

分享標題：go語言中sprintf,go語言中defer
文章URL：http://chinadenli.net/article24/dsejjce.html

成都網站建設公司_創(chuàng)新互聯(lián)，為您提供品牌網站制作、品牌網站建設、網站設計公司、靜態(tài)網站、微信小程序、App開發(fā)

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)