تحويل int إلى string والعكس وتحويل الأنواع في Golang

لا تحوّل 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، لأن البتات الثمانية الدنيا وحدها تبقى (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 تعني "أقل عدد من الأرقام يعيد القيمة نفسها بدقة")، وحجم البتات للعدد العشري الأصلي (64 أو 32).

strconv أسرع من fmt.Sprint، التي تضع القيمة في واجهة وتمرّ بمسار التنسيق العام في 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 لا ينتج أرقامًا. بل ينتج الحرف صاحب نقطة رمز 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
}

النصوص والبايتات والـ runes

تتحوّل string و[]byte و[]rune فيما بينها بـ T(v). كل تحويل ينسخ البيانات، لأن النصوص غير قابلة للتعديل والشرائح قابلة:

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 للإدخال والإخراج والتجزئة والتعديلات على مستوى البايت. صفحة الـ runes والبايتات تشرح UTF-8 بالتفصيل.

التحويل مقابل تأكيد النوع

يغيّر التحويل قيمة من نوع محدّد إلى آخر. أما استخراج القيمة المحدّدة من واجهة (any أو error أو io.Reader) فعملية مختلفة، هي تأكيد النوع:

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

أكّد أولًا، ثم حوّل. وصيغة comma-ok n, ok := v.(int) تتجنّب panic عندما يكون النوع خاطئًا.

مرجع سريع

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