الذهاب مشغلي اللغة
تستخدم المشغلين لإجراء عمليات حسابية أو منطقية في التطبيق قيد التشغيل.
يتم بناؤها الذهاب المشغلين في اللغة:
- العوامل الحسابية
- مشغلي العلائقية
- مشغلي منطقية
- أحادي المعامل مشغلي
- عوامل التعيين
- المشغلين الآخرين
دعونا ننظر في كل التفاصيل مشغلي قدم.
العوامل الحسابية
يسرد الجدول التالي كل اللغات الذهاب العوامل الحسابية. نفترض أن (أ) هو 10، B هو 20.
مشغلي | وصف | أمثلة |
---|---|---|
+ | مضيفا | وخرج + B 30 |
- | طرح | أ - الناتج ب -10 |
* | مضاعف | A * B 200 الانتاج |
/ | منقسم | B / مخرج 2 |
٪ | بقية | B٪ والانتاج 0 |
++ | زيادة | وخرج ++ 11 |
- | إنقاص | الناتج A-- 9 |
يوضح المثال التالي استخدام مختلف العوامل الحسابية:
package main import "fmt" func main() { var a int = 21 var b int = 10 var c int c = a + b fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a - b fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a * b fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a / b fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a % b fmt.Printf("第五行 - c 的值为 %d\n", c ) a++ fmt.Printf("第六行 - c 的值为 %d\n", a ) a-- fmt.Printf("第七行 - c 的值为 %d\n", a ) }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - c 的值为 22 第七行 - c 的值为 21
مشغلي العلائقية
يسرد الجدول التالي كل من العوامل العلائقية لغة العودة. نفترض أن (أ) هو 10، B هو 20.
مشغلي | وصف | أمثلة |
---|---|---|
== | تحقق من القيم هما على قدم المساواة، والعودة على قدم المساواة الحقيقية إذا خطأ غير ذلك. | (A == B) هو False |
! = | تحقق ما إذا كانت القيمتين ليست متساوية، ولا يعود متساوية صحيح إذا خطأ غير ذلك. | (A! = B) هو صحيح |
> | تحقق من قيمة الأيسر هو أكبر من القيمة من الجانب الأيمن، والعودة الحقيقية كاذبة خلاف ذلك. | (A> B) هو False |
< | تحقق من قيمة غادر أقل من القيمة من الجانب الأيمن، والعودة الحقيقية كاذبة خلاف ذلك. | (A <B) غير صحيح |
> = | تحقق ما إذا كانت القيمة أكبر من أو يساوي إلى اليسار إلى القيمة الصحيحة، فإنها ترجع صحيح إذا كان غير صحيح على خلاف ذلك. | (A> = B) هو False |
<= | تحقق ما إذا كانت القيمة أقل من أو يساوي إلى اليسار إلى القيمة الصحيحة، فإنها ترجع صحيح إذا كان غير صحيح على خلاف ذلك. | (A <= B) غير صحيح |
يوضح المثال التالي استخدام العلائقية:
package main import "fmt" func main() { var a int = 21 var b int = 10 if( a == b ) { fmt.Printf("第一行 - a 等于 b\n" ) } else { fmt.Printf("第一行 - a 不等于 b\n" ) } if ( a < b ) { fmt.Printf("第二行 - a 小于 b\n" ) } else { fmt.Printf("第二行 - a 不小于 b\n" ) } if ( a > b ) { fmt.Printf("第三行 - a 大于 b\n" ) } else { fmt.Printf("第三行 - a 不大于 b\n" ) } /* Lets change value of a and b */ a = 5 b = 20 if ( a <= b ) { fmt.Printf("第四行 - a 小于等于 b\n" ) } if ( b >= a ) { fmt.Printf("第五行 - b 大于等于 b\n" ) } }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 b
مشغلي منطقية
يسرد الجدول التالي كل اللغات الذهاب العوامل المنطقية. نفترض أن A غير صحيح، B هو زائف.
مشغلي | وصف | أمثلة |
---|---|---|
&& | منطقية والمشغل. إذا كان كلا الجانبين من المعاملات هي صحيح، والشرط هو صحيح، كاذبة خلاف ذلك. | (A && B) هو False |
|| | المنطقي أو المشغل. إذا كانت المعاملات على كلا الجانبين هناك صحيح، والشرط هو صحيح، كاذبة خلاف ذلك. | (A || B) هو صحيح |
! | منطقيا لا المشغل. إذا كان الشرط هو صحيح، ثم المنطقية ليس شرطا الكاذبة، وإلا صحيح. | ! (A && B) غير صحيح |
يوضح المثال التالي استخدام العوامل المنطقية:
package main import "fmt" func main() { var a bool = true var b bool = false if ( a && b ) { fmt.Printf("第一行 - 条件为 true\n" ) } if ( a || b ) { fmt.Printf("第二行 - 条件为 true\n" ) } /* 修改 a 和 b 的值 */ a = false b = true if ( a && b ) { fmt.Printf("第三行 - 条件为 true\n" ) } else { fmt.Printf("第三行 - 条件为 false\n" ) } if ( !(a && b) ) { fmt.Printf("第四行 - 条件为 true\n" ) } }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
أحادي المعامل مشغلي
مشغلي المختصة بالبت على الأعداد الصحيحة في بت الذاكرة تعمل.
يسرد الجدول التالي مشغلي المختصة بالبت و، |، ويتم احتساب ^:
ص | ف | ص و ف | ص | ف | ص ^ ف |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
نفترض أن A = 60، B = 13؛ الرقم الثنائي ل:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
الحوسبة بت دعم اللغة C رمز هو موضح في الجدول التالي. نفترض أن (أ) هو 60، B هو 13:
مشغلي | وصف | أمثلة |
---|---|---|
و | أحادي المعامل ومشغل "و" هو مشغلي الثنائية. وظيفتها هي اثنين من الأرقام الثنائية المقابلة لكل مرحلة من مراحل العملية والمشاركة. | (أ و ب) النتيجة هي 12، ثنائي هو 0000 1100 |
| | أحادي المعامل أو المشغل "|" هو تشغيل ثنائي. وتتمثل مهمتها في المشاركة في العملية من رقمين كل مرحلة الثنائية المقابلة أو | (A | B) والنتيجة هي 61، ثنائي هو 00111101 |
^ | أحادي المعامل OR خاص المشغل "^" هو مشغلي الثنائية. وتتمثل مهمتها في المشاركة في العملية من رقمين المقابلة كل XOR ثنائي عندما يختلف اثنان بت ثنائي المقابلة والنتيجة هي 1. | (A ^ B) نتيجة ل49 ثنائيات على 00110001 |
<< | ترك المشغل التحول "<<" هو مشغلي الثنائية. يتم ضرب التحول الأيسر N-بت 2 ^ ن. وظيفتها على كل ثنائي "<<" تبقى من المعامل الأيسر من كل عدد البتات المحدد من قبل عدد "<<" حق التحركات العشرية، التخلص من 0S العالية والمنخفضة. | و<< 2 نتائج ل 240 ثنائي هو 11110000 |
>> | مشغل التحول الصحيح ">>" هي مشغلي الثنائية. ينقسم الحق ن بت 2 ^ ن. وتتمثل مهمتها في مختلف ثنائي ">>" المعامل الأيسر عدة كل الحق، ">>" على حق عدد البتات المحدد. | و>> 2 النتائج 15 0000 1111 نظام ثنائي |
يوضح المثال التالي استخدام العوامل المنطقية:
package main import "fmt" func main() { var a uint = 60 /* 60 = 0011 1100 */ var b uint = 13 /* 13 = 0000 1101 */ var c uint = 0 c = a & b /* 12 = 0000 1100 */ fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a | b /* 61 = 0011 1101 */ fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a ^ b /* 49 = 0011 0001 */ fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a << 2 /* 240 = 1111 0000 */ fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a >> 2 /* 15 = 0000 1111 */ fmt.Printf("第五行 - c 的值为 %d\n", c ) }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
عوامل التعيين
يسرد الجدول التالي كل من العودة عامل التعيين اللغة.
مشغلي | وصف | أمثلة |
---|---|---|
= | عامل التعيين البسيط يعين تعبير قيمة من lvalue | C = A + B A + B سيتم تعيين إلى نتيجة C التعبير |
+ = | وأضاف معا قبل التعيين | C + = A يساوي C = C + A |
- = | بعد احالة الطرح | ج - = A يساوي C = C - A |
* = | ثم ضرب الاحالة | C * = A يساوي C = C * A |
/ = | تقسيم بعد التعيين | C / = A يساوي C = C / A |
٪ = | الباقي بعد التعيين | C = A٪ تساوي C = C٪ ل |
<< = | غادر بعد التعيين | C << = 2 يساوي C = C << 2 |
>> = | مباشرة بعد التعيين | C >> = 2 يساوي C = C >> 2 |
& = | أحادي المعامل والاحالة بعد | C & = 2 يساوي C = C & 2 |
^ = | بعد الضغط على XOR التنازل بعض الشيء | C ^ 2 = يساوي C = C ^ 2 |
| = | بعد الضغط على موقف أو التنازل | C | = 2 تساوي C = C | 2 |
يوضح المثال التالي استخدام عامل التعيين:
package main import "fmt" func main() { var a int = 21 var c int c = a fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c ) c += a fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c ) c -= a fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c ) c *= a fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c ) c /= a fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c ) c = 200; c <<= 2 fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c ) c >>= 2 fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c ) c &= 2 fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c ) c ^= 2 fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c ) c |= 2 fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c ) }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第 1 行 - = 运算符实例,c 值为 = 21 第 2 行 - += 运算符实例,c 值为 = 42 第 3 行 - -= 运算符实例,c 值为 = 21 第 4 行 - *= 运算符实例,c 值为 = 441 第 5 行 - /= 运算符实例,c 值为 = 21 第 6行 - <<= 运算符实例,c 值为 = 800 第 7 行 - >>= 运算符实例,c 值为 = 200 第 8 行 - &= 运算符实例,c 值为 = 0 第 9 行 - ^= 运算符实例,c 值为 = 2 第 10 行 - |= 运算符实例,c 值为 = 2
المشغلين الآخرين
يسرد الجدول التالي المشغلين الآخرين الذهاب اللغة.
مشغلي | وصف | أمثلة |
---|---|---|
و | العودة عنوان الذاكرة متغير | وA؛ سيعطي عنوان حقيقي للمتغير. |
* | مؤشر متغير. | * A؛ هو متغير مؤشر |
يوضح المثال التالي استخدام المشغلين الآخرين:
package main import "fmt" func main() { var a int = 4 var b int32 var c float32 var ptr *int /* 运算符实例 */ fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); /* & 和 * 运算符实例 */ ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为 %d\n", a); fmt.Printf("*ptr 为 %d\n", *ptr); }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
أسبقية المشغل
بعض المشغلين لديها أولوية أعلى، ومشغلي الثنائية هي الاتجاه العملي من اليسار إلى اليمين. يسرد الجدول التالي كافة المشغلين وأولوياتها، وممثلين من أعلى إلى أسفل في الأولوية الهابطة:
أفضلية | مشغلي |
---|---|
7 | ^! |
6 | * /٪ ^ & << >> و |
5 | + - | ^ |
4 | ==! = << => => |
3 | <- |
2 | && |
1 | || |
بالطبع، يمكنك استخدام الأقواس لتحسين الأولوية العامة للتشغيل تعبير مؤقتا.
أمثلة على النتائج التشغيلية المذكورة أعلاه:
package main import "fmt" func main() { var a int = 20 var b int = 10 var c int = 15 var d int = 5 var e int; e = (a + b) * c / d; // ( 30 * 15 ) / 5 fmt.Printf("(a + b) * c / d 的值为 : %d\n", e ); e = ((a + b) * c) / d; // (30 * 15 ) / 5 fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e ); e = (a + b) * (c / d); // (30) * (15/5) fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e ); e = a + (b * c) / d; // 20 + (150/5) fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e ); }
أمثلة على النتائج التشغيلية المذكورة أعلاه:
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50