X + = y වැනි කෙටිමං හොඳ පුරුද්දක් ලෙස සලකන්නේ ඇයි?

මේවා ඇත්ත වශයෙන්ම හඳුන්වන්නේ කුමක් දැයි මා දන්නේ නැත, නමුත් මම ඒවා නිතරම දකිමි. පයිතන් ක්‍රියාත්මක කිරීම වැනි දෙයක්:

x += 5සඳහා කෙටිමං අංකනයක් ලෙස x = x + 5.

නමුත් මෙය හොඳ පුරුද්දක් ලෙස සලකන්නේ ඇයි? පයිතන්, සී, ආර් සඳහා මම කියවා ඇති සෑම පොතක හෝ ක්‍රමලේඛන නිබන්ධනයකම පාහේ මම එය හරහා දිව ගියෙමි . අවකාශය ඇතුළුව යතුරු එබීම් තුනක් ඉතිරි කරමින් එය පහසු බව මට වැටහේ. නමුත් මම සෑම විටම කේත කියවන විට ඔවුන් මාව ඉහළට ඔසවා තබන බවක් පෙනේ, අවම වශයෙන් මගේ මතකයට අනුව, එය කියවිය නොහැකි ලෙස අඩු කරන්න , වැඩි නොවේ.

මේවා සෑම තැනකම භාවිතා වන පැහැදිලි සහ පැහැදිලි හේතුවක් මට මග හැරී තිබේද?

එය කෙටිකාලීන නොවේ.

මෙම +=සංකේතය 1970 ගණන්වල සී භාෂාවෙන් දර්ශනය වූ අතර - “ස්මාර්ට් එකලස් කිරීමේ” සී අදහස සමඟ පැහැදිලිවම වෙනස් යන්ත්‍ර උපදෙස් හා ඇඩ්‍රස් ක්‍රමයට අනුරූප වේ:

" i=i+1", "i+=1"සහ" ++i" වැනි දේවල් වියුක්ත මට්ටමින් එකම බලපෑමක් ඇති කළද, ප්‍රොසෙසරයේ වැඩ කිරීමේ වෙනත් ක්‍රමයකට අඩු මට්ටමින් අනුරූප වේ.

විශේෂයෙන් එම ප්‍රකාශන තුන, iවිචල්‍යය CPU ලේඛනයක ගබඩා කර ඇති මතක ලිපිනයෙහි ඇතැයි උපකල්පනය කරමු (අපි එය නම් කරමු D- එය "int වෙත දර්ශකයක්" ලෙස සිතමු) සහ ප්‍රොසෙසරයේ ALU පරාමිතියක් ගෙන එහි ප්‍රති result ලයක් ලබා දෙයි "සමුච්චය" (අපි එය A ලෙස හඳුන්වමු - එය int ලෙස සිතමු).

මෙම අවහිරතා සමඟ (එම කාල පරිච්ඡේදයේ සිට සියලුම මයික්‍රොප්‍රොසෙසර වල ඉතා සුලභ වේ), පරිවර්තනය බොහෝ විට සිදුවනු ඇත

;i = i+1;
MOV A,(D); //Move in A the content of the memory whose address is in D
ADD A, 1;  //The addition of an inlined constant
MOV (D) A; //Move the result back to i (this is the '=' of the expression)

;i+=1;
ADD (D),1; //Add an inlined constant to a memory address stored value

;++i;
INC (D); //Just "tick" a memory located counter

එය කළ හැකි පළමු ක්‍රමය අශෝභන ය, නමුත් නියත ( ADD A, Bහෝ ADD A, (D+x)) වෙනුවට විචල්‍යයන් සමඟ ක්‍රියා කරන විට හෝ වඩාත් සංකීර්ණ ප්‍රකාශන පරිවර්තනය කිරීමේදී එය වඩාත් සාමාන්‍ය වේ (ඒවා සියල්ලම තොගයක් තුළ අඩු ප්‍රමුඛතා ක්‍රියාකාරිත්වයේ තම්බා, ඉහළ ප්‍රමුඛතාවය අමතන්න, පොප් සියලු තර්ක ඉවත් කරන තුරු නැවත නැවත කරන්න).

දෙවැන්න "රාජ්‍ය යන්ත්‍රය" ට වඩා සාමාන්‍ය ය: අපි තවදුරටත් "ප්‍රකාශනයක් ඇගයීමට ලක් නොකරමු", නමුත් "අගයක් ක්‍රියාත්මක කිරීම": අපි තවමත් ALU භාවිතා කරමු, නමුත් පරාමිතිය ප්‍රතිස්ථාපනය කිරීමට ඉඩ දී ඇති ප්‍රති around ලය වීම වටා අගයන් චලනය කිරීමෙන් වළකින්න. වඩාත් සංකීර්ණ ප්‍රකාශනයක් අවශ්‍ය වන විට මෙවැනි උපදෙස් භාවිතා i = 3*i + i-2කළ නොහැක : iවැඩි වාර ගණනක් අවශ්‍ය බැවින් ක්‍රියාත්මක කළ නොහැක .

තෙවන-වඩාත් සරල- “එකතු කිරීම” පිළිබඳ අදහස පවා නොසලකයි, නමුත් කවුන්ටරයක් ​​සඳහා වඩාත් “ප්‍රාථමික” (පරිගණකමය අර්ථයෙන්) පරිපථයක් භාවිතා කරයි. රෙජිස්ටරයක් ​​කවුන්ටරයක් ​​බවට පත් කිරීම සඳහා නැවත සකස් කිරීම සඳහා අවශ්‍ය වන ඒකාබද්ධ ජාලය කුඩා වන අතර එම නිසා පූර්ණ එකතු කරන්නකුට වඩා වේගවත් බැවින් උපදෙස් කෙටි වේ, වේගයෙන් පටවා වහාම ක්‍රියාත්මක වේ.

සමකාලීන සම්පාදකයින් සමඟ (මේ වන විට සී වෙත යොමු වන්න), සම්පාදක ප්‍රශස්තිකරණය සක්‍රීය කරමින්, පහසුව මත පදනම්ව ලිපි හුවමාරු කර ගත හැකි නමුත් අර්ථකථනයේ සංකල්පීය වෙනසක් තවමත් පවතී.

x += 5 මාධ්‍යයන්

• X විසින් හඳුනාගත් ස්ථානය සොයා ගන්න
• එයට 5 ක් එකතු කරන්න

නමුත් x = x + 5අදහස් කරන්නේ:

• X + 5 තක්සේරු කරන්න
  • X විසින් හඳුනාගත් ස්ථානය සොයා ගන්න
  • X සමුච්චය තුළට පිටපත් කරන්න
  • සමුච්චය වෙත 5 ක් එකතු කරන්න
• ප්‍රති result ලය x හි ගබඩා කරන්න
  • X විසින් හඳුනාගත් ස්ථානය සොයා ගන්න
  • සමුච්චය එයට පිටපත් කරන්න

ඇත්ත වශයෙන්ම, ප්‍රශස්තිකරණය කළ හැකිය

• "x සොයා ගැනීම" කිසිදු අතුරු ආබාධයක් නොමැති නම්, "සොයා ගැනීම" දෙක එක් වරක් කළ හැකිය (සහ x දර්ශක ලේඛනයේ ගබඩා කර ඇති ලිපිනයක් බවට පත්වේ)
• එකතු කිරීම සඳහා අයදුම් කරන්නේ නම් පිටපත් දෙකක් elided කළ හැකි &xද accumulator වෙනුවට

එමඟින් ප්‍රශස්තකරණය කළ කේතය එක හා සමපාත x += 5වේ.

නමුත් මෙය කළ හැක්කේ "x සොයා ගැනීම" අතුරු ආබාධ නොමැති නම් පමණි

*(x()) = *(x()) + 5;

හා

*(x()) += 5;

x()අතුරු ආබාධ (පිළිගැනීම x()යනු අමුතු දේවල් කිරීම සහ නැවත පැමිණීම int*) දෙවරක් හෝ එක් වරක් නිපදවන බැවින් අර්ථ නිරූපණයෙන් වෙනස් වේ.

අතර ඇති සමානතාවය x = x + yහා x += yඒ නිසා සෘජු l- අගයකට අදාළ වන +=හා =අදාළ වන විශේෂිත අවස්ථාව නිසාය .

පයිතන් වෙත යාමට, එය සී වෙතින් වාක්‍ය ඛණ්ඩය උරුම කර ගත් නමුත්, පරිවර්ථනය කරන ලද භාෂාවලින් ක්‍රියාත්මක කිරීමට පෙර පරිවර්තනයක් / ප්‍රශස්තිකරණයක් නොමැති හෙයින්, දේවල් එතරම් සමීපව සම්බන්ධ නොවේ (අඩු විග්‍රහ කිරීමේ පියවරක් ඇති බැවින්). කෙසේ වෙතත්, පරිවර්තකයෙකුට ප්‍රකාශන වර්ග තුන සඳහා විවිධ ක්‍රියාත්මක කිරීමේ ක්‍රියාකාරකම් වෙත යොමු විය හැකි අතර, ප්‍රකාශනය සෑදූ ආකාරය සහ ඇගයීමේ සන්දර්භය මත පදනම්ව විවිධ යන්ත්‍ර කේතවල වාසිය ලබා ගනී.

වැඩි විස්තර වලට කැමති කවුද ...

සෑම CPU එකකටම ALU (අංක ගණිත-තාර්කික ඒකකය) ඇත, එනම් එහි සාරය අනුව, උපදෙස් වල දෘෂ්ටි කෝණය මත පදනම්ව රෙජිස්ටර් සහ / හෝ මතකයට ආදාන සහ ප්‍රතිදානය "ප්ලග්" කර ඇති ඒකාබද්ධ ජාලයකි.

ද්විමය මෙහෙයුම් සාමාන්‍යයෙන් ක්‍රියාත්මක කරනු ලබන්නේ “කොහේ හරි” ආදානයක් සහිත සමුච්චකාරක ලේඛනයේ විකරණකාරකයක් ලෙසය, එහිදී කොතැනක හෝ විය හැකිය - උපදෙස් ප්‍රවාහය තුළම (ප්‍රකාශිත අන්තර්ගතයට සාමාන්‍යය: ADD A 5) - වෙනත් ලේඛනයක් තුළ (ප්‍රකාශන ගණනය කිරීම සඳහා සාමාන්‍ය තාවකාලික: උදා: ADD AB) - මතකය තුළ, ලේඛනයක් විසින් දෙන ලද ලිපිනයක (දත්ත ලබා ගැනීමේ සාමාන්‍යය: උදා: ADD A (H)) - H, මේ අවස්ථාවේ දී, විරූපණය වන දර්ශකයක් මෙන් ක්‍රියා කරයි.

මෙම ව්‍යාජ කේතය සමඟ, x += 5වේ

ADD (X) 5

අතර x = x+5කියන්නේ

MOVE A (X)
ADD A 5
MOVE (X) A

එනම්, x + 5 තාවකාලිකව ලබා දෙන අතර එය පසුව පවරා ඇත. x += 5x මත කෙලින්ම ක්‍රියාත්මක වේ.

සත්‍ය ක්‍රියාත්මක කිරීම ප්‍රොසෙසරයේ නියම උපදෙස් මාලාව මත රඳා පවතී: ADD (.) cඔප් කේතයක් නොමැති නම් , පළමු කේතය දෙවැන්න බවට පත්වේ: නැත.

එවැනි ඔප් කේතයක් තිබේ නම් සහ ප්‍රශස්තිකරණය සක්‍රීය කර තිබේ නම්, දෙවන ප්‍රකාශනය, ප්‍රතිලෝම චලනයන් ඉවත් කර රෙජිස්ටර් ඔප්කෝඩ් සකස් කිරීමෙන් පසුව පළමු වැන්න බවට පත්වේ.

ඔබ ඒ ගැන සිතන ආකාරය මත පදනම්ව, එය වඩාත් සරල බැවින් එය තේරුම් ගැනීම පහසුය. උදාහරණයක් ලෙස ගන්න:

x = x + 5 "x ගන්න, එයට පහක් එකතු කරන්න, ඉන්පසු එම නව අගය x වෙත නැවත පවරන්න" යන මානසික සැකසුම ක්‍රියාත්මක කරයි.

x += 5 "x 5 කින් වැඩි කරන්න" ලෙස සිතිය හැකිය

ඉතින්, එය කෙටියෙන් පමණක් නොවේ, එය සැබවින්ම ක්‍රියාකාරීත්වය වඩාත් සෘජුවම විස්තර කරයි. කේත ගොබ්ස් හරහා කියවන විට, ග්‍රහණය කර ගැනීම වඩා පහසුය.

අවම වශයෙන් පයිතන්හි , x += yසහ x = x + yසම්පූර්ණයෙන්ම වෙනස් දේවල් කළ හැකිය.

උදාහරණයක් ලෙස, අප එසේ කරන්නේ නම්

a = []
b = a

පසුව a += [3]හේතු වනු ඇත a == b == [3]අතර, a = a + [3]හේතු වනු ඇත a == [3]හා b == []. එනම්, +=වස්තුව තැනින් තැන වෙනස් කිරීම (හොඳයි, එය එසේ විය හැකිය, __iadd__ඔබ කැමති ඕනෑම දෙයක් කිරීමට ක්‍රමවේදය නිර්වචනය කළ හැකිය ), =නව වස්තුවක් නිර්මාණය කර විචල්‍යය එයට බැඳ තබයි.

NumPy සමඟ සංඛ්‍යාත්මක වැඩ කරන විට මෙය ඉතා වැදගත් වේ , ඔබ නිරන්තරයෙන් අරාවෙහි විවිධ කොටස් වෙත විවිධ යොමු කිරීම් සමඟ අවසන් වන අතර, වෙනත් යොමු කිරීම් ඇති අරාවෙහි කොටසක් ඔබ නොදැනුවත්ව වෙනස් නොකරන බවට වග බලා ගැනීම වැදගත්ය. හෝ අනවශ්‍ය ලෙස අරා පිටපත් කරන්න (ඒවා ඉතා මිල අධික විය හැකිය).

එය මෝඩකමක් ලෙස හැඳින්වේ . ක්‍රමලේඛන මෝඩයන් ප්‍රයෝජනවත් වන්නේ ඒවා විශේෂිත ක්‍රමලේඛන ව්‍යුහයක් ලිවීමේ ස්ථාවර ක්‍රමයක් වන බැවිනි.

කවුරුහරි ලියන සෑම විටම එය වැඩි කරන්නේ වඩා සංකීර්ණ ක්‍රියාකාරිත්වයක් නොවන x += yබව ඔබ දන්නවා (හොඳම භාවිතයක් ලෙස, සාමාන්‍යයෙන් මම වඩාත් සංකීර්ණ මෙහෙයුම් සහ මෙම සින්ටැක්ස් කෙටිමං මිශ්‍ර නොකරමි). 1 කින් වැඩි කිරීමේදී මෙය වඩාත් අර්ථවත් කරයි.xy

@ පබ්බිගේ කාරණය ටිකක් පැහැදිලිව කිවහොත් සලකා බලන්න someObj.foo.bar.func(x, y, z).baz += 5

+=ක්රියාකරු නොමැතිව , යාමට ක්රම දෙකක් තිබේ:

1. someObj.foo.bar.func(x, y, z).baz = someObj.foo.bar.func(x, y, z).baz + 5. මෙය අතිරික්ත හා දිගු පමණක් නොව එය මන්දගාමී වේ. එබැවින් යමෙකුට එසේ කිරීමට සිදුවේ
2. තාවකාලික විචල්යයක් භාවිතා කරන්න : tmp := someObj.foo.bar.func(x, y, z); tmp.baz = tmp.bar + 5. මෙය හරි, නමුත් සරල දෙයක් සඳහා එය විශාල ශබ්දයක්. මෙය සැබවින්ම ධාවන වේලාවේදී සිදුවන දෙයට සමීප වේ, නමුත් එය ලිවීම වෙහෙසකර වන අතර එය භාවිතා +=කිරීමෙන් කාර්යය සම්පාදකයා / පරිවර්තකයා වෙත මාරු වේ.

+=එවැනි ක්‍රියාකරුවන්ගේ වාසිය සහ වෙනත් දේ ප්‍රතික්ෂේප කළ නොහැකි අතර ඔවුන් සමඟ හුරු වීම කාලය පිළිබඳ ප්‍රශ්නයක් පමණි.

එය කෙටි හා පහසු බව සත්‍යයක් වන අතර, එය බොහෝ විට යටින් පවතින එකලස් කිරීමේ භාෂාවෙන් දේවානුභාවයෙන් විය හැකි බව සත්‍යයකි, නමුත් එය හොඳම භාවිතයට හේතුව එය සමස්ත පන්තියේ දෝෂයන් වළක්වන අතර කේතය සමාලෝචනය කිරීම පහසු කරවන බවට වග බලා ගන්න එය කරන්නේ කුමක්.

සමඟ

RidiculouslyComplexName += 1;

එක් විචල්‍ය නාමයක් පමණක් සම්බන්ධ වී ඇති බැවින්, ප්‍රකාශය කරන්නේ කුමක්දැයි ඔබට විශ්වාසයි.

සමඟ RidiculouslyComplexName = RidiculosulyComplexName + 1;

දෙපාර්ශ්වයම එක හා සමාන යැයි සැමවිටම සැකයක් පවතී. ඔබ දෝෂය දුටුවාද? දායකත්වයන් සහ සුදුසුකම් ඇති විට එය වඩාත් නරක අතට හැරේ.

+ = අංකනය මුග්ධ හා කෙටි වුවද, කියවීමට පහසු වීමට මේවා හේතු නොවේ. කියවීමේ කේතයේ වැදගත්ම කොටස වන්නේ වාක්‍ය ඛණ්ඩය අර්ථයට අනුරූපණය කිරීමයි, එබැවින් වාක්‍ය ඛණ්ඩය ක්‍රමලේඛකයාගේ සිතීමේ ක්‍රියාවලියට ගැලපෙන තරමට එය කියවිය හැකි වනු ඇත (බොයිලර් ප්ලේට් කේතය නරක වීමට මෙයද හේතුවකි: එය චින්තනයේ කොටසක් නොවේ ක්‍රියාවලිය, නමුත් කේත ක්‍රියාකාරී වීමට තවමත් අවශ්‍ය වේ). මෙම අවස්ථාවේ දී, සිතුවිල්ල "වර්ධක විචල්‍යය x 5 න් 5" මිස "x x x 5 හි අගය වීමට ඉඩ නොදෙන්න".

කෙටි අංකනයක් කියවීමේ හැකියාව සඳහා නරක වන තවත් අවස්ථා තිබේ, උදාහරණයක් ලෙස ඔබ ත්‍රිමාණ ක්‍රියාකරුවෙකු භාවිතා කරන විට ifප්‍රකාශයක් වඩාත් යෝග්‍ය වේ.

මෙම ක්‍රියාකරුවන් ආරම්භ කිරීමට 'සී-ස්ටයිල්' භාෂාවල සිටින්නේ මන්ද යන්න පිළිබඳ යම් අවබෝධයක් සඳහා , මීට වසර 34 කට පෙර කේ ඇන්ඩ් ආර් 1 වන සංස්කරණයෙන් (1978) උපුටා ගැනීමක් තිබේ:

සංක්ෂිප්තභාවයට අමතරව, පැවරුම් ක්‍රියාකරුවන්ට ඔවුන් සිතන ආකාරයට වඩා හොඳින් අනුරූප වන වාසිය ඇත. අපි කියන්නේ "2 ට i එකතු කරන්න" හෝ "2 කින් වැඩි කරන්න", "මම ගන්න එපා, 2 එකතු කරන්න, ඉන්පසු ප්‍රති result ලය නැවත i තුළට දමන්න." මේ අනුව i += 2. ඊට අමතරව, වැනි සංකීර්ණ ප්රකාශනයක් සඳහා

yyval[yypv[p3+p4] + yypv[p1+p2]] += 2

පැවරුම් ක්‍රියාකරු විසින් කේතය තේරුම් ගැනීම පහසු කරයි, මන්ද දිගු ප්‍රකාශන දෙකක් සැබවින්ම එක සමාන දැයි පා er කයාට වෙහෙස මහන්සි වී පරීක්ෂා කර බැලිය යුතු නැත, නැතහොත් ඒවා එසේ නොවන්නේ මන්දැයි කල්පනා කරන්න. පැවරුම් ක්‍රියාකරු විසින් වඩාත් කාර්යක්ෂම කේතයක් නිෂ්පාදනය කිරීමට සම්පාදකයාට උදව් කළ හැකිය.

කේත කියවීමේ හැකියාව සඳහා සංයුක්ත පැවරුම් ක්‍රියාකරුවන් උදව් කළ බව බ්‍රයන් කර්නිගන් සහ ඩෙනිස් රිචී (කේ ඇන්ඩ් ආර්) විශ්වාස කළ බව මෙම ඡේදයෙන් පැහැදිලි යැයි මම සිතමි .

කේ ඇන්ඩ් ආර් එය ලියා බොහෝ කාලයක් ගත වී ඇති අතර, මිනිසුන් කේත ලිවිය යුතු ආකාරය පිළිබඳ 'හොඳම භාවිතයන්' එතැන් සිට වෙනස් වී හෝ පරිණාමය වී ඇත. නමුත් මෙම programmmers.stackexchange ප්‍රශ්නය සංයුක්ත පැවරුම් කියවීමේ හැකියාව පිළිබඳව යමෙකු පැමිණිල්ලක් කළ බව මට මතක ඇති පළමු අවස්ථාව මෙයයි, එබැවින් බොහෝ ක්‍රමලේඛකයින් ඒවා ගැටලුවක් ලෙස සලකන්නේ දැයි මම කල්පනා කරමි. නැවතත්, මම මෙය ටයිප් කරන විට ප්‍රශ්නයට උඩුකුරු 95 ක් ඇත, එබැවින් සමහර විට කේත කියවීමේදී මිනිසුන් ඒවා විහිළුවට ලක් කරයි.

කියවීමේ හැකියාව හැරුණු විට, ඔවුන් සැබවින්ම වෙනස් දේ කරයි: +=එහි වම් ක්‍රියාකාරිත්වය දෙවරක් ඇගයීමට ලක් කළ යුතු නැත.

නිදසුනක් වශයෙන්, දෙවරක් expr = expr + 5වාෂ්ප වී යයි expr( exprඅපිරිසිදු යැයි උපකල්පනය කරන්න ).

අනෙක් අය ඉතා හොඳින් විස්තර කර ඇති කුසලතා වලට අමතරව, ඔබට ඉතා දිගු නම් ඇති විට එය වඩාත් සංයුක්ත වේ.

  MyVeryVeryVeryVeryVeryLongName += 1;

හෝ

  MyVeryVeryVeryVeryVeryLongName =  MyVeryVeryVeryVeryVeryLongName + 1;

එය සංක්ෂිප්ත ය.

එය ටයිප් කිරීමට වඩා කෙටි ය. එයට අඩු ක්‍රියාකරුවන් සම්බන්ධ වේ. එය අඩු පෘෂ් area වර්ග area ලයක් සහ ව්‍යාකූලත්වයට ඇති අවස්ථාව අඩුය.

එය වඩාත් නිශ්චිත ක්‍රියාකරුවෙකු භාවිතා කරයි.

මෙය ව්‍යාකූල උදාහරණයකි, සත්‍ය සම්පාදකයින් මෙය ක්‍රියාත්මක කරන්නේ දැයි මට විශ්වාස නැත. x + = y ඇත්ත වශයෙන්ම එක් තර්කයක් සහ එක් ක්‍රියාකරුවෙකු භාවිතා කරන අතර x ස්ථානය වෙනස් කරයි. x = x + y ට x = z හි අතරමැදි නිරූපණයක් තිබිය හැකි අතර z යනු x + y වේ. දෙවැන්න ක්‍රියාකරුවන් දෙදෙනෙකු භාවිතා කරයි, එකතු කිරීම සහ පැවරීම සහ තාවකාලික විචල්‍යය. තනි ක්‍රියාකරු එය පැහැදිලිවම පැහැදිලි කරන්නේ අගය පැත්ත y හැර වෙනත් දෙයක් විය නොහැකි බවත් එය අර්ථ නිරූපණය කළ යුතු නැති බවත්ය. න්‍යායාත්මකව ප්ලස්-ක්‍රියාකරුට වඩා වේගයෙන් ධාවනය වන ප්ලස්-සමාන ක්‍රියාකරුවෙකු සහ ශ්‍රේණියේ පැවරුම් ක්‍රියාකරුවෙකු සිටින සමහර විසිතුරු CPU තිබිය හැකිය.

එය කදිම මෝඩයෙකි. එය වේගවත් ද නැද්ද යන්න භාෂාව මත රඳා පවතී. C හි එය වේගවත් වන්නේ එය දකුණු පැත්තෙන් විචල්‍යය වැඩි කිරීම සඳහා උපදෙස් වලට පරිවර්තනය කරන බැවිනි. පයිතන්, රූබි, සී, සී ++ සහ ජාවා ඇතුළු නවීන භාෂා සියල්ලම op = සින්ටැක්ස් සඳහා සහය දක්වයි. එය සංයුක්ත වන අතර ඔබ ඉක්මනින් එයට පුරුදු වේ. වෙනත් ජනතා කේත (OPC) තුළ ඔබ එය බොහෝ දුරට දකිනු ඇති බැවින්, ඔබට එය පුරුදු වී එය භාවිතා කළ හැකිය. මෙන්න තවත් භාෂා කිහිපයකින් සිදුවන දේ.

පයිතන්හි, ටයිප් කිරීම x += 5තවමත් පූර්ණ සංඛ්‍යා වස්තුව 1 නිර්මාණය කිරීමට හේතු වේ (එය තටාකයකින් ඇද ගත හැකි වුවද) සහ 5 අඩංගු පූර්ණ සංඛ්‍යා වස්තුව අනාථ කිරීම.

ජාවා හි, එය නිහ cast වාත්තු කිරීමක් ඇති කරයි. ටයිප් කිරීමට උත්සාහ කරන්න

int x = 4;
x = x + 5.2  // This causes a compiler error
x += 5.2     // This is not an error; an implicit cast is done.

+=ඔබ විචල්‍යයක් සමුච්චයක් ලෙස භාවිතා කරන විට , එනම් ක්‍රියාත්මක වන එකතුව වැනි ක්‍රියාකරුවන් ඉතා ප්‍රයෝජනවත් වේ :

x += 2;
x += 5;
x -= 3;

කියවීමට වඩා පහසුය:

x = x + 2;
x = x + 5;
x = x - 3;

පළමු අවස්ථාවේ දී, සංකල්පමය වශයෙන්, ඔබ අගය වෙනස් කරමින් සිටී x. දෙවන අවස්ථාවේදී, ඔබ නව අගයක් ගණනය කර එය xඑක් එක් කාලයට පවරයි . ඔබ කිසි විටෙකත් එතරම් සරල කේතයක් ලියන්නේ නැති අතර, අදහස එලෙසම පවතී ... අවධානය යොමු වී ඇත්තේ ඔබ නව අගයක් නිර්මාණය කරනවා වෙනුවට පවතින වටිනාකමක් සඳහා කරන දේ වෙත ය.

මෙය සලකා බලන්න

(some_object[index])->some_other_object[more] += 5

D0 ඔබට සැබවින්ම ලිවීමට අවශ්‍යයි

(some_object[index])->some_other_object[more] = (some_object[index])->some_other_object[more] + 5

අනෙක් පිළිතුරු වඩාත් පොදු අවස්ථා ඉලක්ක කරයි, නමුත් තවත් හේතුවක් තිබේ: සමහර ක්‍රමලේඛන භාෂාවල එය අධික ලෙස පැටවිය හැකිය; උදා: පරිමාණය .

කුඩා පරිමාණ පාඩම:

var j = 5 #Creates a variable
j += 4    #Compiles

val i = 5 #Creates a constant
i += 4    #Doesn’t compile

පංතියක් +ක්‍රියාකරු පමණක් අර්ථ දක්වන්නේ නම් , x+=yඇත්ත වශයෙන්ම එය කෙටිමඟකි x=x+y.

+=කෙසේ වෙතත්, පන්තියක් අධික ලෙස පැටවෙන්නේ නම්, ඒවා එසේ නොවේ:

var a = ""
a += "This works. a now points to a new String."

val b = ""
b += "This doesn’t compile, as b cannot be reassigned."

val c = StringBuffer() #implements +=
c += "This works, as StringBuffer implements “+=(c: String)”."

මීට අමතරව, ක්‍රියාකරුවන් +සහ +=වෙනම ක්‍රියාකරුවන් දෙදෙනෙකි (මේවා පමණක් නොව: + a, ++ a, a ++, a + ba + = b ද විවිධ ක්‍රියාකරුවන් වේ); ක්‍රියාකරු අධික ලෙස පැටවීම ඇති භාෂාවලින් මෙය සිත්ගන්නාසුලු අවස්ථා නිර්මාණය කරයි. ඉහත විස්තර කර ඇති ආකාරයටම - +එකතු කිරීම සිදු කිරීම සඳහා ඔබ ක්‍රියාකරුට අධික ලෙස පැටවුවහොත් , මතක +=තබා ගන්න එයද අධික ලෙස පැටවිය යුතුය.

එය එක් වරක් පමණක් කියන්න: දී x = x + 1, මම 'x' දෙවරක් කියමි.

'A = b + = 1' යනුවෙන් කිසි විටෙකත් ලියන්න එපා, නැතිනම් අපට පූස් පැටවුන් 10 ක්, මීයන් 27 ක්, බල්ලෙකු සහ මිටියක් මරා දැමීමට සිදුවේ.

කේතය නිවැරදි බව ඔප්පු කිරීම පහසු කරවන බැවින් ඔබ කිසි විටෙක විචල්‍යයක වටිනාකම වෙනස් නොකළ යුතුය - ක්‍රියාකාරී ක්‍රමලේඛනය බලන්න. කෙසේ වෙතත් ඔබ එසේ කරන්නේ නම්, එක් වරක් පමණක් නොකියා සිටීම හොඳය.