كيفية استخدام المشغلات في Golang

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

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

تُستخدم هذه المشغلات لإجراء عمليات على المتغيرات في لغة Go:

• الإضافة: '+' تضيف اثنين من المتغيرات. على سبيل المثال: x+y.
• الطرح: '-' يطرح اثنين من المتغيرات. مثال:xy.
• الضرب: '*' يضرب اثنين من المتغيرات. على سبيل المثال: x*y.
• القسمة: '/' يقسم المتغير الأول على المتغير الثاني. على سبيل المثال: x/y.
• الباقي: يقوم عامل '%' بإرجاع الباقي عندما يتم قسمة المتغير الأول على المتغير الثاني. على سبيل المثال: x%y.

 ملاحظة: -، +، !، &، *، <- و^ تسمى أيضًا مشغلات أحادية وأولوية المشغلات الأحادية أعلى. تأتي مشغلات ++ و — من العبارات، وليست تعبيرات، لذا فهي تقع خارج التسلسل الهرمي للمشغلات.

على سبيل المثال:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

نتيجة:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

المشغلات العلائقية

يتم استخدام مشغلي العلاقات لمقارنة قيمتين. دعونا نلقي نظرة على كل مشغل واحدا تلو الآخر:

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

على سبيل المثال:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

نتيجة:

false
true
false
true
true
false

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

يتم استخدامها لدمج شرطين أو أكثر أو لتكملة تقييم الشرط الأولي قيد النظر.

• AND: يعيد عامل التشغيل '&&' القيمة true عندما يتم استيفاء كلا الشرطين قيد النظر. وإلا فإنه يعود خطأ. على سبيل المثال، ترجع a && b القيمة true عندما يكون كل من a وb صحيحين (أي غير صفر).
• أو: المشغل '||' يعود صحيحًا عندما يتم استيفاء أحد الشروط (أو كليهما) قيد النظر. وإلا فإنه يعود خطأ. على سبيل المثال: أ || يعود b صحيحًا إذا كان a أو b صحيحًا (أي غير صفر). بالطبع، يعود الأمر صحيحًا عندما يكون كل من a وb صحيحين.
• منطقي NOT: '!' المشغل يعود صحيحًا عندما لا يتم استيفاء الشرط قيد النظر. وإلا فإنه يعود خطأ. على سبيل المثال: !a ترجع true إذا كانت a خاطئة، أي عندما a = 0.

على سبيل المثال:

// Minh họa chương trình Go dùng toán tử logic
package main 
import "fmt"
func main() { 
	var p int = 23
	var q int = 60
		
	if(p!=q && p<=q){ fmt.println("true")="" }="" if(p!="q" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

نتيجة:

True
True
True

مشغلات البت

في لغة Go، هناك 6 مشغلات بتية تعمل على مستوى البت أو تُستخدم لإجراء عمليات بت ببت. وفيما يلي مشغلي البتات:

• & (AND بتيًا): يأخذ رقمين كمتعاملين وينفذ AND على كل بت من الرقمين. تكون نتيجة AND 1 فقط إذا كان كلا البتاتين 1.
• | (أو بتيًا): يأخذ رقمين كمتعاملين وينفذ أو على كل بت من الرقمين. نتيجة OR هي 1 إذا كان أي من البتاتين يساوي 1.
• ^ (XOR بتّي): يأخذ رقمين كمتعاملين وينفّذ XOR على كل بت من الرقمين. نتيجة XOR هي 1 إذا كانت البتتان مختلفتين.
• < (تحويل إلى اليسار): يأخذ رقمين، ويحول بتات المتغير الأول إلى اليسار، ويحدد المتغير الثاني عدد المواضع التي يجب تحويلها
• >> (تحويل إلى اليمين): خذ رقمين، وقم بتحويل بتات المتغير الأول إلى اليمين، ويحدد المتغير الثاني عدد المواضع التي يجب تحويلها.
• &^ (AND NOT): هذا عامل بتّي صريح.

على سبيل المثال:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

نتيجة:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

عامل التعيين

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

• "="(التعيين البسيط): هذا هو أبسط عامل تعيين. يتم استخدام هذا المشغل لتعيين القيمة الموجودة على اليمين للمتغير الموجود على اليسار.
• "+="(تعيين إضافي): هذا المشغل عبارة عن مزيج من المشغلين '+' و'='. يقوم هذا المشغل أولاً بإضافة القيمة الحالية للمتغير الأيسر إلى قيمة المتغير الأيمن، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "-="(تعيين ناقص): هذا المشغل عبارة عن مزيج من المشغلين '-' و'='. يقوم هذا المشغل أولاً بطرح القيمة الحالية للمتغير الأيسر من قيمة المتغير الأيمن، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "*="(تعيين الضرب): هذا المشغل عبارة عن مزيج من المشغلين '*' و'='. يقوم هذا المشغل أولاً بضرب القيمة الحالية للمتغير الأيسر بالقيمة الموجودة على اليمين، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "/="(تعيين القسمة): هذا المشغل عبارة عن مزيج من المشغلين '/' و'='. يقوم هذا المشغل أولاً بتقسيم القيمة الحالية للمتغير الأيسر على القيمة الموجودة على اليمين، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "%="(تعيين الباقي): هذا المشغل عبارة عن مزيج من المشغلين '%' و'='. يقوم هذا المشغل أولاً بأخذ باقي القيمة الحالية للمتغير الأيسر المعطى القيمة الموجودة على اليمين، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "&="(AND بتية): هذا المشغل عبارة عن مزيج من المشغلين '&' و'='. يقوم هذا المشغل أولاً بـ "ANDs bitwise" للقيمة الحالية للمتغير الأيسر إلى القيمة الموجودة على اليمين، ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "^="(أو حصريًا على مستوى البت): هذا المشغل عبارة عن مزيج من المشغلين '^' و'='. يقوم هذا المشغل أولاً بـ "Bitwise Exclusive OR" القيمة الحالية للمتغير الأيسر بقيمة اليمين ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "|="(أو شاملة لكل بت): هذا المشغل عبارة عن مزيج من '|' المشغلين و '='. يقوم هذا المشغل أولاً بـ "Bitwise Inclusive OR" القيمة الحالية للمتغير الأيسر بقيمة اليمين ثم يقوم بتعيين النتيجة للمتغير الأيسر.
• "<=: هذا المشغل عبارة عن مزيج من مشغلي < ' و '="'." يقوم هذا المشغل أولاً "بتحويل" القيمة الحالية للمتغير على اليسار بالقيمة الموجودة على اليمين ثم يقوم بتعيين النتيجة للمتغير على اليمين.
• ">>=": هذا المشغل عبارة عن مزيج من المشغلين '>>' و '='. يقوم هذا المشغل أولاً بـ "Right Shift AND" القيمة الحالية للمتغير الأيسر بالقيمة الموجودة على اليمين، ثم يقوم بتعيين النتيجة للمتغير الأيسر.

على سبيل المثال:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

نتيجة:

50
100
50
2500
50
0

مشغلين آخرين

• &: يقوم هذا المشغل بإرجاع عنوان المتغير.
• *: يوفر هذا المشغل مؤشرًا إلى متغير.
• <-: اسم هذا المشغل هو الاستقبال. يتم استخدامه لاستقبال قيمة من

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

نتيجة:

4
7