OOP සන්දර්භය තුළ ක්‍රමවේදයන්ට එදිරිව කාර්යයන් පිළිබඳ සරල පැහැදිලි කිරීමක් යමෙකුට ලබා දිය හැකිද ?

ඒ කාර්යය නාමය බව කේතය කෑල්ලක් වේ. එය ක්‍රියාත්මක වීමට දත්ත ලබා දිය හැකිය (එනම් පරාමිතීන්) සහ විකල්ප වශයෙන් දත්ත ආපසු ලබා දිය හැකිය (ප්‍රතිලාභ අගය). ශ්‍රිතයකට ලබා දෙන සියලුම දත්ත පැහැදිලිවම සම්මත වේ.

ඒ ක්රමය වස්තුවක් සමඟ සම්බන්ධ වී සිටින නාමය බව කේතය කෑල්ලක් වේ. බොහෝ ආකාරවලින් එය ප්‍රධාන වෙනස්කම් දෙකක් හැර ශ්‍රිතයකට සමාන වේ:

1. ක්‍රමයක් යනු එය හැඳින්වූ වස්තුව ව්‍යංගයෙන් සම්මත කිරීමයි.
2. පංතිය තුළ අඩංගු දත්ත මත ක්‍රියා කිරීමට ක්‍රමවේදයකට හැකියාව ඇත (වස්තුවක් පන්තියක උදාහරණයක් බව මතක තබා ගැනීම - පන්තිය යනු අර්ථ දැක්වීම, වස්තුව එම දත්තවල නිදසුනකි).

(මෙය සරල කළ පැහැදිලි කිරීමකි, විෂය පථයේ ගැටළු නොසලකා හැරීම )

ක්‍රමයක් වස්තුවක් මත වේ.
ශ්‍රිතයක් වස්තුවකින් ස්වාධීන වේ.

ජාවා සහ සී # සඳහා ඇත්තේ ක්‍රම පමණි.
C සඳහා, ඇත්තේ කාර්යයන් පමණි.

C ++ සහ Python සඳහා එය රඳා පවතින්නේ ඔබ පන්තියක සිටිනවාද නැද්ද යන්න මතය.

'method' යනු 'ශ්‍රිතය' සඳහා වස්තු-නැඹුරු වචනයයි . එයට ඇත්තේ එපමණකි (එනම් සැබෑ වෙනසක් නැත).

අවාසනාවකට මෙන්, මෙහි ඇති පිළිතුරු බොහොමයක් සංකීර්ණ, අර්ථවත් වෙනසක් ඇතැයි යන අදහස සදාකාලික හෝ ඉදිරියට ගෙන යන බව මම සිතමි.

ඇත්ත වශයෙන්ම - ඒ සඳහා එතරම් දෙයක් නැත, එකම දෙයට වෙනස් වචන පමණි.

[ප්‍රමාද එකතු කිරීම]

ඇත්ත වශයෙන්ම, බ්‍රයන් නීල් මෙම ප්‍රශ්නයට අදහස් දැක්වීමේදී පෙන්වා දුන් පරිදි, සාමාජික ක්‍රියාකාරකම් ගැන සඳහන් කිරීමේදී C ++ ප්‍රමිතිය කිසි විටෙකත් 'ක්‍රමය' යන යෙදුම භාවිතා නොකරයි. සමහර අය එය C ++ සැබවින්ම වස්තු-නැඹුරු භාෂාවක් නොවන බවට ඇඟවීමක් ලෙස ගත හැකිය; කෙසේ වෙතත්, වෙනත් යෙදුමක් භාවිතා කිරීමට විශේෂයෙන් ප්‍රබල හේතුවක් ඇතැයි ලස්සන බුද්ධිමත් පිරිසක් නොසිතූ බවට ඇඟවීමක් ලෙස මම එය ගැනීමට කැමැත්තෙමි.

පොදුවේ: ක්‍රම යනු පන්තියකට අයත් ශ්‍රිතයන් වන අතර, ශ්‍රිත කේතයේ වෙනත් ඕනෑම විෂය පථයක් මත විය හැකි අතර එමඟින් සියලු ක්‍රම ශ්‍රිත බව ඔබට පැවසිය හැකිය, නමුත් සියලු කාර්යයන් ක්‍රම නොවේ:

පහත දැක්වෙන පයිතන් උදාහරණය ගන්න:

class Door:
    def open(self):
    print 'hello stranger'

def knock_door:
    a_door = Door()
    Door.open(a_door)

knock_door()

ලබා දී ඇති උදාහරණයෙන් ඔබට "දොර" නම් පංතියක් පෙන්වන අතර එය "විවෘත" යනුවෙන් හැඳින්වෙන ක්‍රමයක් හෝ ක්‍රියාවක් ඇත, එය පන්තියක් තුළ ප්‍රකාශයට පත් කළ බැවින් එය ක්‍රමයක් ලෙස හැඳින්වේ. "ඩෙෆ්" සමඟ කේතයේ තවත් කොටසක් ඇත, එය ශ්‍රිතයක් නිර්වචනය කරයි, එය ශ්‍රිතයක් වන්නේ එය පන්තියක් තුළ ප්‍රකාශයට පත් නොකිරීම නිසා ය, මෙම ශ්‍රිතය අපගේ පන්තිය තුළ අප විසින් නිර්වචනය කර ඇති ක්‍රමය ඔබට පෙනෙන පරිදි කැඳවන අතර අවසානයේ ශ්‍රිතය වේ තනිවම කැඳවනු ලැබේ.

ඔබට පෙනෙන පරිදි ඔබට ඕනෑම තැනක ශ්‍රිතයක් ඇමතිය හැකි නමුත් ඔබට ක්‍රමයක් ඇමතීමට අවශ්‍ය නම් එක්කෝ ඔබට එම වර්ගයේම නව වස්තුවක් සම්මත කළ යුතුය. පංතිය ප්‍රකාශයට පත් කළ ආකාරයටම (Class.method (object)) හෝ ඔබට ආයාචනා කළ යුතුය. වස්තුව තුළ ඇති ක්‍රමය (object.Method ()), අවම වශයෙන් පයිතන් තුළ.

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

මතක තබා ගත හැකි සරල ක්‍රමය:

• F unction F ree (නිදහස් මාධ්‍ය යනු වස්තුවකට හෝ පන්තියකට අයත් නොවේ)
• M ethod → M ember (වස්තුවක හෝ පන්තියේ සාමාජිකයෙක්)

ශ්‍රිතයක් සහ ක්‍රමයක් අතර ඇති ප්‍රධාන වෙනස පිළිබඳ සාමාන්‍ය අර්ථ දැක්වීමක් :

පන්ති වලින් පිටත කාර්යයන් අර්ථ දක්වා ඇති අතර ක්‍රම නිර්වචනය කරනු ලබන්නේ පන්තිවල ඇතුළත සහ කොටසක් ය.

ඔබට මෙහි කියවීමට අවශ්‍ය නම් "OO ක්‍රම පිළිබඳ මගේ හැඳින්වීම"

Object Oriented Paradim හි අදහස වන්නේ මෘදුකාංගය සෑදී ඇති "තර්ජනය" කිරීමයි .. හොඳින් "වස්තූන්" ය. තථ්‍ය ලෝකයේ වස්තූන් සතුව දේපළ තිබේ, උදාහරණයක් ලෙස ඔබට සේවකයෙකු සිටී නම්, සේවකයාට නමක්, සේවක හැඳුනුම්පතක්, තනතුරක් තිබේ, ඔහු දෙපාර්තමේන්තුවට අයත් යනාදිය.

වස්තුව ද එහි ගුණාංග සමඟ කටයුතු කරන්නේ කෙසේද සහ ඒවා මත යම් මෙහෙයුම් සිදු කරන්නේ කෙසේදැයි දනී. සේවකයෙකු දැන් කරන්නේ කුමක්දැයි දැන ගැනීමට අපට අවශ්‍ය නම් අපි ඔහුගෙන් විමසමු.

employe whatAreYouDoing.

එම "whatAreYouDoing" යනු වස්තුවට යවන ලද "පණිවිඩයකි". එම ප්‍රශ්නවලට පිළිතුරු දිය යුතු ආකාරය වස්තුව දනී, ප්‍රශ්නය විසඳීමට එයට “ක්‍රමයක්” ඇතැයි කියනු ලැබේ.

එබැවින්, වස්තූන් එහි හැසිරීම හෙළි කළ යුතු ආකාරය ක්‍රම ලෙස හැඳින්වේ. මේ අනුව ක්‍රම වන්නේ පුරාවස්තු වස්තුවට යමක් "කළ යුතු" ය.

හැකි වෙනත් ක්‍රම වේ

employee whatIsYourName
employee whatIsYourDepartmentsName

ආදිය.

අනෙක් අතට කාර්යයන් යනු ක්‍රමලේඛන භාෂාවකට සමහර දත්ත ගණනය කළ හැකි ක්‍රම වේ, නිදසුනක් ලෙස ඔබට ඇඩ්වෝල්ස් (8, 8) ශ්‍රිතය 16 ක් ලබා දෙයි.

// pseudo-code
function addValues( int x, int y )  return x + y 
// call it 
result = addValues( 8,8 )
print result // output is 16...

පළමු ජනප්‍රිය ක්‍රමලේඛන භාෂාවන් (ෆෝට්රාන්, සී, පැස්කල් වැනි) OO ආදර්ශය ආවරණය නොකිරීම නිසා, ඔවුන් මෙම කෞතුක වස්තු "ශ්‍රිත" වලට පමණක් කැඳවයි.

උදාහරණයක් ලෙස C හි පෙර ශ්‍රිතය වනුයේ:

int addValues( int x, int y ) 
{
   return x + y;
}

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

public static int addValues( int x, int y ) {
    return x + y;
}

හුරුපුරුදු බව පෙනේ? එයට හේතුව ජාවා හි මූලයන් C ++ හා C ++ මත C මත ඇති බැවිනි.

අවසානයේ සංකල්පයක් පමණක් වන අතර, ක්‍රියාත්මක කිරීමේදී ඒවා එක හා සමාන විය හැකි නමුත් OO ප්‍රලේඛනයේදී මේවා ක්‍රමවේදය ලෙස හැඳින්වේ.

ජාවා හි කලින් සේවක වස්තුව පිළිබඳ උදාහරණයක් මෙන්න.

public class Employee {

    Department department;
    String name;

    public String whatsYourName(){
        return this.name;
    }
    public String whatsYourDeparmentsName(){
         return this.department.name();
    }
    public String whatAreYouDoing(){
        return "nothing";
    } 
    // Ignore the following, only set here for completness
    public Employee( String name ) {
        this.name = name;
    }

}

// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John

// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();

// Print the info to the console.

 System.out.printf("Employee %s is doing: %s", name, doingWhat );

Output:
Employee John is doing nothing.

එවිට වෙනස වන්නේ එය යෙදෙන "වසම" මත ය.

ඇපල් ස්ක්‍රිප්ටයට “ස්වාභාවික භාෂාව” මැට්ෆෝර් පිළිබඳ අදහස ඇත, යම් අවස්ථාවක දී ඕ.ඕ. උදාහරණයක් ලෙස ස්මාල්ටෝක්. මෙය කියවීමෙන් පසු වස්තූන්ගේ ක්‍රම තේරුම් ගැනීම ඔබට පහසු වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

සටහන: කේතය සම්පාදනය කිරීම නොවේ, උදාහරණයක් ලෙස සේවය කිරීම. ලිපිය වෙනස් කිරීමට සහ පයිතන් උදාහරණය එක් කිරීමට නිදහස් වන්න.

OO ලෝකයේ, දෙකම එකම දේ අදහස් කිරීමට බහුලව භාවිතා වේ.

පිරිසිදු ගණිත හා සීඑස් දෘෂ්ටි කෝණයකින්, ශ්‍රිතයක් එකම තර්ක (f (x, y) = (x + y)) සමඟ කැඳවූ විට සෑම විටම එකම ප්‍රති result ලය ලබා දෙනු ඇත. අනෙක් අතට ක්‍රමයක් සාමාන්‍යයෙන් පන්තියක උදාහරණයක් සමඟ සම්බන්ධ වේ. නැවතත්, බොහෝ නූතන OO භාෂාවන් තවදුරටත් "ශ්‍රිතය" යන පදය භාවිතා නොකරයි. බොහෝ ස්ථිතික ක්‍රම සාමාන්‍යයෙන් තත්වයක් නොමැති බැවින් (සෑම විටම සත්‍ය නොවේ).

ශ්‍රිතයක් යනු කේත සමූහයක් (සාමාන්‍යයෙන් එහි විෂය පථය හා සමහර විට තමන්ගේම වසා දැමීම සමඟ) සමහර තර්ක ලැබිය හැකි අතර ප්‍රති .ලයක් ලබා දිය හැකිය.

ක්‍රමයක් යනු වස්තුවකට අයත් ශ්‍රිතයකි (සමහර වස්තු දිශානත පද්ධතිවල එය පන්තියකට අයත් යැයි කීම වඩාත් නිවැරදිය). වස්තුවක් / පංතියක් විසින් "අයිති" වීම යන්නෙන් අදහස් වන්නේ ඔබ වස්තුව / පන්තිය හරහා ක්‍රමයට යොමු වන බවයි; උදාහරණයක් ලෙස, ජාවා හි ඔබට "දොර" වස්තුවකට අයත් "විවෘත ()" ක්‍රමයක් භාවිතා කිරීමට අවශ්‍ය නම් ඔබට "door.open ()" ලිවිය යුතුය.

සාමාන්‍යයෙන් ක්‍රම මඟින් වස්තුව / පන්තිය තුළ ඔවුන්ගේ හැසිරීම විස්තර කරන අමතර ගුණාංග ද ලබා ගනී, නිදසුනක් ලෙස: දෘශ්‍යතාව (වස්තු දිශානත සංකල්පය හා සම්බන්ධ), එය කුමන වස්තූන්ගෙන් (හෝ පන්තිවලින්) ආයාචනා කළ හැකිද යන්න නිර්වචනය කරයි.

බොහෝ වස්තු දිශානත භාෂාවල, සියලු “ශ්‍රිත” කිසියම් වස්තුවකට (හෝ පන්තියට) අයත් වන අතර එම නිසා මෙම භාෂාවල ක්‍රම නොවන ශ්‍රිත නොමැත.

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

http://en.wikipedia.org/wiki/Method_(computer_science)

ශ්‍රිතයක් යනු ගණිතමය සංකල්පයකි. උදාහරණයක් වශයෙන්:

f(x,y) = sin(x) + cos(y)

f () ශ්‍රිතය දෙවන පරාමිතියේ කොසයින් වලට එකතු කරන ලද පළමු පරාමිතියේ පාපය නැවත ලබා දෙන බව පවසයි. එය ගණිතය පමණි. එය සිදු වන විට පාපය () සහ cos () ද ශ්‍රිත වේ. ශ්‍රිතයකට තවත් දේපලක් ඇත: එකම පරාමිතීන් සහිත ශ්‍රිතයක් සඳහා වන සියලුම ඇමතුම් එකම ප්‍රති .ලය ලබා දිය යුතුය.

ක්‍රමයක් යනු අනෙක් අතට, වස්තුවකට නැඹුරු භාෂාවක වස්තුවකට සම්බන්ධ ශ්‍රිතයකි. එයට එක් ව්‍යංග පරාමිතියක් ඇත: වස්තුව ක්‍රියාත්මක වන විට (සහ එය තත්වය).

එබැවින්, ඔබට g (x) ක්‍රමයක් සහිත Z වස්තුවක් තිබේ නම්, ඔබට පහත දෑ දැකිය හැකිය:

Z.g(x) = sin(x) + cos(Z.y)

මෙම අවස්ථාවෙහිදී, x පරාමිතිය සම්මත කර ඇත, එය පෙර ක්‍රියාකාරී උදාහරණයේ දී මෙන් ය. කෙසේ වෙතත්, cos () සඳහා වන පරාමිතිය Z. Z වස්තුව තුළ ජීවත්වන අගයක් වන අතර එය තුළ ජීවත්වන දත්ත (Zy) යනු Z හි g () ක්‍රමයට ව්‍යංග පරාමිතීන් වේ.

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

දී සී භාෂාව කාලීන කාර්යය භාවිතා කරයි. ජාවා සහ සී # පුද්ගලයින් එය ක්‍රමයක් යැයි කියනු ඇත (මෙම නඩුවේ ශ්‍රිතයක් පන්ති / වස්තුවක් තුළ අර්ථ දැක්වේ).

ඒ C ++ ක්රමලේඛකයෙක් කාලීන 'ක්රමය' නිසා ද C / C ++ පමණක් ක්රමලේඛකයෙක් ඉඩ උත්සවයකට යනුවෙන් හැඳින්විය හැකි, (අ උත්සවය හෝ සමහර විට ක්රමය එය හැඳින්විය හැකියි ඔවුන් කාර්ය පටිපාටික ශෛලිය C ++ කේතය හෝ C ++ වැනි වස්තු නැඹුරු මාර්ගය කරන්නේ ලියන නම් මත පදනම්ව C / C ++ සාහිත්‍යයෙහි අඩුවෙන් භාවිතා වේ).

ඔබ ශ්‍රිතයක් භාවිතා කරන්නේ එහි නම ලෙසිනි.

result = mySum(num1, num2);

පළමුවෙන් මෙන් එහි වස්තුව යොමු කිරීමෙන් ඔබ ක්‍රමයක් අමතනු ඇත,

result = MyCalc.mySum(num1,num2);

Method තිහාසික වශයෙන්, “ක්‍රමයක්” යනු වටිනාකමක් ලබා නොදෙන දෙයක් සහ “ශ්‍රිතයක්” වීම සමඟ සියුම් වෙනසක් තිබෙන්නට පුළුවන. සෑම භාෂාවකටම විශේෂ අර්ථයක් සහිත වචන ශබ්ද කෝෂයක් ඇත .

දී , "C" , යන වචනය "ශ්රිතය" අදහස් වැඩසටහනක් සාමාන්ය .

දී ජාවා , වචනය "ශ්රිතය" විශේෂ අර්ථයක් නැහැ. ඇති ෙහයින්ද "ක්රමය" යනු පන්ති ක්රියාත්මක බවට පත්ව ඇති චර්යාවන් එකක්.

දී C # ලෙස පරිවර්තනය වන බව:

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

නමුත් ඇත්ත වශයෙන්ම, සංකල්ප 2 හි සැබවින්ම වෙනසක් නොමැති බව මම නැවත කියමි. ඔබ ජාවා පිළිබඳ අවිධිමත් සාකච්ඡාවලදී "ශ්‍රිතය" යන යෙදුම භාවිතා කරන්නේ නම්, ඔබ අදහස් කළේ "ක්‍රමය" යැයි මිනිසුන් උපකල්පනය කර ඉදිරියට ගෙන යනු ඇත. ජාවා පිළිබඳ නිසි ලියකියවිලි හෝ ඉදිරිපත් කිරීම් වල එය භාවිතා නොකරන්න, නැතහොත් ඔබ මෝඩයෙකු ලෙස පෙනෙනු ඇත.

ක්‍රියාකාරිත්වය යනු දත්ත හැසිරවීමට භාවිතා කළ හැකි තර්කන සමූහයකි.

ක්‍රමය යනු ශ්‍රිතය යනු එය අයත් වස්තුවේ දත්ත හැසිරවීමට භාවිතා කරන ශ්‍රිතයයි. එබැවින් තාක්‍ෂණිකව, ඔබේ පන්තියට සම්පුර්ණයෙන්ම සම්බන්ධ නොවන නමුත් පන්තියේ ප්‍රකාශයට පත් කරන ලද ශ්‍රිතයක් තිබේ නම් එය ක්‍රමයක් නොවේ; එය නරක නිර්මාණයක් ලෙස හැඳින්වේ.

පංතියක ක්‍රම වස්තුව ලෙස හැඳින්වෙන පන්තියේ උදාහරණය මත ක්‍රියා කරයි.

class Example
{
   public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".

   public void UpdateData() // .. and manipulates it (This is a method by the way)
   {
      data = data + 1;
   }

   public void PrintData() // This is also a method
   {
      Console.WriteLine(data);
   }
}

class Program
{
   public static void Main()
   {
       Example exampleObject1 = new Example();
       Example exampleObject2 = new Example();

       exampleObject1.UpdateData();
       exampleObject1.UpdateData();

       exampleObject2.UpdateData();

       exampleObject1.PrintData(); // Prints "2"
       exampleObject2.PrintData(); // Prints "1"
   }
}

වස්තු පැස්කල් හෝ සී ++ වැනි OO භාෂාවල “ක්‍රමයක්” යනු වස්තුවක් හා සම්බන්ධ ශ්‍රිතයකි. උදාහරණයක් ලෙස, "බල්ලා" වස්තුවකට "පොතු" ශ්‍රිතයක් තිබිය හැකි අතර මෙය "ක්‍රමයක්" ලෙස සැලකේ. ඊට වෙනස්ව, "StrLen" ශ්‍රිතය තනිවම පවතී (එය තර්කයක් ලෙස සපයා ඇති නූලක දිග සපයයි). එබැවින් එය “ශ්‍රිතයක්” පමණි . ජාවාස්ක්‍රිප්ට් තාක්‍ෂණිකව වස්තු දිශානතියකින් යුක්ත වන නමුත් සී ++, සී # හෝ පැස්කල් වැනි පූර්ණ භාෂාවක් සමඟ සසඳන විට බොහෝ සීමාවන්ට මුහුණ දෙයි. එසේ වුවද, වෙනස තවමත් පැවතිය යුතුය.

අමතර කරුණු කිහිපයක්: C # සම්පූර්ණයෙන්ම වස්තු නැඹුරු බැවින් ඔබට තනිවම "කාර්යයන්" නිර්මාණය කළ නොහැක. C # හි සෑම ශ්‍රිතයක්ම වස්තුවකට බැඳී ඇති අතර තාක්‍ෂණිකව එය “ක්‍රමයක්” වේ. පයින් ගැසීම යනු C # හි සිටින කිහිප දෙනෙකු ඔවුන්ව “ක්‍රම” ලෙස හැඳින්වීමයි - ඔවුන් “ශ්‍රිත” යන පදය භාවිතා කරන්නේ සැබෑ වෙනසක් කළ නොහැකි බැවිනි.

අවසාන වශයෙන් - ඕනෑම පැස්කල් ගුරු වරුන් මෙහි මා වෙතට පනින්නේ නැත - පැස්කල් ද "කාර්යයන්" (වටිනාකමක් ලබා දෙන) සහ "ක්‍රියා පටිපාටි" අතර වෙනස දක්වයි. ඇත්ත වශයෙන්ම, ඔබට වටිනාකමක් ලබා දීමට හෝ නොකිරීමට තෝරා ගත හැකි වුවද, සී # මෙම වෙනස පැහැදිලිව නොකියයි.

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

# perfectly normal function
def hello(greetee):
  print "Hello", greetee

# generalise a bit (still a function though)
def greet(greeting, greetee):
  print greeting, greetee

# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
  print greeter.greeting, greetee

# very simple class we can pass to greet_with_greeter
class Greeter(object):
  def __init__(self, greeting):
    self.greeting = greeting

  # while we're at it, here's a method that uses self.greeting...
  def greet(self, greetee):
    print self.greeting, greetee

# save an object of class Greeter for later
hello_greeter = Greeter("Hello")

# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")

දැන් ශ්‍රිතය greet_with_greeterහා ක්‍රමය සංසන්දනය කරන්න greet: එකම වෙනස වන්නේ පළමු පරාමිතියේ නමයි (ශ්‍රිතයේ දී මම එය "ග්‍රීටර්" ලෙස හැඳින්වූ අතර, ක්‍රමයේදී මම එය "ස්වයං" ලෙස නම් කළෙමි). ඒ නිසා මට ශ්‍රිතය භාවිතා greetකරන ආකාරයටම ක්‍රමවේදය භාවිතා කළ හැකිය greet_with_greeter("ඩොට්" සින්ටැක්ස් භාවිතා කර එය ලබා ගැනීම සඳහා, මම එය පන්තියක් තුළ අර්ථ දක්වා ඇති බැවින්):

Greeter.greet(hello_greeter, "World")

ඒ නිසා මම effectively ලදායී ලෙස ක්‍රමයක් ශ්‍රිතයක් බවට පත් කර ඇත්තෙමි. මට ශ්‍රිතයක් ක්‍රමයක් බවට පත් කළ හැකිද? පංති නිර්වචනය කිරීමෙන් පසු ඒවා අවුල් කිරීමට පයිතන් ඔබට ඉඩ දෙන බැවින්, අපි උත්සාහ කරමු:

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

ඔව්, ශ්‍රිතය greet_with_greeterදැන් ක්‍රමය ලෙසද හැඳින්වේ greet2. ක්‍රමයක් සහ ශ්‍රිතයක් අතර ඇති එකම සැබෑ වෙනස මෙය පෙන්වයි: ඔබ වස්තුවක් “මත” කැඳවීමෙන් ඇමතුමක් ලබා දෙන විට object.method(args), භාෂාව එය ඉන්ද්‍රජාලිකව පරිවර්තනය method(object, args)කරයි.

(OO පාරිශුද්ධවාදීන් තර්ක කරන්නේ ක්‍රමවේදයක් ශ්‍රිතයකට වඩා වෙනස් දෙයක් වන අතර, ඔබ උසස් පයිතන් හෝ රූබි හෝ ස්මාල්ටෝක් වෙත පිවිසෙන්නේ නම් - ඔබ ඔවුන්ගේ අදහස දැකීමට පටන් ගනීවි. සමහර භාෂා ක්‍රම මඟින් වස්තුවක බිටු සඳහා විශේෂ ප්‍රවේශයක් ලබා දෙයි. ප්‍රධාන සංකල්පීය වෙනස තවමත් සැඟවුණු අතිරේක පරාමිතියයි.)

මා සඳහා: ක්‍රමයකට සහ ශ්‍රිතයකට මා එකඟ වන්නේ නම් එය සමාන වේ:

• ශ්‍රිතයකට අගයක් ලබා දිය හැකිය
• පරාමිතීන් අපේක්ෂා කළ හැකිය

ඕනෑම කේත කැබැල්ලක් සේම ඔබ දැමූ වස්තූන් තිබිය හැකි අතර එහි ප්‍රති .ලයක් ලෙස ඔබට වස්තුවක් තිබිය හැකිය. එසේ කිරීමේදී ඔවුන් වස්තුවක තත්වය වෙනස් කළ හැකි නමුත් එය මා සඳහා ඔවුන්ගේ මූලික ක්‍රියාකාරිත්වය වෙනස් නොකරයි.

වස්තූන්ගේ හෝ වෙනත් කේතවල ඇමතුම් කාර්යයන්හි වෙනසක් ඇති අර්ථ දැක්වීමක් තිබිය හැකිය. නමුත් එය වාචික විභේදනය සඳහා යමක් නොවන අතර මිනිසුන් ඒවා එකිනෙකට හුවමාරු කරන්නේ එබැවිනි. මම පරිස්සම් විය යුතු ගණනය කිරීමේ උදාහරණය සඳහන් කරයි. මගේ ගණනය කිරීම් සඳහා මම සේවකයින් බඳවා ගන්නා නිසා:

new Employer().calculateSum( 8, 8 );

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

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

මගේ අවබෝධය අනුව ක්‍රමයක් යනු පන්තියක සිදු කළ හැකි ඕනෑම මෙහෙයුමකි. එය ක්‍රමලේඛනය සඳහා භාවිතා කරන සාමාන්‍ය යෙදුමකි.

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

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

පළමු ඇණවුමකට ආසන්න වශයෙන්, ක්‍රමයක් (C ++ style OO වලින්) යනු සාමාජික ශ්‍රිතයක් සඳහා වන තවත් වචනයකි, එය පන්තියක කොටසකි.

සී / සී ++ වැනි භාෂාවලින් ඔබට පන්තියක සාමාජික නොවන කාර්යයන් තිබිය හැකිය; ඔබ පන්තියක් හා සම්බන්ධ නොවන ශ්‍රිතයක් ක්‍රමයක් ලෙස නොකියයි.

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

ක්‍රියාකාරිත්වය යනු ප්‍රධාන වශයෙන් ක්‍රියාපටිපාටිය නැඹුරු වැඩසටහන්කරණයට අයත් සංකල්පයයි එහිදී ශ්‍රිතයක් යනු දත්ත සැකසීමට සහ ඔබට වටිනාකමක් ලබා දිය හැකි ආයතනයකි

ක්‍රමය යනු වස්තු පෙරදිග ක්‍රමලේඛනයේ සංකල්පය වන අතර එහිදී ක්‍රමයක් යනු පන්තියේ සාමාජිකයෙකු වන අතර එය බොහෝ දුරට පන්ති සාමාජිකයන් මත සැකසීම සිදු කරයි.

මම විශේෂ expert යෙක් නොවෙමි, නමුත් මෙය මම දනිමි:

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

2. ක්‍රමය යනු OO පදයයි, සාමාන්‍යයෙන් එයට ශ්‍රිත පරාමිතියෙහි මෙම දර්ශකය ඇත. C වැනි මෙම කේත කැබැල්ල ඔබට ආයාචනා කළ නොහැක, ඔබට එය භාවිතා කිරීමට වස්තුව භාවිතා කළ යුතුය.

3. ඉන්වොයිසි ක්‍රම ද වෙනස් ය. මෙම කේත කැබැල්ලේ ලිපිනය සොයා ගැනීමට මෙහි අර්ථය ඉල්ලන්න. C / C ++, සම්බන්ධ කිරීමේ වේලාව ශ්‍රිත සංකේතය සොයා ගැනීමට භාවිතා කරයි.

4. වෛෂයික-සී වෙනස් ය. ලිපිනය සොයා ගැනීම සඳහා දත්ත ව්‍යුහය භාවිතා කිරීම සඳහා සී ශ්‍රිතයක් අදහස් කරන්න. එයින් අදහස් වන්නේ ධාවන වේලාවේදී සියල්ල දන්නා බවයි.

IMHO පුද්ගලයින්ට අවශ්‍ය වූයේ වස්තු තුළ ඇති කාර්යයන් වෙත යොමු වීමට අවශ්‍ය වූ විට ක්‍රමලේඛකයින් අතර පහසු සන්නිවේදනයක් සඳහා නව වචනයක් නිර්මාණය කිරීමට ය.

ඔබ ක්‍රම කියන්නේ නම් ඔබ අදහස් කරන්නේ පන්තිය තුළ ඇති කාර්යයන් ය. ඔබ කාර්යයන් කියන්නේ නම් ඔබ අදහස් කරන්නේ පන්තියෙන් පිටත ක්‍රියා කිරීමයි.

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

ශ්‍රිතය යනු යමක් කිරීමේ කාර්යභාරයක් ( ශ්‍රිතයක් ) ඉටු කළ යුතු කේතයකි . ක්රමය යනු ගැටළුව විසඳීමේ ක්රමයකි .

එය එකම දේ කරයි. එය එකම දෙයකි. ඔබට ඉතා නිරවද්‍ය වීමට අවශ්‍ය නම් සහ සමුළුව සමඟ යාමට ඔබට ක්‍රම වස්තු තුළ ඇති කාර්යයන් ලෙස හැඳින්විය හැකිය.

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

ක්‍රමයක් යනු අර්ථ දක්වන ලද ග්‍රාහකයක් ඇති ශ්‍රිතයකි, OOP අනුව, ක්‍රමයක් යනු වස්තුවක උදාහරණයක් මත ශ්‍රිතයකි.

ක්‍රම සහ කාර්යයන් අතර වෙනස

මයික්‍රොසොෆ්ට් හි මෙම ලේඛනය කියවීමෙන්

ක්‍රියාත්මක කළ හැකි කේත අඩංගු සාමාජිකයින් සාමූහිකව පන්තියක ක්‍රියාකාරී සාමාජිකයන් ලෙස හැඳින්වේ. පූර්ව කොටසෙහි ක්‍රියාකාරී සාමාජිකයින්ගේ ප්‍රාථමික වර්ග වන ක්‍රම විස්තර කෙරේ. මෙම කොටස මඟින් C # මගින් සහාය දක්වන අනෙකුත් ආකාරයේ ක්‍රියාකාරී සාමාජිකයන් විස්තර කරයි: ඉදිකිරීම්කරුවන්, දේපල, දර්ශක, සිදුවීම්, ක්‍රියාකරුවන් සහ අවසන් කරන්නන්.

එබැවින් ක්‍රම යනු ශ්‍රිතයන්ගේ උප කුලකයයි. සෑම ක්‍රමයක්ම ශ්‍රිතයක් වන නමුත් සෑම ශ්‍රිතයක්ම ක්‍රමයක් නොවේ, උදාහරණයක් ලෙස, ක්‍රමයක්constructor ලෙස පැවසිය නොහැකි නමුත් එය ශ්‍රිතයකි.

ශ්‍රිතය - ස්වාධීන කේත කැබැල්ලක යම් තර්කනයක් ඇතුළත් වන අතර එය ස්වාධීනව හැඳින්විය යුතු අතර ඒවා පන්තියෙන් පිටත අර්ථ දැක්වේ.

ක්‍රමය - ක්‍රමයක් යනු ස්වාධීන වස්තුවක් වන අතර එය කිසියම් වස්තුවකට යොමු වන අතර එය පන්තිය තුළ අර්ථ දැක්වේ.

ජාවාස්ක්‍රිප්ට් උදාහරණ භාවිතා කරමින් ක්‍රමයට එදිරිව ක්‍රියාකාරීත්වය පිළිබඳ පැහැදිලි කිරීමක් මෙන්න:

test(20, 50); ශ්‍රිතය නිර්වචනය කර යම් පියවරක් ක්‍රියාත්මක කිරීමට හෝ කොතැනක හෝ ගබඩා කළ හැකි / භාවිතා කළ හැකි යමක් ආපසු ලබා දීමට භාවිතා කරයි.

ඔබට කේතය නැවත භාවිතා කළ හැකිය: කේතය එක් වරක් නිර්වචනය කර එය බොහෝ වාරයක් භාවිතා කරන්න.

විවිධ ප්‍රති .ල ලබා ගැනීම සඳහා ඔබට එකම කේතය විවිධ තර්ක සමඟ බොහෝ වාරයක් භාවිතා කළ හැකිය.

var x = myFunction(4, 3);   // Function is called, return value will end up in x

function myFunction(a, b) {
    return a * b;          // Function returns the product of a and b
}

var test = something.test(); මෙහි පරීක්ෂණය () කිසියම් වස්තුවක ක්‍රමයක් විය හැකිය, නැතහොත් අභිරුචි මඟින් නිර්වචනය කරන ලද වස්තු සඳහා මූලාකෘතියක් විය හැකිය, මෙහි වැඩි විස්තරයක් ඇත:

ජාවාස්ක්‍රිප්ට් ක්‍රම යනු වස්තූන් මත කළ හැකි ක්‍රියා ය.

ජාවාස්ක්‍රිප්ට් ක්‍රමයක් යනු ශ්‍රිත අර්ථ දැක්වීමක් සහිත දේපලකි.

ජාවාස්ක්‍රිප්ට් හි නූල් සඳහා සාදන ලද දේපල / ක්‍රමය:

var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!

අභිරුචි උදාහරණය:

function person(firstName, lastName, age, eyeColor) {
    this.firstName = firstName;  
    this.lastName = lastName;
    this.age = age;
    this.eyeColor = eyeColor;
    this.changeName = function (name) {
        this.lastName = name;
    };
}

something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'

ඔබට String, Array, සඳහා ගුණාංග නිර්වචනය කළ හැකිය

String.prototype.distance = function (char) {
    var index = this.indexOf(char);

    if (index === -1) {
        console.log(char + " does not appear in " + this);
    } else {
        console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
    }
};

var something = "ThisIsSomeString"

// now use distance like this, run and check console log

something.distance("m");

සමහර යොමු කිරීම්: ජාවාස්ක්‍රිප්ට් වස්තු ක්‍රමය , කාර්යයන් , මූලාකෘති පිළිබඳ වැඩි විස්තර

ටීඑල්; ඩී.ආර්

ශ්‍රිතයක් යනු ක්‍රියාත්මක කිරීමට කේත කැබැල්ලකි.
ක්‍රමයක් යනු වස්තුවක් තුළ ඇති ශ්‍රිතයකි.

ශ්‍රිතයක උදාහරණය:

function sum(){
  console.log("sum")l
}

ක්‍රමයක උදාහරණය:

const obj = {
a:1,
b:2,
sum(){
  }
}

ඒ නිසා අපි ශ්‍රිතයක් තුළ ඇති “මෙම” මූල පදය ඇමතුමකින්, අයදුම් කිරීමෙන් හෝ බන්ධනයකින් භාවිතා නොකරන්නේ නම් එය එතරම් ප්‍රයෝජනවත් නොවන බව අප කියන්නේ ඒ නිසාය. ශ්‍රිතය ක්‍රමයට පරිවර්තනය කරයි

ඒවා බොහෝ විට එකිනෙකට හුවමාරු වේ, නමුත් ක්‍රමයක් සාමාන්‍යයෙන් පන්තියක් තුළ ඇති සබ්මැරීනයකට යොමු වන අතර ශ්‍රිතයක් සාමාන්‍යයෙන් පන්තියෙන් පිටත සබ්මැරීනයකට යොමු වේ. උදාහරණයක් ලෙස, රූබි හි:

# function
def putSqr(a)
   puts a ** 2
end


class Math2
   # method
   def putSqr(a)
      puts a ** 2
   end
end

ජාවාහි, සෑම දෙයක්ම (පැකේජ සහ ආනයන ප්‍රකාශ හැර) පන්තිය තුළ තිබිය යුතු අතර, මිනිසුන් සෑම විටම පාහේ ඒවා හඳුන්වන්නේ “ක්‍රම” ලෙසිනි.