Golang int to string, string to int והמרת טיפוסים

Go אף פעם לא ממירה טיפוסים באופן מרומז. ממירים בין טיפוסים תואמים עם T(v), ובין מספרים לטקסט עם החבילה strconv. שתי ההמרות שהכי מחפשים:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa ("integer to ASCII") מעצבת int כטקסט עשרוני. strconv.Atoi ("ASCII to integer") מפענחת טקסט ל-int ומחזירה שגיאה כשהטקסט הוא לא מספר תקין. תמיד בדקו את השגיאה הזאת.

ההמרה T(v)

תחביר ההמרה של Go נראה כמו קריאה לפונקציה שנקראת על שם טיפוס היעד. הוא עובד בשלושה מצבים:

1. בין טיפוסים מספריים (int, int64, float64, uint8, ...),
2. בין string לבין []byte או []rune,
3. בין טיפוסים שחולקים טיפוס בסיס (Celsius ו-float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

קראו את התוצאות בעיון:

• int(3.9) הוא 3 ו-int(-3.9) הוא -3. המרה מקצצת לכיוון אפס; היא לא מעגלת. השתמשו קודם ב-math.Round, math.Floor או math.Ceil כדי לבחור את ההתנהגות. math.Round מעגלת חצאים הרחק מאפס, כך ש--3.5 הופך ל--4.
• uint8(300) הוא 44, כי רק 8 הביטים הנמוכים שורדים (300 פחות 256), ו-int8(200) הוא -56 מאותה סיבה. אין שגיאה, אין panic.
• Celsius ו-float64 חולקים טיפוס בסיס, ולכן הם מומרים בחופשיות, אבל רק במפורש.

הערכים נמצאים במשתנים בכוונה. עם קבועים, אותן המרות לא מתקמפלות.

קבועים נבדקים, משתנים לא

המרה של קבוע שלא נכנס בטיפוס היא שגיאת הידור. המרה של משתנה עם אותו ערך גולשת בשקט:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

גם המרה של קבוע שאינו שלם לטיפוס של מספר שלם נדחית, בזמן שאותו ערך במשתנה מקוצץ:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

אם הערך העשרוני מחוץ לטווח של טיפוס היעד השלם (למשל int64(1e20)), התוצאה תלויה במימוש: amd64 ו-arm64, לדוגמה, נותנות תשובות שונות. בדקו את הטווח לפני המרה של ערכים לא מהימנים.

המרת מספרים למחרוזות

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat מקבלת בית של פורמט ('f' לנקודה קבועה, 'e' למעריך, 'g' למה שקצר יותר), דיוק (-1 פירושו "הכי מעט ספרות שמאפשרות שחזור מדויק"), וגודל הביטים של ה-float המקורי (64 או 32).

strconv מהירה יותר מ-fmt.Sprint, שעוטפת את הערך ב-interface ועוברת במסלול העיצוב הכללי של fmt. בלולאה חמה ההבדל הזה מורגש; להמרות מזדמנות, בחרו במה שנקרא טוב יותר.

המרת מחרוזות למספרים

ParseInt תמיד מחזירה int64. הארגומנט bitSize (0, 8, 16, 32, 64) קובע את הטווח שהיא מקבלת, כך שמובטח שהתוצאה תיכנס כשממירים אותה לטיפוס קטן יותר. base 0 פירושו "הסק מהתחילית", כך ש-0x1f, 0o17, 0b101 ו-1_000 כולם מתפענחים.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

מה שהפלט מראה:

• " 42" נכשל. Atoi מקבלת סימן אופציונלי וספרות, ושום דבר אחר. קלט מ-bufio בדרך כלל נגמר ב-\n, אז הסירו אותו.
• "4.2" לא תקין עבור Atoi. השתמשו ב-ParseFloat למספרים עשרוניים.
• בשגיאת חריגה מהטווח, ParseInt מחזירה את הערך הגדול ביותר שנכנס (127 עבור int8) יחד עם השגיאה. אל תשתמשו בערך כשהשגיאה היא לא nil.
• השגיאות הן ערכי *strconv.NumError שעוטפים את strconv.ErrSyntax או את strconv.ErrRange, כך ש-errors.Is יכולה להבחין ביניהן.

ParseBool מקבלת 1, t, T, TRUE, true, True ואת צורות ה-false המקבילות. "yes" ו-"on" הן שגיאות.

המלכודת של string(65)

המרה של מספר שלם ל-string לא מייצרת ספרות. היא מייצרת את התו עם ה-code point הזה של Unicode:

n := 65
s := string(n) // "A", not "65"

המהדר מקבל את זה, אבל go vet מדווח על זה:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

אם באמת רוצים את התו, אמרו את זה עם rune: string(rune(n)). אם רוצים את המספר כטקסט, השתמשו ב-strconv.Itoa(n). המרה של rune או byte ל-string תקינה ונפוצה:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

מחרוזות, bytes ו-runes

string, []byte ו-[]rune מומרים זה לזה עם T(v). כל המרה מעתיקה את הנתונים, כי מחרוזות הן immutable ו-slices לא:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

המירו ל-[]rune כשצריך לגשת לפי אינדקס או לשנות לפי תו; המירו ל-[]byte לקלט ופלט, ל-hashing ולעריכות ברמת הבית. הדף על runes ו-bytes מכסה UTF-8 בפירוט.

המרה מול type assertion

המרה משנה ערך מטיפוס קונקרטי אחד לאחר. הוצאת הערך הקונקרטי מתוך interface (any, error, io.Reader) היא פעולה אחרת, ה-type assertion:

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

קודם assertion, אחר כך המרה. צורת ה-comma-ok n, ok := v.(int) מונעת panic כשהטיפוס שגוי.

תקציר מהיר

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}