أنواع البيانات في Golang: int وfloat64 وstring وbool وbyte وrune

الأنواع الأساسية في Go هي الأرقام والقيم المنطقية والنصوص. لكل متغيّر نوع واحد بالضبط يُحدَّد وقت الترجمة، ولا تحوّل Go بين الأنواع نيابة عنك أبدًا. يطبع %T نوع أي قيمة:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

لاحظ أن 'G' تُطبع 71 بنوع int32: الحرف بين علامتي اقتباس مفردتين هو rune، أي رقم (نقطة رمز Unicode). وrune اسم بديل لـ int32 (النوع نفسه باسم ثانٍ)، لذا يبلغ %T عن int32. وبالمثل يبلغ byte عن uint8.

الأعداد الصحيحة

استخدم int افتراضيًا. تعيد len() قيمة int، وفهارس الشرائح int، وعدّادات الحلقات int. وعلى كل منصّة 64 بت يكون int بحجم 64 بت. لجأ إلى الأنواع محدّدة الحجم عندما يكون الحجم جزءًا من عقد: int32 في صيغة ملف ثنائية، وuint8 للبايتات الخام، وint64 لطابع زمني Unix بالنانوثانية.

تجنّب الأنواع عديمة الإشارة للكميات التي "لا يمكن أن تكون سالبة" مثل الأعداد. الطرح إلى ما دون الصفر يلتفّ إلى رقم ضخم بدل أن ينتج رقمًا سالبًا يمكنك التقاطه.

الحدود والفيضان

للحزمة math ثابت لكل حد. ووقت التشغيل تلتفّ العمليات الحسابية الصحيحة التي تفيض بصمت:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

لا panic ولا خطأ: 127 + 1 تصبح -128. التعابير الثابتة وحدها تُفحص وقت الترجمة (var b int8 = 128 لا تُترجم). إذا كان الفيضان ممكنًا في بياناتك، فافحص قبل العملية أو استخدم math/big.

حرفيات الأعداد الصحيحة

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

الأعداد العشرية

الحرفية التي فيها فاصلة عشرية أو أسّ (2.5 و1e6) نوعها float64 افتراضيًا، والحزمة math تأخذ float64 وتعيده. استخدمه ما لم تكن الذاكرة مهمّة في مصفوفة كبيرة.

الأعداد العشرية ثنائية، لذا فمعظم الكسور العشرية تقريبية:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

ينتج عن ذلك قاعدتان. لا تقارن الأعداد العشرية بـ == بعد العمليات الحسابية. ولا تخزّن المال في عدد عشري أبدًا: استخدم عددًا صحيحًا من السنتات، أو مكتبة أعداد عشرية.

قسمة عدد عشري على صفر تعطي +Inf أو -Inf أو NaN بدل panic. أما قسمة عدد صحيح على صفر فتسبّب panic وقت التشغيل (runtime error: integer divide by zero)، والقاسم الصفري الثابت خطأ ترجمة.

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

يحمل bool القيمة true أو false، وقيمته الصفرية false. لا تعامل Go الأرقام أو النصوص الفارغة أو nil كقيم منطقية. if count {} خطأ ترجمة؛ اكتب if count > 0 {}. المعاملات هي && و|| و!، و&& و|| تتوقّفان مبكرًا عند حسم النتيجة.

النصوص

الـ string سلسلة غير قابلة للتعديل من البايتات، وعادة ما تكون نصًا بترميز UTF-8. تعدّ len(s) البايتات لا الأحرف:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

يشغل é بايتين في UTF-8، لذا يبلغ len عن 6 لخمسة أحرف. النصوص بين علامتي اقتباس مزدوجتين تعالج رموز الهروب مثل \n؛ أما النصوص الخام بين علامتي الاقتباس المائلتين فلا تعالجها، ويمكن أن تمتد على عدة أسطر. صفحة النصوص تشرح الحزمة strings، وصفحة الـ runes والبايتات تشرح UTF-8 بالتفصيل.

byte وrune

هذه أسماء بديلة لا أنواع جديدة: byte وuint8 قابلان للتبادل دون تحويل. الأسماء تقول ما يعنيه الرقم.

الأعداد المركّبة

لدى Go أنواع مركّبة مدمجة، complex64 وcomplex128، مع real وimag والحزمة math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

برامج قليلة تحتاجها، لكن معالجة الإشارات وبعض الشيفرات العددية تحتاجها.

الأنواع المركّبة والمرجعية

تتجمّع الأنواع الأساسية في أنواع مركّبة. لكل منها صفحته:

any اسم بديل لـ interface{} (منذ Go 1.18) ويمكنه حمل قيمة من أي نوع.

الأنواع المسمّاة

يمكنك تعريف نوع جديد من نوع موجود. له التمثيل نفسه لكنه نوع مستقل، ويمكن أن تكون له توابع:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

هذه الصرامة مقصودة: لا يمكن تمرير UserID بالخطأ حيث يُتوقَّع OrderID. حوّل صراحة عندما تقصد ذلك: float64(t). راجع صفحة تحويل الأنواع للقواعد ودوال strconv للتنقّل بين الأرقام والنصوص.

القيم الصفرية

لكل نوع قيمة صفرية، وهي ما يحمله المتغيّر قبل أن تسند إليه شيئًا: 0 للأرقام، وfalse لـ bool، و"" للنصوص، وnil للمؤشرات والشرائح والخرائط والقنوات والدوال والواجهات. لا توجد متغيّرات غير مهيّأة في Go.