Go语言类型转换

本文转自Golove博客:http://www.cnblogs.com/golove/p/3262925.html

strconv 包中的函数和方法

atob.go


ParseBool 将字符串转换为布尔值
它接受真值:1, t, T, TRUE, true, True
它接受假值:0, f, F, FALSE, false, False.
其它任何值都返回一个错误

func ParseBool(str string) (value bool, err error)

package main

import (
    "fmt"
    "strconv"
)

func main() {
    fmt.Println(strconv.ParseBool("1"))    // true
    fmt.Println(strconv.ParseBool("t"))    // true
    fmt.Println(strconv.ParseBool("T"))    // true
    fmt.Println(strconv.ParseBool("true")) // true
    fmt.Println(strconv.ParseBool("True")) // true
    fmt.Println(strconv.ParseBool("TRUE")) // true
    fmt.Println(strconv.ParseBool("TRue"))
    // false strconv.ParseBool: parsing "TRue": invalid syntax
    fmt.Println(strconv.ParseBool("0"))     // false
    fmt.Println(strconv.ParseBool("f"))     // false
    fmt.Println(strconv.ParseBool("F"))     // false
    fmt.Println(strconv.ParseBool("false")) // false
    fmt.Println(strconv.ParseBool("False")) // false
    fmt.Println(strconv.ParseBool("FALSE")) // false
    fmt.Println(strconv.ParseBool("FALse"))
    // false strconv.ParseBool: parsing "FAlse": invalid syntax
}

FormatBool 将布尔值转换为字符串 “true” 或 “false”

func FormatBool(b bool) string

func main() {
    fmt.Println(strconv.FormatBool(0 < 1)) // true
    fmt.Println(strconv.FormatBool(0 > 1)) // false
}

AppendBool 将布尔值 b 转换为字符串 “true” 或 “false”
然后将结果追加到 dst 的尾部,返回追加后的 []byte

func AppendBool(dst []byte, b bool) []byte

func main() {
    rst := make([]byte, 0)
    rst = strconv.AppendBool(rst, 0 < 1)
    fmt.Printf("%s\n", rst) // true
    rst = strconv.AppendBool(rst, 0 > 1)
    fmt.Printf("%s\n", rst) // truefalse
}

============================================================

atof.go


ParseFloat 将字符串转换为浮点数
s:要转换的字符串
bitSize:指定浮点类型(32:float32、64:float64)
如果 s 是合法的格式,而且接近一个浮点值,
则返回浮点数的四舍五入值(依据 IEEE754 的四舍五入标准)
如果 s 不是合法的格式,则返回“语法错误”
如果转换结果超出 bitSize 范围,则返回“超出范围”

func ParseFloat(s string, bitSize int) (f float64, err error)

func main() {
    s := "0.12345678901234567890"
    f, err := strconv.ParseFloat(s, 32)
    fmt.Println(f, err)          // 0.12345679104328156
    fmt.Println(float32(f), err) // 0.12345679
    f, err = strconv.ParseFloat(s, 64)
    fmt.Println(f, err) // 0.12345678901234568
}

============================================================

atoi.go


ErrRange 表示值超出范围
var ErrRange = errors.New(“value out of range”)

ErrSyntax 表示语法不正确
var ErrSyntax = errors.New(“invalid syntax”)

NumError 记录转换失败
type NumError struct {
Func string // 失败的函数名(ParseBool, ParseInt, ParseUint, ParseFloat)
Num string // 输入的值
Err error // 失败的原因(ErrRange, ErrSyntax)
}

int 或 uint 类型的长度(32 或 64)

const IntSize = intSize
const intSize = 32 << uint(^uint(0)>>63)

// 实现 Error 接口,输出错误信息
func (e *NumError) Error() string


ParseInt 将字符串转换为 int 类型
s:要转换的字符串
base:进位制(2 进制到 36 进制)
bitSize:指定整数类型(0:int、8:int8、16:int16、32:int32、64:int64)
返回转换后的结果和转换时遇到的错误
如果 base 为 0,则根据字符串的前缀判断进位制(0x:16,0:8,其它:10)

func ParseInt(s string, base int, bitSize int) (i int64, err error)

func main() {
    fmt.Println(strconv.ParseInt("123", 10, 8))
    // 123
    fmt.Println(strconv.ParseInt("12345", 10, 8))
    // 127 strconv.ParseInt: parsing "12345": value out of range
    fmt.Println(strconv.ParseInt("2147483647", 10, 0))
    // 2147483647
    fmt.Println(strconv.ParseInt("0xFF", 16, 0))
    // 0 strconv.ParseInt: parsing "0xFF": invalid syntax
    fmt.Println(strconv.ParseInt("FF", 16, 0))
    // 255
    fmt.Println(strconv.ParseInt("0xFF", 0, 0))
    // 255
}

ParseUint 功能同 ParseInt 一样,只不过返回 uint 类型整数

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

func main() {
    fmt.Println(strconv.ParseUint("FF", 16, 8))
    // 255
}

Atoi 相当于 ParseInt(s, 10, 0)
通常使用这个函数,而不使用 ParseInt

func Atoi(s string) (i int, err error)

func main() {
    fmt.Println(strconv.Atoi("2147483647"))
    // 2147483647
    fmt.Println(strconv.Atoi("2147483648"))
    // 2147483647 strconv.ParseInt: parsing "2147483648": value out of range
}

============================================================

ftoa.go


FormatFloat 将浮点数 f 转换为字符串值
f:要转换的浮点数
fmt:格式标记(b、e、E、f、g、G)
prec:精度(数字部分的长度,不包括指数部分)
bitSize:指定浮点类型(32:float32、64:float64)

格式标记:
‘b’ (-ddddp±ddd,二进制指数)
‘e’ (-d.dddde±dd,十进制指数)
‘E’ (-d.ddddE±dd,十进制指数)
‘f’ (-ddd.dddd,没有指数)
‘g’ (‘e’:大指数,’f’:其它情况)
‘G’ (‘E’:大指数,’f’:其它情况)

如果格式标记为 ‘e’,’E’和’f’,则 prec 表示小数点后的数字位数
如果格式标记为 ‘g’,’G’,则 prec 表示总的数字位数(整数部分+小数部分)

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

package main

import (
    "fmt"
    "strconv"
)

func main() {
    f := 100.12345678901234567890123456789
    fmt.Println(strconv.FormatFloat(f, 'b', 5, 32))
    // 13123382p-17
    fmt.Println(strconv.FormatFloat(f, 'e', 5, 32))
    // 1.00123e+02
    fmt.Println(strconv.FormatFloat(f, 'E', 5, 32))
    // 1.00123E+02
    fmt.Println(strconv.FormatFloat(f, 'f', 5, 32))
    // 100.12346
    fmt.Println(strconv.FormatFloat(f, 'g', 5, 32))
    // 100.12
    fmt.Println(strconv.FormatFloat(f, 'G', 5, 32))
    // 100.12
    fmt.Println(strconv.FormatFloat(f, 'b', 30, 32))
    // 13123382p-17
    fmt.Println(strconv.FormatFloat(f, 'e', 30, 32))
    // 1.001234588623046875000000000000e+02
    fmt.Println(strconv.FormatFloat(f, 'E', 30, 32))
    // 1.001234588623046875000000000000E+02
    fmt.Println(strconv.FormatFloat(f, 'f', 30, 32))
    // 100.123458862304687500000000000000
    fmt.Println(strconv.FormatFloat(f, 'g', 30, 32))
    // 100.1234588623046875
    fmt.Println(strconv.FormatFloat(f, 'G', 30, 32))
    // 100.1234588623046875
}

AppendFloat 将浮点数 f 转换为字符串值,并将转换结果追加到 dst 的尾部
返回追加后的 []byte

func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte


func main() {
    f := 100.12345678901234567890123456789
    b := make([]byte, 0)
    b = strconv.AppendFloat(b, f, 'f', 5, 32)
    b = append(b, " "...)
    b = strconv.AppendFloat(b, f, 'e', 5, 32)
    fmt.Printf("%s", b) // 100.12346 1.00123e+0
}

============================================================

itoa.go


FormatUint 将 int 型整数 i 转换为字符串形式
base:进位制(2 进制到 36 进制)
大于 10 进制的数,返回值使用小写字母 ‘a’ 到 ‘z’

func FormatInt(i int64, base int) string

func main() {
    i := int64(-2048)
    fmt.Println(strconv.FormatInt(i, 2))  // -100000000000
    fmt.Println(strconv.FormatInt(i, 8))  // -4000
    fmt.Println(strconv.FormatInt(i, 10)) // -2048
    fmt.Println(strconv.FormatInt(i, 16)) // -800
    fmt.Println(strconv.FormatInt(i, 36)) // -1kw
}

FormatUint 将 uint 型整数 i 转换为字符串形式
base:进位制(2 进制到 36 进制)
大于 10 进制的数,返回值使用小写字母 ‘a’ 到 ‘z’

func FormatUint(i uint64, base int) string

func main() {
    i := uint64(2048)
    fmt.Println(strconv.FormatUint(i, 2))  // 100000000000
    fmt.Println(strconv.FormatUint(i, 8))  // 4000
    fmt.Println(strconv.FormatUint(i, 10)) // 2048
    fmt.Println(strconv.FormatUint(i, 16)) // 800
    fmt.Println(strconv.FormatUint(i, 36)) // 1kw
}

Itoa 相当于 FormatInt(i, 10)

func Itoa(i int) string

func main() {
    fmt.Println(strconv.Itoa(-2048)) // -2048
    fmt.Println(strconv.Itoa(2048))  // 2048
}

AppendInt 将 int 型整数 i 转换为字符串形式,并追加到 dst 的尾部
i:要转换的字符串
base:进位制
返回追加后的 []byte

func AppendInt(dst []byte, i int64, base int) []byte

func main() {
    b := make([]byte, 0)
    b = strconv.AppendInt(b, -2048, 16)
    fmt.Printf("%s", b) // -800
}

AppendUint 将 uint 型整数 i 转换为字符串形式,并追加到 dst 的尾部
i:要转换的字符串
base:进位制
返回追加后的 []byte

func AppendUint(dst []byte, i uint64, base int) []byte

func main() {
    b := make([]byte, 0)
    b = strconv.AppendUint(b, 2048, 16)
    fmt.Printf("%s", b) // 800
}

============================================================

quote.go


Quote 将字符串 s 转换为“双引号”引起来的字符串
其中的特殊字符将被转换为“转义字符”
不可显示的字符”将被转换为“转义字符”

func Quote(s string) string
func main() {
    fmt.Println(strconv.Quote(`C:\Windows`))
    // "C:\\Windows"
}

注:此处是反引号(键盘上1左侧那个按键),而不是单引号


AppendQuote 将字符串 s 转换为“双引号”引起来的字符串,
并将结果追加到 dst 的尾部,返回追加后的 []byte
其中的特殊字符将被转换为“转义字符”

func AppendQuote(dst []byte, s string) []byte
func main() {
    s := `C:\Windows`
    b := make([]byte, 0)
    b = strconv.AppendQuote(b, s)
    fmt.Printf("%s", b) // "C:\\Windows"
}

// QuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func QuoteToASCII(s string) string

func main() {
fmt.Println(strconv.QuoteToASCII(“Hello 世界!”))
// “Hello \u4e16\u754c\uff01”
}


AppendQuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串,
并将结果追加到 dst 的尾部,返回追加后的 []byte
非 ASCII 字符”和“特殊字符”将被转换为“转义字符”

func AppendQuoteToASCII(dst []byte, s string) []byte
func main() {
    s := "Hello 世界!"
    b := make([]byte, 0)
    b = strconv.AppendQuoteToASCII(b, s)
    fmt.Printf("%s", b) // "Hello \u4e16\u754c\uff01"
}

QuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串
特殊字符”将被转换为“转义字符”

func QuoteRune(r rune) string
func main() {
    fmt.Println(strconv.QuoteRune('好'))
    // '好'
}

注:此处为单引号,而不是反引号,这点要与Quote()使用去分开


AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串,
并将结果追加到 dst 的尾部,返回追加后的 []byte
特殊字符”将被转换为“转义字符”

func AppendQuoteRune(dst []byte, r rune) []byte
func main() {
    b := make([]byte, 0)
    b = strconv.AppendQuoteRune(b, '好')
    fmt.Printf("%s", b) // '好'
}

QuoteRuneToASCII 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串
“非 ASCII 字符”和“特殊字符”将被转换为“转义字符”

func QuoteRuneToASCII(r rune) string
func main() {
    fmt.Println(strconv.QuoteRuneToASCII('好'))
    // '\u597d'
}

AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串,
并将结果追加到 dst 的尾部,返回追加后的 []byte
“非 ASCII 字符”和“特殊字符”将被转换为“转义字符”

func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

func main() {
    b := make([]byte, 0)
    b = strconv.AppendQuoteRuneToASCII(b, '好')
    fmt.Printf("%s", b) // '\u597d'
}

CanBackquote 判断字符串 s 是否可以表示为一个单行的“反引号”字符串
字符串中不能含有控制字符(除了 \t)和“反引号”字符,否则返回 false
``
func CanBackquote(s string) bool
func main() {
b := strconv.CanBackquote("C:\\Windows\n")
fmt.Println(b) // false
b = strconv.CanBackquote("C:\\Windows\r")
fmt.Println(b) // false
b = strconv.CanBackquote("C:\\Windows\f")
fmt.Println(b) // false
b = strconv.CanBackquote("C:\\Windows\t")
fmt.Println(b) // true
b = strconv.CanBackquote("C:\\
Windows`”)
fmt.Println(b) // false
}


------------------------------------------------------------

UnquoteChar 将 s 中的第一个字符“取消转义”并解码

s:转义后的字符串
 quote:字符串使用的“引号符”(用于对引号符“取消转义”)

value: 解码后的字符
 multibyte:value 是否为多字节字符
tail: 字符串 s 除去 value 后的剩余部分
error: 返回 s 中是否存在语法错误

参数 quote 为“引号符”
如果设置为单引号,则 s 中允许出现 \' 字符,不允许出现单独的 ' 字符
如果设置为双引号,则 s 中允许出现 \" 字符,不允许出现单独的 " 字符
 如果设置为 0,则不允许出现 \' 或 \" 字符,可以出现单独的 '" 字符
 ```
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)

func main() {
    s := `\"大\\家\\好!\"`
    c, mb, sr, _ := strconv.UnquoteChar(s, '"')
    fmt.Printf("%-3c %v\n", c, mb)
    for ; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr, '"') {
        fmt.Printf("%-3c %v\n", c, mb)
    }
    // " false
    // 大 true
    // \ false
    // 家 true
    // \ false
    // 好 true
    // ! true
}

Unquote 将“带引号的字符串” s 转换为常规的字符串(不带引号和转义字符)
s 可以是“单引号”、“双引号”或“反引号”引起来的字符串(包括引号本身)
如果 s 是单引号引起来的字符串,则返回该该字符串代表的字符
“`
func Unquote(s string) (t string, err error)

func main() {
sr, err := strconv.Unquote("\"大\t家\t好!\"")
fmt.Println(sr, err)
sr, err = strconv.Unquote('大家好!')
fmt.Println(sr, err)
sr, err = strconv.Unquote('好')
fmt.Println(sr, err)
sr, err = strconv.Unquote(“大\\t家\\t好!“)
fmt.Println(sr, err)
}


------------------------------------------------------------

 IsPrint 判断 Unicode 字符 r 是否是一个可显示的字符
 可否显示并不是你想象的那样,比如空格可以显示,而\t则不能显示
 具体可以参考 Go 语言的源码
 ```
func IsPrint(r rune) bool

func main() {
    fmt.Println(strconv.IsPrint('a'))  // true
    fmt.Println(strconv.IsPrint('好'))  // true
    fmt.Println(strconv.IsPrint(' '))  // true
    fmt.Println(strconv.IsPrint('\t')) // false
    fmt.Println(strconv.IsPrint('\n')) // false
    fmt.Println(strconv.IsPrint(0))    // false
}
<div class="post-text" itemprop="text"> <p>I am trying to convert the string to uint on 32-bit ubuntu using the following code. But it always convert it in uint64 despite explicitly passing 32 as the argument in the function. Below in the code mw is the object of the <a href="https://github.com/gographics/imagick" rel="noreferrer">image magick</a> library. Which returns <code>uint</code> when <code>mw.getImageWidth()</code> and <code>mw.getImageHeight()</code> is called. Also, it accepts the <code>uint</code> type argument in the <a href="https://github.com/gographics/imagick/blob/master/imagick/magick_wand_image.go" rel="noreferrer">resize</a> function. </p> <pre><code> width := strings.Split(imgResize, "x")[0] height := strings.Split(imgResize, "x")[1] var masterWidth uint = mw.GetImageWidth() var masterHeight uint = mw.GetImageHeight() mw := imagick.NewMagickWand() defer mw.Destroy() err = mw.ReadImageBlob(img) if err != nil { log.Fatal(err) } var masterWidth uint = mw.GetImageWidth() var masterHeight uint = mw.GetImageHeight() wd, _ := strconv.ParseUint(width, 10, 32) ht, _ := strconv.ParseUint(height, 10, 32) if masterWidth < wd || masterHeight < ht { err = mw.ResizeImage(wd, ht, imagick.FILTER_BOX, 1) if err != nil { panic(err) } } </code></pre> <p>Error is :</p> <pre><code># command-line-arguments test.go:94: invalid operation: masterWidth < wd (mismatched types uint and uint64) goImageCode/test.go:94: invalid operation: masterHeight < ht (mismatched types uint and uint64) goImageCode/test.go:100: cannot use wd (type uint64) as type uint in argument to mw.ResizeImage goImageCode/AmazonAWS.go:100: cannot use ht (type uint64) as type uint in argument to mw.ResizeImage </code></pre> </div>
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页