මතකය කළමනාකරණය කළ භාෂාවන් වන ජාවා, ජාවාස්ක්‍රිප්ට් සහ සී # වැනි වචන නව අළුත් වචන රඳවා තබාගත්තේ ඇයි?

මෙම newජාවා, ජාවාස්ක්රිප්ට්, සහ C # වගේ භාෂා ඉඟි පද පන්ති නව උදාහරණයක් නිර්මාණය කරයි.

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

එබැවින්, C ++ පසුබිමකින් එන විට, newජාවා, ජාවාස්ක්‍රිප්ට් සහ සී # වැනි භාෂාවල මූල පදය මට ස්වභාවික හා පැහැදිලිව පෙනෙන්නට තිබුණි. ඊට පස්සේ මම පයිතන් ඉගෙන ගන්න පටන් ගත්තා new. පයිතන්හිදී, නිදසුනක් ලෙස ඉදිකරන්නේ ඉදිකිරීම්කරු ඇමතීමෙන් ය:

f = Foo()

මුලදී, මෙය මට ටිකක් off ත් වූ බවක් පෙනෙන්නට තිබුණි, එය සිදු වන තුරු පයිතන්ට කිසිදු හේතුවක් නොමැති බව මට පෙනී ගියේය new, මන්ද සෑම දෙයක්ම වස්තුවක් බැවින් විවිධ ඉදිකිරීම් වාක්‍ය ඛණ්ඩ අතර ව්‍යාකූලත්වයක් අවශ්‍ය නොවේ.

ඒත් එක්කම මම හිතුවා - ඇත්තටම newජාවා වල තේරුම මොකක්ද? අප කිව යුත්තේ ඇයි Object o = new Object();? ඇයි නැත්තේ Object o = Object();? C ++ හි අනිවාර්යයෙන්ම අවශ්‍යතාවයක් ඇත new, මන්දයත් අප ගොඩවල් මත වෙන් කිරීම සහ තොගයේ වෙන් කිරීම අතර වෙනස හඳුනාගත යුතු බැවිනි, නමුත් ජාවාහි සියලු වස්තූන් ගොඩවල් මත ගොඩනගා ඇත, එබැවින් newමූල පදය පවා ඇත්තේ ඇයි ? එම ප්‍රශ්නයම ජාවාස්ක්‍රිප්ට් සඳහාද විමසිය හැකිය. මට එතරම් හුරු නැති C # හි, newවස්තු වර්ග සහ අගය වර්ග අතර වෙනස හඳුනා ගැනීමේදී යම් අරමුණක් තිබිය හැකි යැයි මම සිතමි , නමුත් මට විශ්වාස නැත.

කෙසේ වෙතත්, මට පෙනී යන්නේ C ++ ට පසුව පැමිණි බොහෝ භාෂාවන් සරලවම “උරුම” කර ඇති බවයි new- එය ඇත්ත වශයෙන්ම අවශ්‍ය නොවී. එය බොහෝ දුරට ගවේෂණාත්මක මූල පදයක් වැනි ය . කිසිම හේතුවක් නිසා අපට එය අවශ්‍ය නොවන බව පෙනේ, නමුත් එය එහි තිබේ.

ප්‍රශ්නය: මම මේ ගැන නිවැරදිද? එසේත් නැතිනම් newC ++ - ජාවා, ජාවාස්ක්‍රිප්ට් සහ සී # වැනි මතකයෙන් පාලනය වන භාෂාවන් විය යුතු නමුත් පයිතන් නොවීමට බලවත් හේතුවක් තිබේද?

ඔබගේ නිරීක්ෂණ නිවැරදි ය. C ++ යනු සංකීර්ණ තිරිසනෙකු වන අතර, පසුව newඅවශ්‍ය වන දේ deleteසහ ස්වයංක්‍රීයව නැවත ලබා ගත හැකි දෙයක් අතර වෙනස හඳුනා ගැනීමට යතුරු පදය භාවිතා කරන ලදි . ජාවා සහ සී # හි, ඔවුන් deleteමූලික පදය අතහැරියේ කුණු එකතු කරන්නා ඔබ වෙනුවෙන් එය බලා ගන්නා බැවිනි.

ගැටලුව වන්නේ ඔවුන් newමූලික පදය තබාගත්තේ ඇයි? භාෂාව ලියූ අය සමඟ කතා නොකර පිළිතුරු දීමට අපහසුය. මගේ හොඳම අනුමාන පහත දැක්වේ:

• එය අර්ථාන්විතව නිවැරදි විය. ඔබ C ++ ගැන හුරුපුරුදු නම් new, යතුරුපදය ගොඩේ වස්තුවක් නිර්මාණය කරන බව ඔබ දැන සිටියේය . ඉතින්, අපේක්ෂිත හැසිරීම වෙනස් කරන්නේ ඇයි?
• ක්‍රමවේදයක් ඇමතීමට වඩා ඔබ වස්තුවක් ක්ෂණිකව ස්ථාපනය කරන බවට එය අවධානය යොමු කරයි. මයික්‍රොසොෆ්ට් කේත ශෛලීය නිර්දේශ සමඟ, ක්‍රම නාම විශාල අකුරු වලින් ආරම්භ වන බැවින් ව්‍යාකූලත්වයක් ඇති විය හැකිය.

රූබි එය භාවිතා කරන විට පයිතන් සහ ජාවා / සී # අතර කොහේ හරි තිබේ new. මූලික වශයෙන් ඔබ මේ වගේ වස්තුවක් ක්ෂණිකව ක්‍රියාත්මක කරයි:

f = Foo.new()

එය යතුරු පදයක් නොවේ, එය පන්තිය සඳහා ස්ථිතික ක්‍රමයකි. එහි තේරුම නම්, ඔබට සිංගල්ටන් එකක් අවශ්‍ය නම්, new()සෑම අවස්ථාවකම එකම අවස්ථාව නැවත ලබා දීම සඳහා පෙරනිමි ක්‍රියාත්මක කිරීම අභිබවා යා හැකිය . එය අනිවාර්යයෙන්ම නිර්දේශ කර නැත, නමුත් එය කළ හැකිය.

කෙටියෙන් කිවහොත්, ඔබ හරි ය. නව පදය ජාවා සහ සී # වැනි භාෂාවලින් අතිරික්තය. 1990 දශකයේ සී ++ ස්ටෑන්ඩර්ඩ් කොමිටියේ සාමාජිකයෙකු වූ බ ru ස් එකෙල්ගේ අවබෝධය සහ පසුව ජාවා පිළිබඳ පොත් ප්‍රකාශයට පත් කිරීම: http://www.artima.com/weblogs/viewpost.jsp?thread=260578

ගොඩවල් වස්තු තොග වස්තූන්ගෙන් වෙන්කර හඳුනා ගැනීමට යම් ක්‍රමයක් තිබිය යුතුය. මෙම ගැටළුව විසඳීම සඳහා නව පදය ස්මාල්ටෝක් වෙතින් ලබා ගන්නා ලදි. තොග වස්තුවක් නිර්මාණය කිරීම සඳහා, ඔබ එය කැට් x හි මෙන් සරලව ප්‍රකාශ කරයි; හෝ, තර්ක සමඟ, කැට් x ("මිටන්");. ගොඩවල් වස්තුවක් නිර්මාණය කිරීම සඳහා, ඔබ නව කැට් මෙන් නව භාවිතා කරයි; හෝ නව කැට් ("මිටන්");. අවහිරතා සැලකිල්ලට ගත් විට මෙය අලංකාර සහ ස්ථාවර විසඳුමකි.

C ++ සියල්ල නරක ලෙස සිදු කර ඇති බවත් අධික ලෙස සංකීර්ණ බවත් තීරණය කිරීමෙන් පසු ජාවා ඇතුළු කරන්න. මෙහි ඇති උත්ප‍්‍රාසාත්මක කාරණය නම්, ජාවා විසින් තොග වෙන් කිරීම ඉවත දැමීමට තීරණය කළ හැකි වීමයි. (මම වෙනත් තැනක ආමන්ත්‍රණය කළ ප‍්‍රාථමිකයන්ගේ පරාජය නොසලකා හැරීම). සියලු වස්තූන් ගොඩවල් මත වෙන් කර ඇති බැවින්, තොග සහ ගොඩවල් වෙන් කිරීම අතර වෙනස හඳුනා ගැනීමට අවශ්‍ය නැත. ඔවුන්ට පහසුවෙන් කැට් x = කැට් () හෝ කැට් x = කැට් ("මිටන්") කියන්නට ඇත. හෝ ඊටත් වඩා හොඳ, පුනරාවර්තනය තුරන් කිරීම සඳහා ඒකාබද්ධ කරන ලද අනුමාන කිරීම් (නමුත් එය - සහ වසා දැමීම් වැනි වෙනත් අංග - "බොහෝ කාලයක්" ගතවනු ඇත, එබැවින් අපි ඒ වෙනුවට ජාවාහි සාමාන්‍ය අනුවාදය සමඟ හිර වී සිටිමු. ජාවා වෙත නව අංග එකතු කිරීමේදී ඇති වන ගැටලු නිසා එය සිදු නොවනු ඇත.

මට සිතිය හැකි හේතු දෙකක් තිබේ:

• new වස්තුවක් සහ ප්‍රාථමිකයක් අතර වෙනස හඳුනා ගනී
• මෙම newකාරක රීති තව ටිකක් හොඳින් කියවිය හැකි (IMO) යනු

පළමුවැන්න සුළුපටු ය. මම හිතන්නේ නැහැ මේ දෙන්නා වෙන්ව කියන්න අමාරුයි කියලා. දෙවැන්න OP හි ලක්ෂ්‍යයට උදාහරණයකි, එය එක්තරා newආකාරයක අතිරික්තයකි.

නම් අවකාශ ගැටුම් තිබිය හැකිය; සලකා බලන්න:

public class Foo {
   Foo() {
      // Constructor
   }
}

public class Bar {
   public static void main(String[] args) {
      Foo f = Foo();
   }

   public Foo Foo() {
      return Foo();
   }
}

ඔබට පරිකල්පනය වැඩි නොකර, අසීමිත පුනරාවර්තන ඇමතුමකින් පහසුවෙන් අවසන් විය හැකිය. සම්පාදකයාට "වස්තුවට සමාන ක්‍රියාකාරී නාමයක්" දෝෂයක් බලාත්මක කිරීමට සිදුවේ. මෙය සැබවින්ම හානියක් නොවනු ඇත, නමුත් එය භාවිතා කිරීම වඩා සරල ය new, එහි සඳහන් වන්නේ, Go to the object of the same name as this method and use the method that matches this signature.ජාවා විග්‍රහ කිරීමට ඉතා සරල භාෂාවක් වන අතර, මෙම ප්‍රදේශයේ මෙම සහාය ඇති බව මම සැක කරමි.

Java, එකක් සඳහා, තවමත් C ++ වල ලියන්නම් ඇත: නැත තරමක් සියල්ල යම් වස්තුවක්. ජාවා තුළ ගතිකව වෙන් කළ යුතු නොවන බිල්ට් වර්ග (උදා, charසහ int) ඇත.

newජාවාහි එය සැබවින්ම අවශ්‍ය බව මින් අදහස් නොවේ - ගතිකව වෙන් කිරීමට අවශ්‍ය නොවන වර්ග සමූහය ස්ථාවර හා දන්නා කරුණකි. ඔබ යම් වස්තුවක් නිර්වචනය කරන විට, එය සරල අගයක් ද charනැතිනම් ගතිකව වෙන් කළ යුතු වස්තුවක් ද යන්න සම්පාදකයාට දැනගත හැකිය (ඇත්ත වශයෙන්ම දනී) .

ජාවා හි සැලසුමේ ගුණාත්මකභාවය පිළිබඳ මෙයින් අදහස් කරන්නේ කුමක්ද යන්න විවෘත කිරීමෙන් (හෝ නැවත) මම වැළකී සිටිමි.

ජාවාස්ක්‍රිප්ට් හි ඔබට එය අවශ්‍ය වන්නේ ඉදිකිරීම්කරු සාමාන්‍ය ශ්‍රිතයක් ලෙස පෙනෙන නිසාය, එබැවින් නව වස්තුව සඳහා නොවන්නේ නම් ඔබට නව වස්තුවක් නිර්මාණය කිරීමට අවශ්‍ය බව JS දැන ගන්නේ කෙසේද?

ජාවාස්ක්‍රිප්ට් ශ්‍රිතයක් newක්‍රියාකරු සමඟ ක්‍රියාත්මක කිරීමෙන් newක්‍රියාකරු නොමැතිව ශ්‍රිතයක් යෙදීමට වඩා වෙනස් හැසිරීමක් ඇති වේ.

උදාහරණයක් වශයෙන්:

Date()       //Returns a string

new Date()   //Returns a Date object

function foo() {};

foo()        //Returns `undefined`

new foo()    //Returns an empty object

සිත්ගන්නා කරුණ නම්, VB ට එය අවශ්‍ය වේ - අතර වෙනස

Dim f As Foo

එය විචල්‍යයක් පවරන්නේ නැතිව ප්‍රකාශ කරයි, එය Foo f;C # ට සමාන වේ , සහ

Dim f As New Foo()

එය විචල්‍යය ප්‍රකාශයට පත් කරන var f = new Foo();අතර C # ට සමාන පංතියේ නව අවස්ථාවක් පවරයි . Pre.NET VB හි, ඔබට භාවිතා කිරීමට Dim f As Fooහෝ Dim f As New Foo- ඉදිකිරීම්කරුවන් මත අධික බරක් නොතිබූ නිසා.

මම බොහෝ පිළිතුරු වලට කැමති අතර මෙය එක් කිරීමට කැමතියි:
එය කේත කියවීම පහසු
කරයි මෙම තත්වය බොහෝ විට සිදුවනු ඇති බවක් නොවේ, නමුත් නාම පදයක් ලෙස එකම නමක් බෙදාගත් ක්‍රියා පදයක නාමයෙන් ඔබට ක්‍රමයක් අවශ්‍ය යැයි සලකන්න. සී # සහ වෙනත් භාෂාවන් ස්වභාවිකවම වචනය objectවෙන් කර ඇත. නමුත් එය එසේ නොවේ නම් එය Foo = object()වස්තු ක්‍රම ඇමතුමේ ප්‍රති result ලයක් වනු ඇත හෝ එය නව වස්තුවක් ක්ෂණිකව ලබා දෙනු ඇත. newමූලික වචන නොමැතිව භාෂාවට මෙම තත්වයෙන් ආරක්ෂා වන නමුත්, newඉදිකිරීම්කරුවෙකු ඇමතීමට පෙර මූලපදයේ අවශ්‍යතාවය අනුව ඔබ වස්තුවක් ලෙස එකම නමක් ඇති ක්‍රමවේදයක් පැවතීමට ඉඩ දෙයි.

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

ජාවාස්ක්‍රිප්ට් සහ සී # කියන්නට තරම් මම නොදනිමි, නමුත් newජාවා හි සී ++ සතුව තිබීම හැර වෙනත් හේතුවක් මට නොපෙනේ .

C # හි එය සාමාජිකයෙකු විසින් නොපැහැදිලි විය හැකි සන්දර්භයන්හි දෘශ්‍යමාන වර්ග වලට ඉඩ දෙයි. එහි වර්ගයට සමාන නමක් සහිත දේපලක් තබා ගැනීමට ඔබට ඉඩ සලසයි. පහත සඳහන් කරුණු සලකා බලන්න,

class Address { 
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
}

class Person {
    public string Name { get; set; }
    public Address Address { get; set; }

    public void ChangeStreet(string newStreet) {
        Address = new Address { 
            Street = newStreet, 
            City = Address.City,
            State = Address.State,
            Zip = Address.Zip
        };
    }
}

භාවිතය සටහන newඑය බව පැහැදිලි විය කිරීමට ඉඩ Addressයනු Addressනො වර්ගය Addressසාමාජිකයෙක්. මෙමඟින් සාමාජිකයෙකුට එහි වර්ගයට සමාන නමක් තිබිය හැක. මෙය නොමැතිව ඔබට නම ගැටීම වළක්වා ගැනීම සඳහා වර්ගයේ නම උපසර්ගගත කළ CAddressයුතුය. මෙය ඉතා චේතනාන්විත වූයේ ඇන්ඩර්ස් කිසි විටෙකත් කුසගින්නෙන් පෙළෙන අංකනයකට හෝ ඒ හා සමාන කිසිම දෙයකට අකමැති වූ අතර එය නොමැතිව භාවිතයට ගැනීමට C # ට අවශ්‍ය වූ බැවිනි. එය ද හුරුපුරුදු කාරණය ද්විත්ව ප්‍රසාද දීමනාවක් විය.

පරිපූර්ණ ඉදිරියට යැවීමත් සමඟම, newC ++ හි ස්ථානගත නොකිරීම අවශ්‍ය නොවේ. එබැවින්, සඳහන් කළ කිසිම භාෂාවකින් එය තවදුරටත් අවශ්‍ය නොවේ.

ජාවා නිර්මාණකරුවන්ට මෙය මතකයේ තිබේදැයි මට විශ්වාස නැත, නමුත් ඔබ වස්තූන් පුනරාවර්තන වාර්තා ලෙස සිතන විට , එවිට ඔබට සිතාගත හැකිය Foo(123)එය වස්තුවක් ආපසු නොදෙන නමුත් වස්තුව නිර්මාණය කරන නිවැරදි ලක්ෂ්‍යයේ ශ්‍රිතයකි (එනම් ශ්‍රිතය නැවත පැමිණේ වස්තුව එය තර්කයක් ලෙස ලබා දෙන්නේ නම් එය ඉදිවෙමින් පවතී). එහි අරමුණ newවන්නේ “ගැටය ගැට ගසා” එම නිවැරදි ස්ථානය නැවත ලබා දීමයි. වෙනත් වචන වලින් කිවහොත් new, "වස්තුවෙන් විය යුතු" දේ පිළිබඳව එය දැනුවත් කරනු ඇත self.

මේ ආකාරයේ ප්‍රවේශය උරුමය විධිමත් කිරීමට උපකාරී වේ: ඔබට වෙනත් වස්තු ශ්‍රිතයක් සමඟ වස්තු ශ්‍රිතයක් දීර් extend කළ හැකි අතර අවසානයේ ඒවා selfභාවිතා කිරීමෙන් පොදු දේ ලබා දිය හැකිය new:

cp = new (Colored("Blue") & Line(0, 0, 100, 100))

මෙන්න &වස්තු-ශ්‍රිත දෙකක් ඒකාබද්ධ කරයි.

මෙම අවස්ථාවේ දී පහත newපරිදි අර්ථ දැක්විය හැකිය:

def new(objectFunction) {
    actualObject = objectFunction(actualObject)
    return actualObject
}

'නිල්' ඉඩ දීමට.

ගොඩවල් මත පදනම් වූ ප්‍රතිපාදන සමඟ ජාවා නිල් වස්තූන් භාවිතය වැලඳ ගත්තේය. කෞතුක වස්තුවක් ලෙස නොව අංගයක් ලෙස. වස්තූන්ට නිත්‍ය තත්වයක් තිබිය හැකි විට, ඔබ ප්‍රකාශය ආරම්භයේ සිට වෙන් කළ යුතුය. එබැවින් නව මූල පදය.

C ++ හි රේඛාවක් වැනි ය

Person me;

ක්ෂණිකව පෙරනිමි ඉදිකිරීම්කරු අමතනු ඇත.

පයිතන්ට එය අවශ්‍ය නොවීමට හේතුව එහි වර්ග පද්ධතියයි. මූලික වශයෙන්, ඔබ foo = bar()පයිතන් හි දකින විට, bar()ආයාචනා කරනු ලබන ක්‍රමයක්, ක්ෂණිකව ක්‍රියාත්මක වන පන්තියක් හෝ විනෝදජනක වස්තුවක් යනු කුමක් ද යන්න ගැටළුවක් නොවේ ; පයිතන්හි, ශ්‍රිතයක් සහ ශ්‍රිතයක් අතර මූලික වෙනසක් නොමැත (ක්‍රම වස්තු බැවින්); පංතියක් ක්ෂණිකව ක්‍රියාත්මක කිරීම විනෝදකාමී පුද්ගලයෙකුගේ විශේෂ අවස්ථාවක් යැයි ඔබට තර්ක කළ හැකිය. මේ අනුව, සිදුවෙමින් පවතින දේවල පුරාවිද්‍යාත්මක වෙනසක් ඇති කිරීමට කිසිදු හේතුවක් නැත (විශේෂයෙන් මතක කළමනාකරණය පයිතන් තුළ අතිශයින් සැඟවී ඇති හෙයින්).

වෙනත් යතුරු ලියන පද්ධතියක් ඇති භාෂාවක, හෝ ක්‍රම සහ පන්ති වස්තු නොවන විට, වස්තුවක් නිර්මාණය කිරීම සහ ශ්‍රිතයක් හෝ විනෝදයක් ඇමතීම අතර වඩා ශක්තිමත් සංකල්පීය වෙනසක් ඇතිවීමේ හැකියාව පවතී . මේ අනුව, සම්පාදකයාට / පරිවර්තකයාට යතුරුපදය අවශ්‍ය newනොවුවද, එය පයිතන් සතුව ඇති සියලු සීමාවන් කඩ නොකළ භාෂාවලින් පවත්වා ගත හැකි බව තේරුම් ගත හැකිය.

නූල් භාවිතා කරන විට ඇත්ත වශයෙන්ම ජාවා හි වෙනසක් ඇත:

String myString = "myString";

සිට වෙනස් වේ

String myString = new String("myString");

නූල "myString"මීට පෙර කවදාවත් භාවිතා කර නැතැයි සිතමු , පළමු ප්‍රකාශය නූල් තටාකයේ තනි ගොඩක් වස්තුවක් (ගොඩවල විශේෂ ප්‍රදේශයක්) නිර්මාණය කරන අතර දෙවන ප්‍රකාශය වස්තු දෙකක් නිර්මාණය කරයි. . මෙම විශේෂිත අවස්ථාවෙහිදී දෙවන ප්‍රකාශය නිෂ් less ල බව පැහැදිලිය, නමුත් එය භාෂාවට ඉඩ දිය හැකිය.

මෙයින් අදහස් කරන්නේ වස්තුව නිර්මාණය වී ඇත්තේ ගොඩවල් වල ඇති විශේෂ ප්‍රදේශය තුළ බවත්, සාමාන්‍ය වස්තු ක්ෂණිකකරණය සඳහා වෙන් කර ඇති බවත්, නමුත් එය නොමැතිව වස්තූන් ස්ථාපනය කිරීමේ වෙනත් ක්‍රම තිබිය හැකි බවත්; ඉහත උදාහරණය නිදසුනකි, විස්තීරණතාව සඳහා ඉඩ ඉතිරිව ඇත.

C # හි ගොඩගැසීමට එදිරිව ගොඩගැසී ඇති වස්තූන් අතර වෙනස හඳුනා ගැනීම වැදගත් වේ. වඩා හොඳ කාර්ය සාධනය සඳහා අපි නිතරම තොගයේ වස්තු නිර්මාණය කරමු. බලන්න, තොගයේ ඇති වස්තුවක් විෂය පථයෙන් ඉවතට ගිය විට, ප්‍රාථමිකය මෙන් තොගය දිග හැරෙන විට එය වහාම අතුරුදහන් වේ. කසළ එකතු කරන්නාට එය නිරීක්ෂණය කිරීම අවශ්‍ය නොවන අතර, ගොඩවල් සඳහා අවශ්‍ය ඉඩ වෙන් කිරීම සඳහා මතක කළමනාකරුගේ අමතර පොදු කාර්යයක් නොමැත.