المعاملات الشائعة

عمليات المعاملات هي العمليات التي تستخدم جميع أنواع المعاملات. ستقدّم هذه المقالة المعاملات الشائعة في Go. وستُقدَّم معاملات أخرى في مقالات أخرى لاحقًا.

حول بعض الأوصاف الواردة في شروح المعاملات

ستقدّم هذه المقالة المعاملات الحسابية ومعاملات البتات ومعاملات المقارنة والمعاملات المنطقية ومعامل دمج النصوص فقط. هذه المعاملات إما معاملات ثنائية وإما معاملات أحادية. تأخذ عملية المعامل الثنائي معامَلين به، بينما تأخذ عملية المعامل الأحادي معامَلًا به واحدًا فقط.

كل عملية من عمليات المعاملات المقدَّمة في هذه المقالة تُرجع نتيجة واحدة.

لا تسعى هذه المقالة إلى دقة بعض الأوصاف. فمثلًا، عندما يُقال إن معاملًا ثنائيًا يشترط أن يكون نوعا معامَلَيه به متماثلين، فالمقصود هو:

• إذا كانت قيمتا المعامَلَين به مُنمَّطتين، فيجب أن يكون نوعاهما النوع نفسه، أو أن يكون أحد المعامَلَين به قابلًا للتحويل الضمني إلى نوع الآخر.
• إذا كانت إحدى القيمتين فقط مُنمَّطة، فيجب أن تكون القيمة الأخرى (غير المُنمَّطة) قابلة للتمثيل كقيمة من نوع المعامَل به المُنمَّط، أو أن تكون قيم النوع الافتراضي للمعامَل به الآخر (غير المُنمَّط) قابلة للتحويل الضمني إلى نوع المعامَل به المُنمَّط.
• إذا كانت قيمتا المعامَلَين به غير مُنمَّطتين، فيجب أن تكونا قيمتين منطقيتين، أو قيمتين نصيتين، أو قيمتين عدديتين أساسيتين.

وبالمثل، عندما يُقال إن معاملًا ما، ثنائيًا كان أو أحاديًا، يشترط أن يكون نوع أحد معامَلاته به من نوع معيّن، فالمقصود هو:

• إذا كان المعامَل به مُنمَّطًا، فيجب أن يكون نوعه ذلك النوع المعيّن، أو قابلًا للتحويل الضمني إليه.
• إذا كان المعامَل به غير مُنمَّط، فيجب أن تكون القيمة غير المُنمَّطة قابلة للتمثيل كقيمة من ذلك النوع المعيّن، أو أن تكون قيم النوع الافتراضي للمعامَل به قابلة للتحويل الضمني إلى ذلك النوع المعيّن.

التعابير الثابتة

قبل تقديم جميع أنواع المعاملات، ينبغي أن نعرف ما هي التعابير الثابتة وحقيقةً في تقييم التعابير الثابتة. ستُشرح التعابير في مقالة لاحقة التعابير والجمل. في الوقت الحالي، يكفي أن نعرف أن معظم العمليات المذكورة في هذه المقالة هي تعابير.

إذا كانت جميع المعامَلات بها الداخلة في تعبير ثوابت، فإن هذا التعبير يُسمى تعبيرًا ثابتًا. تُقيَّم جميع التعابير الثابتة في وقت التصريف. ونتيجة تقييم التعبير الثابت تبقى ثابتًا.

ولا يُسمى التعبير تعبيرًا غير ثابت إلا إذا كان أحد المعامَلات به فيه ليس ثابتًا.

المعاملات الحسابية

تدعم Go خمسة معاملات حسابية ثنائية أساسية:

المعامل	الاسم	الشروط المفروضة على المعامَلَين به
+	الجمع	يجب أن تكون قيمتا المعامَلَين به من النوع العددي الأساسي نفسه.
-	الطرح
*	الضرب
/	القسمة
%	باقي القسمة	يجب أن تكون قيمتا المعامَلَين به من النوع الصحيح الأساسي نفسه.

كثيرًا ما تُسمى هذه المعاملات الخمسة أيضًا معاملات المجموع والفرق والجداء وخارج القسمة وباقي القسمة على الترتيب. لن تشرح Go 101 كيفية عمل عمليات هذه المعاملات بالتفصيل.

تدعم Go ستة معاملات حسابية ثنائية على البتات:

المعامل	الاسم	الشروط المفروضة على المعامَلَين به وشرح الآلية
&	«و» على البتات	يجب أن تكون قيمتا المعامَلَين به من النوع الصحيح نفسه. شرح الآلية (القيمة التي يحمل الرمز السفلي 2 صيغتها الحرفية الثنائية): 11002 & 10102 نتيجتها 10002 `11002
`	`	«أو» على البتات
^	«أو الحصرية» على البتات
&^	المسح على البتات
<<	الإزاحة اليسرى على البتات	يجب أن يكون المعامَل به الأيسر عددًا صحيحًا، ويجب أن يكون المعامَل به الأيمن أيضًا عددًا صحيحًا (وإذا كان ثابتًا فيجب أن يكون غير سالب)، ولا يُشترط تطابق نوعيهما. (لاحظ أنه قبل Go 1.13، كان يجب أن يكون المعامَل به الأيمن عددًا صحيحًا غير مُوقَّع أو ثابتًا صحيحًا غير مُنمَّط قابلًا للتمثيل كقيمة uint.) المعامَل به الأيمن السالب (الذي يجب أن يكون غير ثابت) سيؤدي إلى panic في وقت التشغيل. شرح الآلية: 11002 << 3 نتيجتها 11000002 11002 >> 3 نتيجتها 12 ملاحظة: في عملية الإزاحة اليمنى على البتات، تُملأ جميع البتات المُفرَغة على اليسار ببتة الإشارة (أعلى بتة) للمعامَل به الأيسر. مثلًا، إذا كان المعامَل به الأيسر قيمة int8 تساوي -128، أو 100000002 في الصيغة الحرفية الثنائية، فإن 100000002 >> 2 نتيجتها 111000002، أي -32.
>>	الإزاحة اليمنى على البتات

تدعم Go أيضًا ثلاثة معاملات حسابية أحادية:

المعامل	الاسم	الشروح
+	الموجب	+n مكافئة لـ 0 + n.
-	السالب	-n مكافئة لـ 0 - n.
^	المتمّم على البتات
(النفي على البتات)	^n مكافئة لـ m ^ n، حيث m قيمة جميع بتاتها 1. مثلًا، إذا كان نوع n هو int8، فإن m هي -1، وإذا كان نوع n هو uint8، فإن m هي 0xFF.

لاحظ ما يلي:

• في كثير من اللغات الأخرى، يُرمز إلى معامل المتمّم على البتات بـ ~.
• وكما في كثير من اللغات الأخرى، يمكن استخدام معامل الجمع الثنائي + أيضًا معاملًا لدمج النصوص، وسيُقدَّم ذلك أدناه.
• وكما في لغتي C وC++، يمكن استخدام معامل الضرب الثنائي * أيضًا معاملًا لإلغاء الإشارة إلى المؤشر، ويمكن استخدام معامل «و» على البتات & أيضًا معاملًا لأخذ العنوان. يُرجى قراءة المؤشرات في Go للتفاصيل لاحقًا.
• وخلافًا للغة Java، تدعم Go أنواع الأعداد الصحيحة غير المُوقَّعة، لذا لا يوجد في Go معامل الإزاحة غير المُوقَّعة >>>.
• لا يوجد في Go معامل للرفع إلى قوة، استخدم بدلًا منه الدالة Pow في الحزمة القياسية math. ستُقدَّم حزمة الشيفرة واستيراد الحزم في المقالة التالية الحزم والاستيرادات.
• معامل المسح على البتات &^ معامل فريد في Go. m &^ n مكافئة لـ m & (^n).

مثال:

func main() {
	var (
		a, b float32 = 12.0, 3.14
		c, d int16   = 15, -6
		e	uint8   = 7
	)

	// هذه الجمل تُصرَّف بنجاح.
	_ = 12 + 'A' // معامَلان به عدديان غير مُنمَّطين
	_ = 12 - a   // معامَل به غير مُنمَّط ومعامَل به مُنمَّط
	_ = a * b    // معامَلان به مُنمَّطان
	_ = c % d
	_, _ = c + int16(e), uint8(c) + e
	_, _, _, _ = a / b, c / d, -100 / -9, 1.23 / 1.2
	_, _, _, _ = c | d, c & d, c ^ d, c &^ d
	_, _, _, _ = d << e, 123 >> e, e >> 3, 0xF << 0
	_, _, _, _ = -b, +c, ^e, ^-1

	// الجمل التالية يفشل تصريفها.
	_ = a % b   // خطأ: a و b ليسا عددين صحيحين
	_ = a | b   // خطأ: a و b ليسا عددين صحيحين
	_ = c + e   // خطأ: عدم تطابق الأنواع
	_ = b >> 5  // خطأ: b ليس عددًا صحيحًا
	_ = c >> -5 // خطأ: القيمة -5 غير قابلة للتمثيل كقيمة uint

	_ = e << uint(c) // تُصرَّف بنجاح
	_ = e << c       // لا تُصرَّف بنجاح إلا منذ Go 1.13
	_ = e << -c      // لا تُصرَّف بنجاح إلا منذ Go 1.13،
	                 // وستؤدي إلى panic في وقت التشغيل.
	_ = e << -1      // خطأ: المعامَل به الأيمن سالب
}

حول الطفح

لا يُسمح بالطفح (overflow) في قيم الثوابت المُنمَّطة، لكنه مسموح في القيم غير الثابتة وقيم الثوابت غير المُنمَّطة، سواء أكانت القيم نتائج وسيطة أم نهائية. تُقتطع القيم غير الثابتة عند الطفح (أو تُلَفّ حول نفسها)، أما الطفح في قيمة ثابتة غير مُنمَّطة (بالنسبة إلى الأنواع الافتراضية) فلا يُقتطع (ولا يُلَفّ حول نفسه).

مثال:

// النتائج قيم غير ثابتة.
var a, b uint8 = 255, 1
// تُصرَّف بنجاح، وتُقتطع البتات العليا الطافحة.
var c = a + b  // c == 0
// تُصرَّف بنجاح، وتُقتطع البتات العليا الطافحة.
var d = a << b // d == 254

// النتائج ثوابت غير مُنمَّطة.
const X = 0x1FFFFFFFF * 0x1FFFFFFFF // يطفح نوع int
const R = 'a' + 0x7FFFFFFF          // يطفح نوع rune
// السطران أعلاه يُصرَّفان بنجاح، مع أن
// القيمتين غير المُنمَّطتين X و R تطفحان
// نوعيهما الافتراضيين على الترتيب.

// نتائج العمليات أو نتائج التحويلات
// قيم مُنمَّطة. جميع هذه الأسطر يفشل تصريفها.
var e = X // خطأ: الثابت غير المُنمَّط X يطفح نوع int
var h = R // خطأ: الثابت 2147483744 يطفح نوع rune
const Y = 128 - int8(1)  // خطأ: القيمة 128 تطفح نوع int8
const Z = uint8(255) + 1 // خطأ: القيمة 256 تطفح نوع uint8

حول نتائج عمليات المعاملات الحسابية

باستثناء عمليات الإزاحة على البتات، فإن نتيجة عملية معامل حسابي ثنائي

• قيمة مُنمَّطة من النوع نفسه لكل من المعامَلَين به إذا كانت قيمتا المعامَلَين به مُنمَّطتين ومن النوع نفسه.
• قيمة مُنمَّطة من النوع نفسه للمعامَل به المُنمَّط إذا كانت إحدى القيمتين فقط مُنمَّطة. وفي الحساب، ستُستنتج القيمة الأخرى (غير المُنمَّطة) كقيمة من نوع المعامَل به المُنمَّط. وبعبارة أخرى، سيُحوَّل المعامَل به غير المُنمَّط ضمنيًا إلى نوع المعامَل به المُنمَّط.
• قيمة غير مُنمَّطة إذا كانت قيمتا المعامَلَين به غير مُنمَّطتين. والنوع الافتراضي لقيمة النتيجة هو أحد النوعين الافتراضيين، وهو النوع الذي يظهر لاحقًا في هذه القائمة: int، rune، float64، complex128. مثلًا، إذا كان النوع الافتراضي لأحد المعامَلَين به غير المُنمَّطين هو int، وكان الآخر rune، فإن النوع الافتراضي لقيمة النتيجة غير المُنمَّطة هو rune.

قواعد نتيجة عملية معامل الإزاحة على البتات معقّدة قليلًا. أولًا، قيمة النتيجة دائمًا قيمة صحيحة. أما ما إذا كانت مُنمَّطة أم غير مُنمَّطة فيعتمد على حالات محدّدة.

• إذا كان المعامَل به الأيسر قيمة مُنمَّطة (قيمة صحيحة)، فإن نوع النتيجة هو نوع المعامَل به الأيسر نفسه.
• إذا كان المعامَل به الأيسر قيمة غير مُنمَّطة وكان المعامَل به الأيمن ثابتًا، فستُعامَل القيمة اليسرى دائمًا كقيمة صحيحة، وإذا لم يكن نوعها الافتراضي نوعًا صحيحًا، فيجب أن تكون قابلة للتمثيل كعدد صحيح غير مُنمَّط ويُنظر إلى نوعها الافتراضي على أنه int. في هذه الحالات، تكون النتيجة أيضًا قيمة غير مُنمَّطة، والنوع الافتراضي للنتيجة هو النوع الافتراضي نفسه للمعامَل به الأيسر.
• إذا كان المعامَل به الأيسر قيمة غير مُنمَّطة وكان المعامَل به الأيمن عددًا صحيحًا غير ثابت، فسيُحوَّل المعامَل به الأيسر أولًا إلى النوع الذي كان سيفترضه لو استُبدلت عملية الإزاحة على البتات بالمعامَل به الأيسر وحده. والنتيجة قيمة مُنمَّطة نوعها هو النوع المفترض.

مثال:

func main() {
	// ثلاث قيم غير مُنمَّطة. أنواعها
	// الافتراضية هي: int و rune(int32) و complex64.
	const X, Y, Z = 2, 'A', 3i

	var a, b int = X, Y // قيمتان مُنمَّطتان.

	// نوع d هو النوع الافتراضي لـ Y: rune.
	d := X + Y
	// نوع e هو نوع a: int.
	e := Y - a
	// نوع f هو نوعا a و b: int.
	f := a * b
	// نوع g هو النوع الافتراضي لـ Z: complex64.
	g := Z * Y

	// المخرجات: 2 65 (+0.000000e+000+3.000000e+000i)
	println(X, Y, Z)
	// المخرجات: 67 63 130 (+0.000000e+000+1.950000e+002i)
	println(d, e, f, g)
}

مثال آخر (عمليات الإزاحة على البتات):

const N = 2
// A قيمة غير مُنمَّطة (نوعها الافتراضي int).
const A = 3.0 << N // A == 12
// B قيمة مُنمَّطة (نوعها int8).
const B = int8(3.0) << N // B == 12

var m = uint(32)
// الأسطر الثلاثة التالية متكافئة. وفي
// السطرين الأخيرين منها، يُستنتج نوعا
// القيمتين "1" كلاهما كـ int64،
// وليس int.
var x int64 = 1 << m
var y = int64(1 << m)
var z = int64(1) << m

// السطر التالي يفشل تصريفه.
/*
var _ = 1.23 << m // خطأ: إزاحة من النوع float64
*/

القاعدة الأخيرة لعملية معامل الإزاحة على البتات وُضعت لتجنّب الحالات التي تُرجع فيها بعض عمليات الإزاحة على البتات نتائج مختلفة على معماريات مختلفة دون اكتشاف هذه الاختلافات في الوقت المناسب. مثلًا، إذا استُنتج نوع المعامَل به 1 كـ int بدلًا من int64، فستُرجع عملية البتات في السطر 13 (أو السطر 12) نتائج مختلفة بين معماريات 32 بت (0) ومعماريات 64 بت (2³²)، مما قد يولّد أخطاء يصعب اكتشافها في الوقت المناسب.

تُظهر مقتطفة الشيفرة التالية نتيجة طريفة تترتب على القاعدة الأخيرة لعملية معامل الإزاحة على البتات:

const n = uint(2)
var m = uint(2)

// السطران التاليان يُصرَّفان بنجاح.
var _ float64 = 1 << n
var _ = float64(1 << n)

// السطران التاليان يفشل تصريفهما.
var _ float64 = 1 << m
var _ = float64(1 << m)

سبب فشل تصريف السطرين الأخيرين هو أن كليهما مكافئ للسطرين التاليين:

var _ = float64(1) << m
var _ = 1.0 << m // خطأ: إزاحة من النوع float64

مثال آخر:

package main

const n = uint(8)
var m = uint(8)

func main() {
	println(a, b) // 2 0
}

var a byte = 1 << n / 128
var b byte = 1 << m / 128

يطبع البرنامج أعلاه 2 0، لأن السطرين الأخيرين مكافئان لـ

var a = byte(int(1) << n / 128)
var b = byte(1) << m / 128

حول عمليات قسمة الأعداد الصحيحة وباقي القسمة

افترض أن x وy معامَلان به من النوع الصحيح نفسه؛ فإن خارج القسمة الصحيح q (= x / y) وباقي القسمة r (= x % y) يحققان x == q*y + r، حيث |r| < |y|. وإذا لم تكن r صفرًا، فإن إشارتها هي إشارة x (المقسوم). ونتيجة x / y تُقتطع باتجاه الصفر.

إذا كان المقسوم عليه y ثابتًا، فيجب ألا يكون صفرًا. وإذا كان المقسوم عليه صفرًا في وقت التشغيل وكان عددًا صحيحًا، فسيحدث panic في وقت التشغيل. تشبه حالات panic الاستثناءات في بعض اللغات الأخرى. ويمكننا معرفة المزيد عن حالات panic في هذه المقالة.

مثال:

println( 5/3,   5%3)  // 1 2
println( 5/-3,  5%-3) // -1 2
println(-5/3,  -5%3)  // -1 -2
println(-5/-3, -5%-3) // 1 -2

println(5.0 / 3.0)     // 1.666667
println((1-1i)/(1+1i)) // -1i

var a, b = 1.0, 0.0
println(a/b, b/b) // +Inf NaN

_ = int(a)/int(b) // تُصرَّف بنجاح لكنها تؤدي إلى panic في وقت التشغيل.

// السطران التاليان يفشل تصريفهما.
println(1.0/0.0) // خطأ: القسمة على صفر
println(0.0/0.0) // خطأ: القسمة على صفر

استخدام op= مع المعاملات الحسابية الثنائية

بالنسبة إلى معامل حسابي ثنائي op، يمكن اختصار x = x op y إلى x op= y. وفي الصيغة المختصرة، ستُقيَّم x مرة واحدة فقط.

مثال:

var a, b int8 = 3, 5
a += b
println(a) // 8
a *= a
println(a) // 64
a /= b
println(a) // 12
a %= b
println(a) // 2
b <<= uint(a)
println(b) // 20

معاملا الزيادة ++ والنقصان --

وكما في كثير من اللغات الشائعة الأخرى، تدعم Go أيضًا معاملي الزيادة ++ والنقصان --. غير أن العمليات التي تستخدم هذين المعاملين لا تُرجع أي نتائج، لذا لا يمكن استخدام مثل هذه العمليات كتعابير. ويجب أن يكون المعامَل به الوحيد الداخل في مثل هذه العملية قيمة عددية، ويجب ألا تكون هذه القيمة العددية ثابتًا، ويجب أن يتبع المعامل ++ أو -- المعامَل به.

مثال:

package main

func main() {
	a, b, c := 12, 1.2, 1+2i
	a++ // صحيحة. <=> a += 1 <=> a = a + 1
	b-- // صحيحة. <=> b -= 1 <=> b = b - 1
	c++ // صحيحة

	// الأسطر التالية يفشل تصريفها.
	/*
	_ = a++
	_ = b--
	_ = c++
	++a
	--b
	++c
	*/
}

معامل دمج النصوص

كما ذُكر أعلاه، يمكن استخدام معامل الجمع أيضًا لدمج النصوص.

المعامل	الاسم	الشروط المفروضة على المعامَلَين به
+	دمج النصوص	يجب أن تكون قيمتا المعامَلَين به من النوع النصي نفسه.

تنطبق صيغة op= أيضًا على معامل دمج النصوص.

مثال:

println("Go" + "lang") // Golang
var a = "Go"
a += "lang"
println(a) // Golang

إذا كان أحد معامَلَي به عملية دمج النصوص نصًا مُنمَّطًا، فإن نوع النص الناتج هو نوع النص المُنمَّط نفسه. وإذا كان كلا المعامَلَين به نصين غير مُنمَّطين (ثابتين)، فإن النتيجة أيضًا قيمة نصية غير مُنمَّطة.

المعاملات المنطقية (Boolean)

تدعم Go معاملين منطقيين ثنائيين ومعاملًا منطقيًا أحاديًا واحدًا:

المعامل	الاسم	الشروط المفروضة على المعامَلَين به
&&	«و» المنطقية (ثنائية)
وتُعرف أيضًا بـ«و» الشرطية	يجب أن تكون قيمتا المعامَلَين به من النوع المنطقي نفسه.
`		`
وتُعرف أيضًا بـ«أو» الشرطية
!	«ليس» المنطقية (أحادية)	يجب أن يكون نوع المعامَل به الوحيد نوعًا منطقيًا.

يمكننا استخدام المعامل != المقدَّم في القسم الفرعي التالي معاملًا لـ«أو الحصرية» المنطقية.

شرح الآلية:

// x    y       x && y   x || y   !x      !y
true    true    true     true     false   false
true    false   false    true     false   true
false   true    false    true     true    false
false   false   false    false    true    true

إذا كانت إحدى القيمتين منطقية مُنمَّطة، فإن نوع النتيجة المنطقية هو نوع القيمة المنطقية المُنمَّطة نفسه. وإذا كانت قيمتا المعامَلَين به منطقيتين غير مُنمَّطتين، فإن النتيجة أيضًا قيمة منطقية غير مُنمَّطة.

معاملات المقارنة

تدعم Go ستة معاملات مقارنة ثنائية:

المعامل	الاسم	الشروط المفروضة على المعامَلَين به
==	يساوي	عمومًا، يجب أن يكون نوعا معامَلَيه به متطابقين. للقواعد التفصيلية، يُرجى قراءة قواعد المقارنة في Go.
!=	لا يساوي
<	أصغر من	يجب أن تكون قيمتا المعامَلَين به من النوع الصحيح نفسه أو النوع العشري نفسه أو النوع النصي نفسه.
<=	أصغر من أو يساوي
>	أكبر من
>=	أكبر من أو يساوي

نوع نتيجة أي عملية مقارنة هو دائمًا قيمة منطقية غير مُنمَّطة. وإذا كان معامَلا به عملية مقارنة ثابتين، فإن النتيجة أيضًا قيمة ثابتة (منطقية).

لاحقًا، إذا قلنا إن قيمتين قابلتان للمقارنة، فإننا نعني أنه يمكن مقارنتهما بالمعاملين == و!=. وسنعرف لاحقًا أنواع القيم غير القابلة للمقارنة. جميع قيم الأنواع الأساسية قابلة للمقارنة.

يُرجى ملاحظة أنه لا يمكن تمثيل جميع الأعداد الحقيقية تمثيلًا دقيقًا في الذاكرة، لذا قد لا تكون مقارنة قيمتين عشريتين (أو مركّبتين) موثوقة. ينبغي أن نتحقق مما إذا كانت القيمة المطلقة للفرق بين قيمتين عشريتين أصغر من عتبة صغيرة لنحكم على تساوي القيمتين العشريتين.

أسبقية المعاملات

فيما يلي أسبقية المعاملات في Go. المعاملات الأعلى لها أسبقية أعلى. والمعاملات في السطر نفسه لها الأسبقية نفسها. وكما في كثير من اللغات الأخرى، يمكن استخدام () لرفع الأسبقية.

*   /   %   <<  >>  &   &^
+   -   |   ^
==  !=  <   <=  >   >=
&&
||

أحد الفروق الواضحة عن بعض اللغات الشائعة الأخرى هو أن أسبقية << و>> في Go أعلى من أسبقية + و-.

المزيد حول التعابير الثابتة

سيُهيَّأ المتغير المُعرَّف التالي على القيمة 2.2 بدلًا من 2.7. والسبب هو أن أسبقية عملية القسمة أعلى من أسبقية عملية الجمع، وفي عملية القسمة يُنظر إلى كل من 3 و2 على أنهما عددان صحيحان. ونتيجة تقييم 3/2 هي 1.

var x = 1.2 + 3/2

الثابتان المُسمَّيان المُعرَّفان في البرنامج التالي غير متساويين. في التعريف الأول، يُنظر إلى كل من 3 و2 على أنهما عددان صحيحان. أما في التعريف الثاني، فيُنظر إليهما على أنهما عددان عشريان.

package main

const x = 3/2*0.1
const y = 0.1*3/2

func main() {
	println(x) // +1.000000e-001
	println(y) // +1.500000e-001
}

المزيد من المعاملات

كما في C/C++، يوجد معاملان متعلقان بالمؤشرات هما * و&. نعم، إنهما رمزا المعاملين نفسيهما المستخدمين في الضرب و«و» على البتات. يُستخدم & لأخذ عنوان قيمة قابلة لعنونة، ويُستخدم * لإلغاء الإشارة إلى قيمة مؤشر. وخلافًا لـ C/C++، لا تدعم قيم أنواع المؤشرات العمليات الحسابية في Go. لمزيد من التفاصيل، يُرجى قراءة المؤشرات في Go لاحقًا.

توجد في Go بعض المعاملات الأخرى. وستُقدَّم وتُشرح في مقالات أخرى من Go 101.