strconv

package
v1.26.0 Latest Latest
Warning

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

 Go to latest Published: Apr 21, 2026 License: MIT Imports: 2 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 = strconv.IntSize

IntSize is the size in bits of an int or uint value.

Variables

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

ErrRange indicates that a value is out of range for the target type.

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

ErrSyntax indicates that a value does not have the right syntax for the target type.

Functions

func AppendBool 

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

AppendBool appends "true" or "false", according to the value of b, 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("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は、sを表すダブルクォートで囲まれたGo文字列リテラル（Quote によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

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は、runeを表すシングルクォートで囲まれたGo文字リテラル（QuoteRune によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

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は、runeを表すシングルクォートで囲まれたGo文字リテラル（QuoteRuneToASCII によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

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は、runeを表すシングルクォートで囲まれたGo文字リテラル（QuoteRuneToGraphic によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

func AppendQuoteToASCII 

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

AppendQuoteToASCIIは、sを表すダブルクォートで囲まれたGo文字列リテラル（QuoteToASCII によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

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は、sを表すダブルクォートで囲まれたGo文字列リテラル（QuoteToGraphic によって生成されたもの）をdstに追加し、拡張されたバッファを返します。

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 is equivalent to ParseInt(s, 10, 0), converted to type 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は、タブ以外の制御文字を含まない単一行のバッククォート文字列として、文字列sを変更せずに表現できるかどうかを報告します。

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 returns "true" or "false" according to the value of b.

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 converts the complex number c to a string of the form (a+bi) where a and b are the real and imaginary parts, formatted according to the format fmt and precision prec.

The format fmt and precision prec have the same meaning as in FormatFloat. It rounds the result assuming that the original was obtained from a complex value of bitSize bits, which must be 64 for complex64 and 128 for complex128.

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. The exponent is written as a decimal integer; for all formats other than 'b', it will be at least two digits.

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は、Unicodeによってグラフィックとして定義されたルーンかどうかを報告します。 このような文字には、カテゴリL、M、N、P、S、および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は、文字がGoによって印刷可能と定義されているかどうかを報告します。 これは、unicode.IsPrint と同じ定義で、文字、数字、句読点、記号、ASCIIスペースを含みます。

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 returns the boolean value represented by the string. It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False. Any other value returns an error.

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 converts the string s to a complex number with the precision specified by bitSize: 64 for complex64, or 128 for complex128. When bitSize=64, the result still has type complex128, but it will be convertible to complex64 without changing its value.

The number represented by s must be of the form N, Ni, or N±Ni, where N stands for a floating-point number as recognized by ParseFloat, and i is the imaginary component. If the second N is unsigned, a + sign is required between the two components as indicated by the ±. If the second N is NaN, only a + sign is accepted. The form may be parenthesized and cannot contain any spaces. The resulting complex number consists of the two components converted by ParseFloat.

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

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

If s is syntactically well-formed but either component is more than 1/2 ULP away from the largest floating point number of the given component's size, ParseComplex returns err.Err = ErrRange and c = ±Inf for the respective component.

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 interprets a string s in the given base (0, 2 to 36) and bit size (0 to 64) and returns the corresponding value i.

The string may begin with a leading sign: "+" or "-".

If the base argument is 0, the true base is implied by the string's prefix following the sign (if present): 2 for "0b", 8 for "0" or "0o", 16 for "0x", and 10 otherwise. Also, for argument base 0 only, underscore characters are permitted as defined by the Go syntax for integer literals.

The bitSize argument specifies the integer type that the result must fit into. Bit sizes 0, 8, 16, 32, and 64 correspond to int, int8, int16, int32, and int64. If bitSize is below 0 or above 64, an error is returned.

The errors that ParseInt returns have concrete type *NumError and include err.Num = s. If s is empty or contains invalid digits, err.Err = ErrSyntax and the returned value is 0; if the value corresponding to s cannot be represented by a signed integer of the given size, err.Err = ErrRange and the returned value is the maximum magnitude integer of the appropriate bitSize and sign.

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 is like ParseInt but for unsigned numbers.

A sign prefix is not permitted.

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は、sを表すダブルクォートで囲まれたGo文字列リテラルを返します。 返される文字列は、制御文字および IsPrint によって定義された印刷不可能な文字のために、 Goエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。

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は、runeを表すシングルクォートで囲まれたGo文字リテラルを返します。 返される文字列は、制御文字および IsPrint によって定義された印刷不可能な文字のために、 Goエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。 rが有効なUnicodeコードポイントでない場合、Unicode置換文字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は、runeを表すシングルクォートで囲まれたGo文字リテラルを返します。 返される文字列は、制御文字および IsPrint によって定義された印刷不可能な文字のために、 Goエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。 rが有効なUnicodeコードポイントでない場合、Unicode置換文字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は、runeを表すシングルクォートで囲まれたGo文字リテラルを返します。 返される文字列は、Unicodeのグラフィック文字（IsGraphic によって定義される）を変更せず、 非グラフィック文字に対してGoエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。 rが有効なUnicodeコードポイントでない場合、Unicode置換文字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は、sを表すダブルクォートで囲まれたGo文字列リテラルを返します。 返される文字列は、制御文字および IsPrint によって定義された印刷不可能な文字のために、 Goエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。

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は、sを表すダブルクォートで囲まれたGo文字列リテラルを返します。 返される文字列は、Unicodeのグラフィック文字（IsGraphic によって定義される）を変更せず、 非グラフィック文字に対してGoエスケープシーケンス（\t、\n、\xFF、\u0100）を使用します。

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は、sのプレフィックスにある引用符で囲まれた文字列（Unquote で理解される形式）を返します。 sが有効な引用符で囲まれた文字列で始まらない場合、QuotedPrefixはエラーを返します。

Example 
package main

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

func main() {
	s, err := strconv.QuotedPrefix("not a quoted string")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.QuotedPrefix("\"double-quoted string\" with trailing text")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.QuotedPrefix("`or backquoted` with more trailing text")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.QuotedPrefix("'\u263a' is also okay")
	fmt.Printf("%q, %v\n", s, err)

}

Output:
"", invalid syntax
"\"double-quoted string\"", <nil>
"`or backquoted`", <nil>
"'☺'", <nil>

func Unquote 

func Unquote(s string) (string, error)

Unquoteは、sをシングルクォート、ダブルクォート、またはバッククォートで囲まれたGo文字列リテラルとして解釈し、 sが囲む文字列値を返します。（sがシングルクォートの場合、それはGoの文字リテラルとなり、Unquoteは対応する1文字の文字列を返します。 空の文字リテラルの場合、Unquoteは空文字列を返します。）

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は、文字列sによって表されるエスケープされた文字列または文字リテラルの最初の文字またはバイトをデコードします。 4つの値を返します。

1. value：デコードされたUnicodeコードポイントまたはバイト値 2. multibyte：デコードされた文字がマルチバイトUTF-8表現を必要とするかどうかを示すブール値 3. tail：文字の後の残りの文字列 4. エラー：文字が構文的に有効である場合はnilになります。

2番目の引数であるquoteは、解析されるリテラルの種類を指定し、許可されるエスケープされた引用符文字を決定します。 シングルクォートに設定すると、\'のシーケンスを許可し、エスケープされていない'を許可しません。 ダブルクォートに設定すると、\"を許可し、エスケープされていない"を許可しません。 ゼロに設定すると、どちらのエスケープも許可せず、両方の引用符文字がエスケープされていない状態で現れることを許可します。

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
}

A NumError records a failed conversion.

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.