strconv

package
v1.21.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 10, 2023 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

パッケージ strconv は基本データ型の文字列表現への変換を実装します。

数値の変換

最も一般的な数値の変換は Atoi (文字列から整数へ) と Itoa (整数から文字列へ) です。 

i, err := strconv.Atoi("-42")
s := strconv.Itoa(-42)

これらは10進数とGoのint型を仮定しています。

ParseBool、ParseFloat、ParseInt、および ParseUint は文字列を値に変換します： 

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

パース関数は最も広い型（float64、int64、およびuint64）を返しますが、サイズ引数が より狭い幅を指定している場合、結果はその狭い型にデータの損失なく変換できます： 

s := "2147483647" // 最大のint32
i64, err := strconv.ParseInt(s, 10, 32)
...
i := int32(i64)

FormatBool、FormatFloat、FormatInt、および FormatUint は値を文字列に変換します： 

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)

AppendBool、AppendFloat、AppendInt、および AppendUint は類似していますが、 フォーマットされた値を宛先スライスに追加します。

文字列の変換

Quote および QuoteToASCII は文字列をクォートされたGo文字リテラルに変換します。 後者は非ASCII Unicodeを \u でエスケープして、結果がASCII文字列であることを保証します： 

q := strconv.Quote("Hello, 世界")
q := strconv.QuoteToASCII("Hello, 世界")

QuoteRune および QuoteRuneToASCII は類似していますが、runeを受け入れて、 クォートされたGo runeリテラルを返します。

Unquote および UnquoteChar はGo文字列およびruneリテラルのクォートを解除します。

Index

Examples

Constants

View Source 
const IntSize = intSize

IntSizeはintまたはuint値のビットサイズです。

Variables

View Source 
var ErrRange = errors.New("value out of range")

ErrRangeは、値が対象の型の範囲外であることを示します。

View Source 
var ErrSyntax = errors.New("invalid syntax")

ErrSyntaxは、値がターゲットの型の正しい構文ではないことを示します。

Functions

func AppendBool 

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

AppendBoolはbの値に応じて、"true"または"false"をdstに追加し、拡張されたバッファを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b := []byte("bool:")
	b = strconv.AppendBool(b, true)
	fmt.Println(string(b))

}

Output:

bool:true

func AppendFloat 

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

AppendFloat appends the string form of the floating-point number f, as generated by FormatFloat, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b32 := []byte("float32:")
	b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
	fmt.Println(string(b32))

	b64 := []byte("float64:")
	b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
	fmt.Println(string(b64))

}

Output:

float32:3.1415927E+00
float64:3.1415926535E+00

func AppendInt 

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

AppendInt appends the string form of the integer i, as generated by FormatInt, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b10 := []byte("int (base 10):")
	b10 = strconv.AppendInt(b10, -42, 10)
	fmt.Println(string(b10))

	b16 := []byte("int (base 16):")
	b16 = strconv.AppendInt(b16, -42, 16)
	fmt.Println(string(b16))

}

Output:

int (base 10):-42
int (base 16):-2a

func AppendQuote 

func AppendQuote(dst []byte, s string) []byte

AppendQuote appends a double-quoted Go string literal representing s, as generated by Quote, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b := []byte("quote:")
	b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
	fmt.Println(string(b))

}

Output:

quote:"\"Fran & Freddie's Diner\""

func AppendQuoteRune 

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

AppendQuoteRune appends a single-quoted Go character literal representing the rune, as generated by QuoteRune, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b := []byte("rune:")
	b = strconv.AppendQuoteRune(b, '☺')
	fmt.Println(string(b))

}

Output:

rune:'☺'

func AppendQuoteRuneToASCII 

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

AppendQuoteRuneToASCII appends a single-quoted Go character literal representing the rune, as generated by QuoteRuneToASCII, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b := []byte("rune (ascii):")
	b = strconv.AppendQuoteRuneToASCII(b, '☺')
	fmt.Println(string(b))

}

Output:

rune (ascii):'\u263a'

func AppendQuoteRuneToGraphic added in v1.6.0 

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

AppendQuoteRuneToGraphic appends a single-quoted Go character literal representing the rune, as generated by QuoteRuneToGraphic, to dst and returns the extended buffer.

func AppendQuoteToASCII 

func AppendQuoteToASCII(dst []byte, s string) []byte

AppendQuoteToASCII appends a double-quoted Go string literal representing s, as generated by QuoteToASCII, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b := []byte("quote (ascii):")
	b = strconv.AppendQuoteToASCII(b, `"Fran & Freddie's Diner"`)
	fmt.Println(string(b))

}

Output:

quote (ascii):"\"Fran & Freddie's Diner\""

func AppendQuoteToGraphic added in v1.6.0 

func AppendQuoteToGraphic(dst []byte, s string) []byte

AppendQuoteToGraphic appends a double-quoted Go string literal representing s, as generated by QuoteToGraphic, to dst and returns the extended buffer.

func AppendUint 

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

AppendUint appends the string form of the unsigned integer i, as generated by FormatUint, to dst and returns the extended buffer.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	b10 := []byte("uint (base 10):")
	b10 = strconv.AppendUint(b10, 42, 10)
	fmt.Println(string(b10))

	b16 := []byte("uint (base 16):")
	b16 = strconv.AppendUint(b16, 42, 16)
	fmt.Println(string(b16))

}

Output:

uint (base 10):42
uint (base 16):2a

func Atoi 

func Atoi(s string) (int, error)

AtoiはParseInt(s, 10, 0)と同じであり、int型に変換されます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := "10"
	if s, err := strconv.Atoi(v); err == nil {
		fmt.Printf("%T, %v", s, s)
	}

}

Output:

int, 10

func CanBackquote 

func CanBackquote(s string) bool

CanBackquote reports whether the string s can be represented unchanged as a single-line backquoted string without control characters other than tab.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
	fmt.Println(strconv.CanBackquote("`can't backquote this`"))

}

Output:

true
false

func FormatBool 

func FormatBool(b bool) string

FormatBoolはbの値に応じて"true"または"false"を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := true
	s := strconv.FormatBool(v)
	fmt.Printf("%T, %v\n", s, s)

}

Output:

string, true

func FormatComplex added in v1.15.0 

func FormatComplex(c complex128, fmt byte, prec, bitSize int) string

FormatComplexは複素数cを，(a+bi)という形式の文字列に変換します．ここでaとbは実部と虚部を表し，フォーマットfmtと精度precに従って整形されます．

フォーマットfmtと精度precは，FormatFloatの意味と同じです．元の値がcomplex64の場合はbitSizeが64で，complex128の場合は128であることを前提にして結果を丸めます．

func FormatFloat 

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

FormatFloat converts the floating-point number f to a string, according to the format fmt and precision prec. It rounds the result assuming that the original was obtained from a floating-point value of bitSize bits (32 for float32, 64 for float64).

The format fmt is one of 'b' (-ddddp±ddd, a binary exponent), 'e' (-d.dddde±dd, a decimal exponent), 'E' (-d.ddddE±dd, a decimal exponent), 'f' (-ddd.dddd, no exponent), 'g' ('e' for large exponents, 'f' otherwise), 'G' ('E' for large exponents, 'f' otherwise), 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).

The precision prec controls the number of digits (excluding the exponent) printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats. For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point. For 'g' and 'G' it is the maximum number of significant digits (trailing zeros are removed). The special precision -1 uses the smallest number of digits necessary such that ParseFloat will return f exactly.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := 3.1415926535

	s32 := strconv.FormatFloat(v, 'E', -1, 32)
	fmt.Printf("%T, %v\n", s32, s32)

	s64 := strconv.FormatFloat(v, 'E', -1, 64)
	fmt.Printf("%T, %v\n", s64, s64)

	// fmt.Printlnはこれらの引数を使用して浮動小数点数を出力します。
	fmt64 := strconv.FormatFloat(v, 'g', -1, 64)
	fmt.Printf("%T, %v\n", fmt64, fmt64)

}

Output:

string, 3.1415927E+00
string, 3.1415926535E+00
string, 3.1415926535

func FormatInt 

func FormatInt(i int64, base int) string

FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' for digit values >= 10.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := int64(-42)

	s10 := strconv.FormatInt(v, 10)
	fmt.Printf("%T, %v\n", s10, s10)

	s16 := strconv.FormatInt(v, 16)
	fmt.Printf("%T, %v\n", s16, s16)

}

Output:

string, -42
string, -2a

func FormatUint 

func FormatUint(i uint64, base int) string

FormatUint returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' for digit values >= 10.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := uint64(42)

	s10 := strconv.FormatUint(v, 10)
	fmt.Printf("%T, %v\n", s10, s10)

	s16 := strconv.FormatUint(v, 16)
	fmt.Printf("%T, %v\n", s16, s16)

}

Output:

string, 42
string, 2a

func IsGraphic added in v1.6.0 

func IsGraphic(r rune) bool

IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such characters include letters, marks, numbers, punctuation, symbols, and spaces, from categories L, M, N, P, S, and Zs.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	shamrock := strconv.IsGraphic('☘')
	fmt.Println(shamrock)

	a := strconv.IsGraphic('a')
	fmt.Println(a)

	bel := strconv.IsGraphic('\007')
	fmt.Println(bel)

}

Output:

true
true
false

func IsPrint 

func IsPrint(r rune) bool

IsPrint reports whether the rune is defined as printable by Go, with the same definition as unicode.IsPrint: letters, numbers, punctuation, symbols and ASCII space.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	c := strconv.IsPrint('\u263a')
	fmt.Println(c)

	bel := strconv.IsPrint('\007')
	fmt.Println(bel)

}

Output:

true
false

func Itoa 

func Itoa(i int) string

Itoa is equivalent to FormatInt(int64(i), 10).

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	i := 10
	s := strconv.Itoa(i)
	fmt.Printf("%T, %v\n", s, s)

}

Output:

string, 10

func ParseBool 

func ParseBool(str string) (bool, error)

ParseBoolは文字列で表されるブール値を返します。 1、t、T、TRUE、true、True、0、f、F、FALSE、false、Falseを受け入れます。 その他の値はエラーを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := "true"
	if s, err := strconv.ParseBool(v); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

}

Output:

bool, true

func ParseComplex added in v1.15.0 

func ParseComplex(s string, bitSize int) (complex128, error)

ParseComplexは文字列sを、bitSizeで指定された精度で複素数に変換します。 bitSizeが64の場合、結果は型complex128になりますが、値を変更せずにcomplex64に変換することができます。

sに表される数値は、N、Ni、またはN±Niの形式でなければなりません。ここで、NはParseFloatで認識される浮動小数点数を表し、iは虚数成分です。 2つ目のNが非負である場合、±によって示される2つの成分の間に+記号が必要です。2つ目のNがNaNである場合、+記号のみが受け入れられます。 形式は括弧で囲んでも良く、スペースを含んではいけません。 変換される複素数は、ParseFloatによって変換された2つの成分から構成されます。

ParseComplexが返すエラーは、*NumErrorという具体的な型であり、err.Num = sとなります。

sが構文的に正しくない場合、ParseComplexはerr.Err = ErrSyntaxを返します。

sが構文的に正しくなっているが、いずれかの成分が与えられた成分のサイズで最大の浮動小数点数から1/2 ULP以上離れている場合、 ParseComplexはerr.Err = ErrRangeとc = ±Infを返します。

func ParseFloat 

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

ParseFloat converts the string s to a floating-point number with the precision specified by bitSize: 32 for float32, or 64 for float64. When bitSize=32, the result still has type float64, but it will be convertible to float32 without changing its value.

ParseFloat accepts decimal and hexadecimal floating-point numbers as defined by the Go syntax for floating-point literals. If s is well-formed and near a valid floating-point number, ParseFloat returns the nearest floating-point number rounded using IEEE754 unbiased rounding. (Parsing a hexadecimal floating-point value only rounds when there are more bits in the hexadecimal representation than will fit in the mantissa.)

The errors that ParseFloat returns have concrete type *NumError and include err.Num = s.

If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.

If s is syntactically well-formed but is more than 1/2 ULP away from the largest floating point number of the given size, ParseFloat returns f = ±Inf, err.Err = ErrRange.

ParseFloat recognizes the string "NaN", and the (possibly signed) strings "Inf" and "Infinity" as their respective special floating point values. It ignores case when matching.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := "3.1415926535"
	if s, err := strconv.ParseFloat(v, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat(v, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("NaN", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	// ParseFloat は大文字小文字を区別しない
	if s, err := strconv.ParseFloat("nan", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("inf", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("-0", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseFloat("+0", 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

}

Output:

float64, 3.1415927410125732
float64, 3.1415926535
float64, NaN
float64, NaN
float64, +Inf
float64, +Inf
float64, -Inf
float64, -0
float64, 0

func ParseInt 

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

ParseIntは与えられた基数（0、2から36）とビットサイズ（0から64）で文字列sを解釈し、対応する値iを返します。

文字列は先頭に符号 "+" または "-" を持つことができます。

基数引数が0の場合、真の基数は符号の後に続く文字列の接頭辞で推測されます（存在する場合）："0b"の場合は2、"0"または"0o"の場合は8、"0x"の場合は16、それ以外の場合は10です。また、基数0の場合だけアンダースコア文字が許可されます。これはGoの構文で定義されている整数リテラルです。

bitSize引数は結果が適合する必要のある整数型を指定します。ビットサイズ0、8、16、32、64はint、int8、int16、int32、int64に対応します。bitSizeが0未満または64を超える場合、エラーが返されます。

ParseIntが返すエラーは具体的な型*NumErrorを持ち、err.Num = sとなります。sが空であるか無効な数字を含んでいる場合、err.Err = ErrSyntaxとなり返される値は0です。sに対応する値を指定のサイズの符号付き整数で表現することができない場合、err.Err = ErrRangeとなり、返される値は適切なbitSizeと符号の最大の大きさの整数です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v32 := "-354634382"
	if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

	v64 := "-3546343826724305832"
	if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

}

Output:

int64, -354634382
int64, -3546343826724305832

func ParseUint 

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

ParseUintはParseIntと同じですが、符号の接頭辞は許可されていません。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v := "42"
	if s, err := strconv.ParseUint(v, 10, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseUint(v, 10, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

}

Output:

uint64, 42
uint64, 42

func Quote 

func Quote(s string) string

Quote returns a double-quoted Go string literal representing s. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for control characters and non-printable characters as defined by IsPrint.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	// この文字列リテラルにはタブ文字が含まれています。
	s := strconv.Quote(`"Fran & Freddie's Diner	☺"`)
	fmt.Println(s)

}

Output:

"\"Fran & Freddie's Diner\t☺\""

func QuoteRune 

func QuoteRune(r rune) string

QuoteRune returns a single-quoted Go character literal representing the rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for control characters and non-printable characters as defined by IsPrint. If r is not a valid Unicode code point, it is interpreted as the Unicode replacement character U+FFFD.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	s := strconv.QuoteRune('☺')
	fmt.Println(s)

}

Output:

'☺'

func QuoteRuneToASCII 

func QuoteRuneToASCII(r rune) string

QuoteRuneToASCII returns a single-quoted Go character literal representing the rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for non-ASCII characters and non-printable characters as defined by IsPrint. If r is not a valid Unicode code point, it is interpreted as the Unicode replacement character U+FFFD.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	s := strconv.QuoteRuneToASCII('☺')
	fmt.Println(s)

}

Output:

'\u263a'

func QuoteRuneToGraphic added in v1.6.0 

func QuoteRuneToGraphic(r rune) string

QuoteRuneToGraphic returns a single-quoted Go character literal representing the rune. If the rune is not a Unicode graphic character, as defined by IsGraphic, the returned string will use a Go escape sequence (\t, \n, \xFF, \u0100). If r is not a valid Unicode code point, it is interpreted as the Unicode replacement character U+FFFD.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	s := strconv.QuoteRuneToGraphic('☺')
	fmt.Println(s)

	s = strconv.QuoteRuneToGraphic('\u263a')
	fmt.Println(s)

	s = strconv.QuoteRuneToGraphic('\u000a')
	fmt.Println(s)

	s = strconv.QuoteRuneToGraphic('	') // タブ文字
	fmt.Println(s)

}

Output:

'☺'
'☺'
'\n'
'\t'

func QuoteToASCII 

func QuoteToASCII(s string) string

QuoteToASCII returns a double-quoted Go string literal representing s. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for non-ASCII characters and non-printable characters as defined by IsPrint.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	// この文字列リテラルにはタブ文字が含まれています。
	s := strconv.QuoteToASCII(`"Fran & Freddie's Diner	☺"`)
	fmt.Println(s)

}

Output:

"\"Fran & Freddie's Diner\t\u263a\""

func QuoteToGraphic added in v1.6.0 

func QuoteToGraphic(s string) string

QuoteToGraphic returns a double-quoted Go string literal representing s. The returned string leaves Unicode graphic characters, as defined by IsGraphic, unchanged and uses Go escape sequences (\t, \n, \xFF, \u0100) for non-graphic characters.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	s := strconv.QuoteToGraphic("☺")
	fmt.Println(s)

	// この文字列リテラルにはタブ文字が含まれています。
	s = strconv.QuoteToGraphic("This is a \u263a	\u000a")
	fmt.Println(s)

	s = strconv.QuoteToGraphic(`" This is a ☺ \n "`)
	fmt.Println(s)

}

Output:

"☺"
"This is a ☺\t\n"
"\" This is a ☺ \\n \""

func QuotedPrefix added in v1.17.0 

func QuotedPrefix(s string) (string, error)

QuotedPrefix returns the quoted string (as understood by Unquote) at the prefix of s. If s does not start with a valid quoted string, QuotedPrefix returns an error.

func Unquote 

func Unquote(s string) (string, error)

Unquote interprets s as a single-quoted, double-quoted, or backquoted Go string literal, returning the string value that s quotes. (If s is single-quoted, it would be a Go character literal; Unquote returns the corresponding one-character string.)

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	s, err := strconv.Unquote("You can't unquote a string without quotes")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("\"The string must be either double-quoted\"")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("`or backquoted.`")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("'\u263a'") // 単一の文字はシングルクォーテーション内でのみ許可されています。
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("'\u2639\u2639'")
	fmt.Printf("%q, %v\n", s, err)

}

Output:

"", invalid syntax
"The string must be either double-quoted", <nil>
"or backquoted.", <nil>
"☺", <nil>
"", invalid syntax

func UnquoteChar 

func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)

UnquoteChar decodes the first character or byte in the escaped string or character literal represented by the string s. It returns four values:

  1. value, the decoded Unicode code point or byte value;
  2. multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
  3. tail, the remainder of the string after the character; and
  4. an error that will be nil if the character is syntactically valid.

The second argument, quote, specifies the type of literal being parsed and therefore which escaped quote character is permitted. If set to a single quote, it permits the sequence \' and disallows unescaped '. If set to a double quote, it permits \" and disallows unescaped ". If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/strconv"
)

func main() {
	v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("value:", string(v))
	fmt.Println("multibyte:", mb)
	fmt.Println("tail:", t)

}

Output:

value: "
multibyte: false
tail: Fran & Freddie's Diner\"

Types

type NumError 

type NumError struct {
	Func string
	Num  string
	Err  error
}

NumErrorは変換に失敗したことを記録します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/strconv"
)

func main() {
	str := "Not a number"
	if _, err := strconv.ParseFloat(str, 64); err != nil {
		e := err.(*strconv.NumError)
		fmt.Println("Func:", e.Func)
		fmt.Println("Num:", e.Num)
		fmt.Println("Err:", e.Err)
		fmt.Println(err)
	}

}

Output:

Func: ParseFloat
Num: Not a number
Err: invalid syntax
strconv.ParseFloat: parsing "Not a number": invalid syntax

func (*NumError) Error 

func (e *NumError) Error() string

func (*NumError) Unwrap added in v1.14.0 

func (e *NumError) Unwrap() error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.