MODULAR PROGRAMMING: MGA KATANGIAN, HALIMBAWA, BENTAHE, APLIKASYON - TEKNOLOHIYA - 2025

Ang modular programming ay isang pamamaraan na ginagamit para sa pag-unlad ng software, kung saan ang programa ay nahahati sa maraming maliliit na bloke o autonomous na mga bahagi na tinatawag na mga module, na maaaring mapangasiwaan, lohikal at pagganap.

Ang module ay isang bloke ng mga pahayag na malulutas ang isang partikular na problema. Ang bawat module ay naglalaman ng lahat ng kinakailangan upang matupad ang sarili nitong pag-andar at maaaring mai-edit o mabago nang hindi naaapektuhan ang natitirang bahagi ng proyekto.

Halimbawa ng paglutas ng isang problema gamit ang mga module. Pinagmulan: Kayau / CC BY (https://creativecommons.org/licenses/by/3.0)

Ang ganitong paraan ng programming ay nakamit sa pamamagitan ng pagpapanatili ng isang permanenteng interface ng module na ginagamit ng iba pang mga bahagi ng software upang ma-access ang mga function ng bawat module.

Ang mga module ay nagpapataw ng mga lohikal na mga hangganan sa pagitan ng mga sangkap, pagpapabuti ng pagpapanatili. Ang mga ito ay isinama sa pamamagitan ng mga interface, na idinisenyo sa paraang upang mabawasan ang pag-asa sa pagitan ng iba't ibang mga module.

Pangunahing at pantulong na mga module

Ang isang pangunahing module at ilang pangalawang module ay kung ano ang bumubuo sa modular programming. Mula sa pangunahing module, ang mga tawag ay ginawa sa mga pag-andar ng mga pantulong na module.

Ang mga plug-in na ito ay umiiral bilang hiwalay na mga maipapatupad na file, na na-load kapag tumatakbo ang pangunahing module. Ang bawat module ay may natatanging pangalan na itinalaga sa pahayag ng PROGRAM.

Ang mga koponan sa trabaho ay maaaring bumuo ng iba't ibang mga module nang hiwalay nang hindi kinakailangang malaman ang lahat ng mga module ng system. Ang bawat isa sa mga modular application ay nauugnay sa isang numero ng bersyon upang magbigay ng kakayahang umangkop sa mga developer sa pagpapanatili ng module.

Modular na mga tampok ng programming

Modularidad

Ang isang computer ay hindi nangangailangan ng isang sumabog na bersyon ng code upang patakbuhin ito. Ito ay mga limitasyong nagbibigay-malay sa tao na nagpipilit sa iyo na magsulat ng code sa mas maliit na mga chunks.

Ang isang programa ay maaaring maglaman ng iba pang mga pag-andar at maaari ring sumangguni sa mga pag-andar na nasa iba pang mga file. Ang mga pag-andar o module na ito ay mga hanay ng mga pahayag na ginagamit upang magsagawa ng isang operasyon o makalkula ang isang halaga.

Upang mapanatili ang pagiging simple at kakayahang mabasa sa malaki at kumplikadong mga programa, ang isang maikling pangunahing pag-andar ay ginagamit kasabay ng iba pang mga pag-andar, sa halip na isang mahabang pangunahing pag-andar.

Sa pamamagitan ng paghihiwalay ng isang programa sa mga pangkat ng mga module, ang bawat module ay mas madaling maunawaan, kaya sumunod sa mga pangunahing patnubay ng nakabalangkas na programa.

Kahulugan ng pagpapaandar

Ang isang function ay binubuo ng isang pagpapahayag ng kahulugan nito na sinusundan ng mga utos at pahayag. Ang pangkalahatang anyo ng isang function ay:

Function_name (pagpapahayag ng parameter) {

mga pangungusap;

mga utos;

pagpapahayag ng pagbabalik;

}

- Ang pagpapahayag ng mga parameter ay kumakatawan sa impormasyon na ipinapasa sa pagpapaandar.

- Ang mga karagdagang variable na partikular na ginagamit ng pagpapaandar ay tinukoy sa mga pangungusap.

- Lahat ng mga pag-andar ay dapat magsama ng isang pahayag sa pagbabalik.

Saklaw ng mga variable

Ang mga variable na idineklara sa loob ng pangunahing pag-andar o sa mga function na tinukoy ng gumagamit ay tinatawag na mga lokal na variable. Ang mga ito ay may halaga kapag gumana ang pagpapaandar, ngunit ang kanilang halaga ay hindi mananatili kapag nakumpleto ang pagpapaandar.

Ang mga variable na ipinahayag na panlabas sa pangunahing programa o sa mga function na tinukoy ng gumagamit ay tinatawag na global variable. Ang mga variable na ito ay maaaring makuha mula sa anumang pag-andar na nasa loob ng programa.

Ito ay pamamaraan

Ang modular na programming ay medyo pamamaraan, dahil kumpleto itong nakatuon sa pagsulat ng code para sa mga pag-andar, nang hindi isinasaalang-alang ang data.

Modular na mga halimbawa ng programming

Modularidad sa totoong buhay

Ipagpalagay na ang isang bahay na may kuryente, na may ilang mga saksakan sa dingding. Pinapayagan ka ng sistemang ito na mag-plug sa iba't ibang mga de-koryenteng aparato, halimbawa, microwave, washing machine, dryer, atbp.

Ang mga aparatong ito ay idinisenyo upang maisagawa ang kanilang tukoy na gawain kapag naka-plug in at naka-on, anuman ang lokasyon nila.

Ang mga module ng isang application ay dapat sundin ang parehong pilosopiya. Nangangahulugan ito na kailangan lamang nilang maisagawa ang kanilang tukoy na gawain kahit na anong bahagi ng application na kanilang naroroon, o kahit anong application na konektado sila.

Gayundin, tulad ng isang de-koryenteng aparato ay madaling mai-unplugged mula sa outlet, dapat na idinisenyo ang isang module sa paraang madali itong maalis sa isang aplikasyon.

Tulad ng pag-alis ng isang de-koryenteng aparato ay hindi nakakaapekto sa pag-andar ng iba pang mga konektadong aparato, ang pag-alis ng mga module mula sa isang aplikasyon ay hindi dapat makaapekto sa pag-andar ng iba pang mga module ng application na iyon.

Mga Pag-andar sa Java

Sa mga module ng Java ay nakasulat bilang mga independiyenteng pag-andar. Halimbawa, maaaring magkaroon ka ng isang function o code block upang makalkula ang GPA ng isang mag-aaral batay sa kanilang mga marka sa lahat ng mga kurso na kanilang nakuha.

Ang function ay kailangang makuha ang listahan ng mga marka bilang input at pagkatapos ay ibalik ang kinakalkula na average na grado:

Ang pagpapaandar na ito ay tinatawag na CalculateAverageNote. Tumatanggap ito bilang input ng isang listahan ng mga tala, gamit ang isang hanay ng mga dobleng uri ng data, at ibabalik ang kinakalkula na average.

Sa pagpapaandar, ang lokal na variable na kabuuan ay sinimulan sa zero at pagkatapos, gamit ang isang para sa loop, ang lahat ng mga kwalipikasyon ay idinagdag sa kabuuan. Sa wakas, ang kabuuan na nakuha ay nahahati sa bilang ng mga tala, ibabalik ang nagresultang halaga.

Kung ang input matrix ay mayroong mga tala 3.5, 3.0 at 4.0, pagkatapos idagdag ang mga ito, magkakaroon ito ng halaga ng 10.5 at pagkatapos ay hatiin ito ng 3, dahil may tatlong tala. Ang function ay ibabalik ang halaga 3.5.

Kalamangan

Programa ng independiyenteng programa

Ang maraming mga programmer ay maaaring gumana sa parehong proyekto kung nahahati ito sa mga module. Ang iba't ibang mga programmer ay maaaring nakapag-iisa na magdisenyo ng iba't ibang mga module ng programa, na kinakailangan para sa isang malaki at kumplikadong programa.

Mahusay na pag-unlad ng programa

Ang mga programa ay maaaring mabuo nang mas mabilis, dahil maliit, nakatayo na mga module ay madaling maunawaan, magdisenyo, at pagsubok kaysa sa malalaking mga programa.

Ang programmer ay maaaring magbigay ng kinakailangang input at i-verify na ang module ay tama sa pamamagitan ng pagsusuri sa output nito.

Maramihang paggamit ng mga module

Ang code na nakasulat para sa isang programa ay madalas na kapaki-pakinabang sa iba. Pinapayagan ng modular na programming na ang mga seksyon na ito ay mai-save para magamit sa hinaharap. Dahil ang code ay mai-relocatable, ang nai-save na mga module ay maaaring maiugnay sa anumang iba pang programa na nakakatugon sa mga kinakailangan sa input at output.

Sa pamamagitan ng monolithic programming, ang mga naturang seksyon ng code ay naka-embed sa loob ng programa at hindi magagamit para magamit ng iba pang mga programa.

Dali ng pag-debug at pagbabago

Ang isang module ay mas maliit kaysa sa isang buong programa, kaya mas madaling subukan. Ang bawat module ay maaaring isulat at subukan nang hiwalay mula sa natitirang programa. Matapos masuri ang isang module, maaari itong magamit sa isang bagong programa nang hindi na muling subukan ito.

Kapag dapat baguhin ang isang programa, pinapagaan ng modular na programa ang trabaho. Ang mga bago o debugged module ay maaaring maiugnay sa isang umiiral na programa nang hindi binabago ang natitirang programa.

Mga Kakulangan

Labis na object-oriented na istraktura

Ang program na ito ay gumagamit ng mga interface, na kung saan ay isang medyo mabisang ideya. Upang samantalahin iyon, ang ilang mga frameworks ay may isang buong hanay ng mga mapagpapalit na mga klase. Halimbawa, upang mahawakan ang pagtitiyaga, maaaring mayroong maraming mga klase na nagpapatupad ng isang interface ng pagpupursige.

Gayunpaman, ang mga integrated environment environment (IDE) ay nalilito tungkol dito. Halimbawa, maaari mong subukang hanapin ang mapagkukunan ng isang pamamaraan, at hindi malalaman ng IDE kung aling pamamaraan ang nais mong makita, sa gayon ipinapakita ang isang mahabang listahan ng mga file kung saan umiiral ang isang pamamaraan na may pangalang iyon.

Napakaliit ng mga module

Mayroong maraming mga module na naglalaman lamang ng isang napakaliit na pag-andar. Ang bawat module ay nangangailangan ng karagdagang oras sa pag-parse at pagproseso, bilang karagdagan sa heading nito sa code.

Samakatuwid, ang paggamit ng maraming maliliit na module ay magdagdag ng isang overhead sa sistema ng compilation, pagtaas ng laki ng pakete.

Mabulok nang walang kadahilanan

Ang ilang mga code ay halos hindi nagbabago. Sa mga pagkakataong ito ay hindi maaaring magkaroon ng maraming kahulugan upang subukang gawing mas malinis o may abstract na lohika, kung gumamit lamang ito ay maayos.

Mayroong mga code na hindi masyadong maganda, ngunit hindi pa sila nagbago nang maraming mga nakaraang taon. Walang dahilan upang mabulok ang code na hindi kailanman nagbago at gumagana nang maayos sa mga module.

Aplikasyon

Ang modular na programa ay isang konsepto lamang. Ang kasanayan nito ay maaaring mailapat sa anumang wika sa programming, lalo na sa isang pamamaraan ng kalakal, na may isang hiwalay na pinagsama-samang programa.

Ang mga bahagi ng mga aklatan na itinayo mula sa magkahiwalay na pinagsama-samang mga module ay maaaring pagsamahin sa isang set gamit ang isang tool sa programming na tinatawag na isang linker.

Ang mga pangalan ng mga pag-andar sa iba't ibang mga module ay dapat na natatangi upang mapadali ang kanilang pag-access kung sakaling ang mga pag-andar na ginamit ng pangunahing module ay dapat na nai-export.

Kabilang sa mga programming language na sumusuporta sa konsepto ng modular programming ay ang C, Ada, PL / I, Erlang, Pascal, Algol, COBOL, RPG, Haskell, Python, HyperTalk, IBM / 360 Assembler, MATLAB, Ruby, IBM RPG, Ang SmallTalk, Morpho, Java (mga pakete ay itinuturing na mga module), Perl, atbp.

C wika

Ang modular na programa ay maaaring mailapat sa wikang C dahil ginagawang posible na malunasan ang isang malaking kahirapan sa pamamagitan ng paghihiwalay nito sa maraming mga module.

Ang bawat isa sa mga module na ito ay malulutas ang isang partikular na problema, habang ang pangunahing programa, na kung saan ay ang hanay ng mga nasabing pamamaraan, malulutas ang problema sa kabuuan.

Ang bawat pag-andar na tinukoy sa C ay sa pamamagitan ng default na mai-access sa buong mundo. Magagawa ito sa pamamagitan ng pagsasama ng isang file ng header, kung saan tinukoy ang pagpapatupad ng pag-andar.

Bilang isang halimbawa, nais naming magpahayag ng isang uri ng data ng salansan at din na ang pagpapatupad at ang istraktura ng data ay nakatago mula sa mga gumagamit.

Maaari itong gawin sa pamamagitan ng unang pagtukoy ng isang pampublikong file na tinatawag na stack.h, na naglalaman ng pangkaraniwang data na may uri ng stack ng data at ang mga pag-andar na suportado ng uri ng stack ng data.

isinalansan.h:

panlabas na stack_var1;

panlabas int stack_do_something (walang bisa);

Ngayon ay maaari kang lumikha ng isang file na tinatawag na stack.c na naglalaman ng pagpapatupad ng uri ng stack ng data:

Mga Sanggunian

1. CIO Wiki (2019). Modular na Programming. Kinuha mula sa: cio-wiki.org.
2. Mga Kahulugan ng IT (2020). Modular na Programming. Kinuha mula sa: defit.org.
3. Bagong Mexico Tech (2020). Modular na programa na may mga pag-andar. Kinuha mula sa: ee.nmt.edu.
4. Christian Maioli (2020). 3 mga pamamaraan ng malikhaing para sa pagsusulat ng modular code. Tech Beacon. Kinuha mula sa: techbeacon.com.
5. Mga Geeks para sa Geeks (2020). Modular Diskarte sa Programming. Kinuha mula sa: geeksforgeeks.org.
6. Pag-aaral (2020). Modular Programming: Kahulugan at Application sa Java. Kinuha mula sa: study.com.