عناصر الحسابات بلغة Go

العمليات الحسابية هي أساس أي لغة برمجة. لذلك، لا تكون وظائف لغة Go كاملة بدون استخدام العمليات الحسابية. العمليات الحسابية تسمح لنا بتنفيذ أنواع مختلفة من العمليات على العناصر. في لغة Go، يمكن تصنيف العمليات الحسابية بناءً على وظائفها المختلفة:

• عناصر الحساب

• العلامات العلاقية

• عموديات منطقية

• أجهزة الحساب موضعية

• عمود التساوي

• عمليات متنوعة

عناصر الحساب

هذه تستخدم لتوليد العمليات الحسابية/الرياضية للعناصر في لغة Go:

• الجمع مصطلح '+' يضيف بين العناصر. مثال، x + y.

• الطرح مصطلح '-' ينقص بين العناصر. مثال، x-y.

• جمع مصطلح '*' يضرب بين العناصر. مثال، x * y.

• حساب القسمة: علامة '/' تعطي نتيجة قسمة أول عمليات التحقق بثاني عمليات التحقق. مثل x / y.

• حساب المتبقي:عند قسمة أول عمليات التحقق بثاني عمليات التحقق، يعود عمود '% ' الناتج المتبقي. مثل x % y.

ملاحظة: -،+،!،＆،*،<- و ^ تُسمى أيضًا علامات علاقية ثنائية، وتمتلك علامات العلاقية الثنائية أولوية أعلى. علامات ++ و -- تأتي من جملة، ليست تعبيرات، لذا لا تكون جزءًا من هيكل العلامات العلاقية.

package　main
import　"fmt"
func　main()　{
　　　　p := 34
　　　　q := 20
　　　　// حساب النقطة
　　　　result1 := p + q
　　　　fmt.Printf("نتيجة الحساب p + q = %d", result1)
　　　　// حساب الجمع
　　　　result2 := p - q
　　　　fmt.Printf("\nنتيجة الحساب p - q = %d", result2)
　　　　// حساب الضرب
　　　　result3 := p * q
　　　　fmt.Printf("\nنتيجة الحساب p * q = %d", result3)
　　　　// حساب القسمة
　　　　result4 := p / q
　　　　fmt.Printf("\nنتيجة الحساب p / q = %d", result4)
　　　　// حساب المتبقي
　　　　result5 := p % q
　　　　fmt.Printf("\nنتيجة الحساب p %% q = %d", result5)
}

الإخراج:

نتيجة الحساب p + q = 54
نتيجة الحساب p - q = 14
نتيجة الحساب p * q = 680
نتيجة الحساب p / q = 1
نتيجة الحساب p % q = 14

العلامات العلاقية

استخدام العلامات العلاقية للتحقق من مقارنة قيمتين. دعنا نرى واحدة تلو الأخرى:

• '==' (يساوي)المعادلة التحقق من أن أول عمليات التحقق متساوية مع ثاني عمليات التحقق. إذا كانت متساوية، فإنه يعود صحيحًا. وإلا يعود خطأ. على سبيل المثال، 5==5 يعود صحيحًا.

• '!=' (غير متساوي)المعادلة التحقق من أن أول عمليات التحقق غير متساوية مع ثاني عمليات التحقق. إذا كانت غير متساوية، فإنه يعود صحيحًا. وإلا يعود خطأ. إنه إضافة بولية دقيقة لمعادلة '=='.

• '>' (أكبر)المعادلة التحقق من أن أول عمليات التحقق أكبر من ثاني عمليات التحقق. إذا كان أكبر، فإنه يعود صحيحًا. وإلا يعود خطأ. على سبيل المثال، 6>5 يعود صحيحًا.

• '<' (أصغر)المعادلة التحقق من أن أول عمليات التحقق أصغر من ثاني عمليات التحقق. إذا كان أصغر، فإنه يعود صحيحًا. وإلا يعود خطأ. على سبيل المثال، 6<5 يعود خطأ.

• '>=' (أكبر أو يساوي)المعادلة التحقق من أن أول عمليات التحقق أكبر أو يساوي ثاني عمليات التحقق. إذا كان أكبر أو يساوي، فإنه يعود صحيحًا. وإلا يعود خطأ. على سبيل المثال، 5>=5 يعود صحيحًا.

• “ <=”（小于等于）تحقق العداد الأول إذا كان أقل أو يساوي العداد الثاني. إذا كان أقل أو يساوي، فإنه يعود إلى صحيح. وإلا يعود إلى خطأ. على سبيل المثال، 5 <= 5也将 يعود إلى صحيح.

package　main
import　"fmt"
func　main()　{
　　　　p := 34
　　　　q := 20
　　　　// ‘==’ (يساوي)
　　　　result1 := p == q
　　　　fmt.Println(result1)
　　　　// ‘!=’ (غير يساوي)
　　　　result2 := p != q
　　　　fmt.Println(result2)
　　　　// ‘<’ (أقل من)
　　　　result3 := p < q
　　　　fmt.Println(result3)
　　　　// ‘>’ (أكبر من)
　　　　result4 := p > q
　　　　fmt.Println(result4)
　　　　// ‘>=’ (أكبر من أو يساوي)
　　　　result5 := p >= q
　　　　fmt.Println(result5)
　　　　// ‘<=’ (أقل من أو يساوي)
　　　　result6 := p <= q
　　　　fmt.Println(result6)
}

الإخراج:

خطأ
صحيح
خطأ
صحيح
صحيح
خطأ

عموديات منطقية

• AND منطقي:عندما ي�� كلا الشروطين النظرية، يعود عمودي "&&" إلى صحيح. وإلا يعود إلى خطأ. على سبيل المثال، عندما يكون a وb صحيحين (أي غير صفر) فإن a && b يعود إلى صحيح.

• اللصح أو عندما ي�� أحد (أو كلا) الشروط، يعود عمودي "||" إلى صحيح. وإلا يعود إلى خطأ. على سبيل المثال، إذا كان a أو b صحيحاً (أي غير صفر)، فإن || b يعود إلى صحيح. بالطبع، عندما يكون a وb صحيحين، فإنه يعود إلى صحيح.

• اللاصح: بمعنى أنه لا ي��شروط النظر، "!" عمودية عائدة إلى صحيح. وإلا فإنه يعود إلى خطأ. على سبيل المثال، إذا كان a خطأ، أي a = 0، فإن !a يعود إلى صحيح.

package　main
import　"fmt"
func　main()　{
　　　　var p int = 23
　　　　var q int = 60
　　　　if p != q && p <= q {
　　　　　　　　fmt.Println("صحيح")
　　　　}
　　　　if p != q || p <= q {
　　　　　　　　fmt.Println("صحيح")
　　　　}
　　　　if !(p == q) {
　　　　　　　　fmt.Println("صحيح")
　　　　}
}

الإخراج:

صحيح
صحيح
صحيح

أجهزة الحساب موضعية

في لغة Go، هناك ستة أجهزة حساب موضعية يمكنها العمل موضعياً أو استخدامها لعمليات معالجة موضعية. إليك أجهزة الحساب موضعية:

• و (جمع موضعي): يتماثنان من الأرقام كعدادات، ويتم تنفيذ عمليات الجمع بين كل دالة من الأرقام باستخدام "الجمع". يتم حصول النتيجة AND فقط عندما تكون كلا الدوال 1.

• | (XOR): يأخذانرقمان كعمودين، ويقومان بحساب OR لكل موقع من المواقع. إذا كان أي موقع من المواقع يساوي 1، فإن نتيجة OR تساوي 1.يأخذانرقمان كعمودين، ويقومان بحساب OR لكل موقع من المواقع. إذا كان أي موقع من المواقع يساوي 1، فإن نتيجة OR تساوي 1.

• ^ (XOR): يأخذانرقمان كعمودين، ويقومان بحساب XOR لكل موقع من المواقع.يأخذانرقمان كعمودين، ويقومان بحساب XOR لكل موقع من المواقع.

• << (الانتقال إلى اليسار):يأخذانرقمان، ينتقلان بجعل الأول ينتقل إلى اليسار، والثاني يحدد عدد الأماكن التي يتم انتقالها.

• >> (الانتقال إلى اليمين):يأخذانرقمان، ينتقلان بجعل الأول ينتقل إلى اليمين، والثاني يحدد عدد الأماكن التي يتم انتقالها.

• ＆^ (AND NOT):عمود الت清除 (Bit Clearing) الذي يفعل عمود التحقق &(^).

package　main
import　"fmt"
func　main()　{
　　　　p := 134
　　　　q := 320
　　　　// & (AND)
　　　　result1 := p & q
　　　　fmt.Printf("نتيجة الحساب p & q = %d", result1)
　　　　// | (OR)
　　　　result2 := p | q
　　　　fmt.Printf("\nنتيجة الحساب p | q = %d", result2)
　　　　// ^ (XOR)
　　　　result3 := p ^ q
　　　　fmt.Printf("\nنتيجة الحساب p ^ q = %d", result3)
　　　　// << (الانتقال إلى اليسار)
　　　　result4 := p << 1
　　　　fmt.Printf("\nنتيجة الحساب p << 1 = %d", result4)
　　　　// >> (الانتقال إلى اليمين)
　　　　result5 := p >> 1
　　　　fmt.Printf("\nنتيجة الحساب p >> 1 = %d", result5)
　　　　// &^ (AND NOT)
　　　　result6 := p &^ q
　　　　fmt.Printf("\nنتيجة الحساب p &^ q = %d", result6)
}

الإخراج:

نتيجة الحساب p & q = 0
نتيجة الحساب p | q = 454
نتيجة الحساب p ^ q = 454
نتيجة الحساب p << 1 = 268
نتيجة الحساب p >> 1 = 67
نتيجة الحساب p &^ q = 134

عمود التساوي

يستخدم عمود التساوي لتخصيص القيم للمتغيرات. العمود الأيسر من عمود التساوي هو متغير، بينما العمود الأيمن هو قيمة. يجب أن يكون القيمة على الجانب الأيمن متطابقة في نوع البيانات مع المتغير على الجانب الأيسر، وإلا سيقوم المترجم بإلقاء خطأ. العمود الأيمن من عمود التساوي المختلفة كما يلي:

• “ =” (التساوي البسيط):هذا هو عمود التساوي الأبسط. يتم استخدامه لتحديد القيمة على الجانب الأيمن إلى المتغير على الجانب الأيسر.

• “ + =”（الإضافة):هذا العنصر هو مزيج من علامتي '+' و '='. يضيف هذا العنصر أولاً القيمة اليمنى إلى قيمة المتغير الأيسر، ثم يوزع النتيجة على المتغير الأيسر.

• “ -=”（الطرح):هذا العنصر هو مزيج من علامتي '-' و '='. يطرح هذا العنصر أولاً القيمة اليمنى من قيمة المتغير الأيسر، ثم يوزع النتيجة على المتغير الأيسر.

• “ * =”（الضرب):هذا العنصر هو مزيج من علامتي '*' و '='. يضرب هذا العنصر أولاً قيمة المتغير الأيسر بالقيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

• “ / =”（القسمة):هذا العنصر هو مزيج من علامتي '/' و '='. يقسم هذا العنصر أولاً قيمة المتغير الأيسر بالقيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

• “％=” (القسمة الباقية):هذا العنصر هو مزيج من علامتي “%” و “ =”. يضرب هذا العنصر أولاً قيمة المتغير الأيسر مع القيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

• “＆=” (الإشارة إلى الأجزاء المشتركة):هذا العنصر هو مزيج من علامتي '＆' و '='. يضيف هذا العنصر أولاً قيمة المتغير الأيسر مع القيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

• “ ^ =”（الإشارة إلى الأجزاء المختلفة):هذا العنصر هو مزيج من علامتي '^' و '='. يضيف هذا العنصر أولاً قيمة المتغير الأيسر مع القيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

• “ | =”（الإشارة إلى الأجزاء المشتركة):هذا العنصر هو مزيج من علامتي | و '='. يضيف هذا العنصر أولاً قيمة المتغير الأيسر مع القيمة اليمنى، ثم يوزع النتيجة على المتغير الأيسر.

package　main　
　　　　
import　"fmt"
　　　　
func　main()　{　
　　　var　p　int　=　38
　　　　var　q　int　=　70
　　　　　　　
　　　//　“=”(الإسناد البسيط)　
　　　p　=　q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“+=”(الإضافة)　
　　　　p　+=　q　
　　　fmt.Println(p)　
　　　　　　　
　　　//“-=”(الطرح)　
　　　p-=q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“*=”(الضرب)　
　　　p*=　q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　“/=”(القسمة)　
　　　　p　/=　q　
　　　fmt.Println(p)　
　　　　　　
　　　　//　“%=”(القسمة الباقية)　
　　　　p　%=　q　
　　　fmt.Println(p)　
　　　　　　
}

الإخراج:

70
140
70
4900
70
0

عمليات متنوعة

• ＆：يقدم هذا العنصر عنوان المتغير.

• *：يقدم هذا العنصر إشارة إلى المتغير.

• <-：اسم هذا المفهوم هو Receive. يستخدم لاستقبال القيم من قناة.

package　main　
　　　　
import　"fmt"
　　　　
func　main()　{　
　　a　:=　94
　　　　　
//使用运算符（＆）和
//指针间接（*）运算符
　　b　:=　&a　　
　　fmt.Println(*b)　　
　　*b　=　67　
　　fmt.Println(a)　　
}

الإخراج:

94
67