strconv

الوثائق الرسمية: strconv package - strconv - Go Packages

حزمة strconv تنفذ التحويل بين التمثيل النصي وأنواع البيانات الأساسية

الاستيراد

import (
  "strconv"
)

فيما يلي سيتم عرض كيفية الاستخدام من خلال أمثلة.

تحويل سلسلة إلى عدد صحيح

func Atoi(s string) (int, error)

s - السلسلة المراد تحويلها

func TestAoti(t *testing.T) {
  ints, err := strconv.Atoi("456789")
  fmt.Println(ints, err)
}

=== RUN   TestAoti
456789 <nil>
--- PASS: TestAoti (0.00s)
PASS

تحويل عدد صحيح إلى سلسلة

func Itoa(i int) string

i - العدد الصحيح المراد تحويله

func TestIota(t *testing.T) {
   str := strconv.Itoa(114)
   fmt.Println(str)
}

=== RUN   TestIota
114
--- PASS: TestIota (0.00s)
PASS

تحويل سلسلة إلى قيمة منطقية

func ParseBool(str string) (bool, error)

s - السلسلة المراد تحويلها

السلاسل التي يمكن تحويلها كالتالي

"1", "t", "T", "true", "TRUE", "True" // true
"0", "f", "F", "false", "FALSE", "False" // false

func TestAtob(t *testing.T) {
   parseBool, err := strconv.ParseBool("1")
   fmt.Println(parseBool, err)

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

   b2, err := strconv.ParseBool("FALSE")
   fmt.Println(b2, err)
}

=== RUN   TestAotb
true <nil>
true <nil>
false <nil>
--- PASS: TestAotb (0.00s)
PASS

تحويل قيمة منطقية إلى سلسلة

func FormatBool(b bool) string

b - القيمة المنطقية

func TestBota(t *testing.T) {
   fmt.Println(strconv.FormatBool(true))
   fmt.Println(strconv.FormatBool(false))
}

=== RUN   TestBota
true
false
--- PASS: TestBota (0.00s)
PASS

التحويل إلى سلسلة Go

كلاهما سيحول السلسلة إلى سلسلة Go بين علامتي اقتباس، والفرق هو أن الأخير سيُحوّل الأحرف غير ASCII عبر \u.

func TestQuote(t *testing.T) {
  fmt.Println(strconv.Quote("hello 世界"))
  fmt.Println(strconv.QuoteToASCII("hello 世界"))
}

=== RUN   TestQuote
"hello 世界"
"hello \u4e16\u754c"
--- PASS: TestQuote (0.00s)
PASS

تحويل سلسلة إلى عدد فاصلة عائمة

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

s - السلسلة المراد تحويلها
bitSize - عدد البتات

func TestParseFloat(t *testing.T) {
   float, err := strconv.ParseFloat("1.145114", 64)
   fmt.Println(float, err)

   float, err = strconv.ParseFloat("2.3333333333333333333", 64)
   fmt.Println(float, err)
}

=== RUN   TestFloat
1.145114 <nil>
2.3333333333333335 <nil>
--- PASS: TestFloat (0.00s)
PASS

تحويل عدد فاصلة عائمة إلى سلسلة

عند تحويل السلاسل إلى أرقام فاصلة عائمة، قدمت الجهة الرسمية عدة طرق للتنسيق، من أجل إخراج أنماط مختلفة.

// 'b' (-ddddp±ddd، أس ثنائي),
// 'e' (-d.dddde±dd، حرف e صغير للأس العشري),
// 'E' (-d.ddddE±dd، حرف E كبير للأس العشري),
// 'f' (-ddd.dddd، بدون أس), // بدون متطلبات خاصة يُستخدم هذا عادةً
// 'g' (للأس الكبير يُستخدم تنسيق 'e'، للأس الصغير يُستخدم تنسيق 'f'),
// 'G' (للأس الكبير يُستخدم تنسيق 'e'، للأس الصغير يُستخدم تنسيق 'f')，
// 'x' (-0xd.ddddp±ddd، كسر سداسي عشر وأس ثنائي),
// 'X' (-0Xd.ddddP±ddd، كسر سداسي عشر وأس ثنائي).

دالة التحويل

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

f - رقم الفاصلة العائمة المراد تحويله
fmt - نوع التنسيق
prec - الدقة، باستثناء حالات g/G حيث تعني الحد الأقصى لعدد الأرقام الفعالة، في الحالات الأخرى تعني عدد الخانات العشرية المحتفظ بها
bitzise - عدد البتات

بالطبع في الحالات العامة يُستخدم f لتحويل صيغة الأرقام العشرية بشكل مباشر وهو الأكثر شيوعاً.

func TestFormatFloat(t *testing.T) {
   f := 1315643.14159261234567891011
   fmt.Println(strconv.FormatFloat(f, 'f', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'b', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'e', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'x', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'g', 6, 64))
   fmt.Println(strconv.FormatFloat(1.111, 'g', 6, 64))
}

=== RUN   TestFormatFloat
1315643.141593
5650644266346967p-32
1.315643e+06
0x1.4133b2p+20
1.31564e+06
1.111
--- PASS: TestFormatFloat (0.00s)
PASS

تحويل سلسلة إلى عدد مركب

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

s - السلسلة المراد تحويلها
bitSize - عدد البتات

func TestParseComplex(t *testing.T) {
   fmt.Println(strconv.ParseComplex("1+2i", 128))
   fmt.Println(strconv.ParseComplex("1+2j", 128))
}

=== RUN   TestParseComplex
(1+2i) <nil>
(0+0i) strconv.ParseComplex: parsing "1+2j": invalid syntax
--- PASS: TestParseComplex (0.00s)
PASS

تحويل عدد مركب إلى سلسلة

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

c- العدد المركب

fmt - نوع التنسيق، راجع أنواع تنسيق أرقام الفاصلة العائمة

prec - راجع دقة أرقام الفاصلة العائمة

bitsize - عدد البتات

func TestFormatComplex(t *testing.T) {
   fmt.Println(strconv.FormatComplex(complex(1.1, 12), 'f', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(5.6, 2.8), 'b', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(18.88999, 89.7), 'g', 2, 128))
}

=== RUN   TestFormatComplex
(1.10+12.00i)
(6305039478318694p-50+6305039478318694p-51i)
(19+90i)
--- PASS: TestFormatComplex (0.00s)
PASS

إلحاق البيانات بسلسلة

في لغات أخرى مثل Java، نتيجة "1"+1 هي "11"، حيث تقوم Java بإجراء تحويل النوع تلقائياً، أما في لغة Go فهذه العملية غير مسموح بها، لأن النوعين مختلفان. لذلك نحتاج لاستخدام دوال Append تحت strconv، ومعاملاتها هي نفسها دوال تحويل البيانات المقابلة أعلاه.

func TestAppend(t *testing.T) {
   bytes := []byte("هنا بعض البيانات:")
   bytes = strconv.AppendInt(bytes, 10, 10)
   bytes = strconv.AppendFloat(bytes, 1.2222, 'f', 2, 64)
   bytes = strconv.AppendBool(bytes, false)
   fmt.Println(string(bytes))
}

=== RUN   TestAppend
هنا بعض البيانات:101.22false
--- PASS: TestAppend (0.00s)
PASS

strconv ​

الاستيراد ​

تحويل سلسلة إلى عدد صحيح ​

تحويل عدد صحيح إلى سلسلة ​

تحويل سلسلة إلى قيمة منطقية ​

تحويل قيمة منطقية إلى سلسلة ​

التحويل إلى سلسلة Go ​

تحويل سلسلة إلى عدد فاصلة عائمة ​

تحويل عدد فاصلة عائمة إلى سلسلة ​

تحويل سلسلة إلى عدد مركب ​

تحويل عدد مركب إلى سلسلة ​

إلحاق البيانات بسلسلة ​