MODULÄR PROGRAMMERING: EGENSKAPER, EXEMPEL, FÖRDELAR, APPLIKATIONER - TEKNOLOGI - 2025

Den modulära programmeringen är en teknik som används för mjukvaruutveckling, där programmet är uppdelat i många små block eller autonoma komponenter som kallas moduler, som är hanterbara, logiska och funktionella.

Modulen är ett block med uttalanden som löser ett visst problem. Varje modul innehåller allt som krävs för att uppfylla sin egen funktionalitet och kan redigeras eller modifieras utan att det påverkar resten av projektet.

Exempel på att lösa ett problem med hjälp av moduler. Källa: Kayau / CC BY (https://creativecommons.org/licenses/by/3.0)

Detta sätt att programmera uppnås genom att upprätthålla ett permanent modulgränssnitt som används av de andra programvarukomponenterna för att få åtkomst till funktionerna i varje modul.

Moduler sätter logiska gränser mellan komponenter, vilket förbättrar underhållsförmågan. De är integrerade genom gränssnitt, som är utformade på ett sådant sätt att de minimerar beroendet mellan de olika modulerna.

Huvud- och hjälpmoduler

En huvudmodul och flera sekundära moduler utgör den modulära programmeringen. Från huvudmodulen ringer man till hjälpmodulernas funktioner.

Dessa plug-ins finns som separata körbara filer som laddas när huvudmodulen körs. Varje modul har ett unikt namn tilldelat i PROGRAM-uttalandet.

Arbetsgrupperna kan utveckla olika moduler separat utan att behöva känna till alla moduler i systemet. Var och en av de modulära applikationerna är associerade med ett versionsnummer för att ge utvecklarna flexibilitet vid underhåll av modulen.

Modulära programmeringsfunktioner

modularitet

En dator behöver inte en exploderad version av koden för att köra den. Det är mänskliga kognitiva begränsningar som tvingar dig att skriva kod i mindre bitar.

Ett program kan innehålla andra funktioner och kan också hänvisa till funktioner som finns i andra filer. Dessa funktioner eller moduler är uppsättningar uttalanden som används för att utföra en operation eller beräkna ett värde.

För att upprätthålla enkelhet och läsbarhet i stora och komplexa program används en kort huvudfunktion tillsammans med andra funktioner, snarare än en lång huvudfunktion.

Genom att dela ett program i grupper av moduler kommer varje modul att vara lättare att förstå och därmed följa de grundläggande riktlinjerna för strukturerad programmering.

Funktionsdefinition

En funktion består av en deklaration av dess definition följt av kommandon och uttalanden. Den allmänna formen för en funktion är:

Funktionsnamn (parameterdeklaration) {

meningar;

kommandon;

återvändande uttryck;

}

- Deklarationen av parametrarna representerar den information som skickas till funktionen.

- Ytterligare variabler som används specifikt av funktionen definieras i meningarna.

- Alla funktioner måste innehålla ett returrätt.

Variabelns omfattning

Variabler som deklareras inom huvudfunktionen eller i användardefinierade funktioner kallas lokala variabler. Dessa har ett värde när funktionen körs, men deras värde bevaras inte när funktionen är klar.

Variabler som deklareras externt till huvudprogrammet eller användardefinierade funktioner kallas globala variabler. Dessa variabler kan tas från alla funktioner som finns i programmet.

Det är processuellt

Modulär programmering är ganska procedurell, eftersom den är helt inriktad på att skriva kod för funktioner utan att ta hänsyn till uppgifterna.

Modulära programmeringsexempel

Modularitet i verkliga livet

Anta att ett hus har el med flera uttag på väggarna. Detta system låter dig ansluta olika elektriska apparater, till exempel mikrovågsugn, tvättmaskin, torktumlare etc.

Dessa enheter är utformade för att utföra sin specifika uppgift när de är anslutna och påslagen, oavsett var de befinner sig.

Modulerna i en applikation måste följa samma filosofi. Det betyder att de bara måste utföra sin specifika uppgift oavsett vilken del av applikationen de är i, eller till och med vilken applikation de är anslutna till.

Precis som en elektrisk enhet lätt kan kopplas ur kontakten måste en modul vara utformad på ett sådant sätt att den enkelt kan tas bort från en applikation.

Precis som att borttagning av en elektrisk enhet inte påverkar funktionaliteten för de andra anslutna enheterna, bör borttagning av moduler från en applikation inte påverka funktionaliteten för de andra modulerna i den applikationen.

Funktioner i Java

I Java skrivs moduler som oberoende funktioner. Till exempel kan du ha en funktion eller kodblock för att beräkna en students GPA baserat på deras betyg i alla kurser de har tagit.

Funktionen måste få listan över betyg som input och sedan returnera det beräknade betygsmedlet:

Denna funktion kallas CalculAverageNote. Den mottar som inmatning en lista med anteckningar, använder en matris med datatypen dubbel och returnerar det beräknade genomsnittet.

I funktionen initialiseras den lokala variabla summan till noll och sedan läggs alla kvalifikationer till med summan med en for-loop. Slutligen delas den erhållna summan med antalet sedlar, vilket ger det resulterande värdet.

Om ingångsmatrisen hade anteckningarna 3.5, 3.0 och 4.0, efter att ha lagt till dem, skulle den ha summan värdet 10,5 och sedan skulle den delas med 3, eftersom det finns tre toner. Funktionen returnerar värdet 3,5.

Fördel

Oberoende projektprogrammering

Flera programmerare kan arbeta på samma projekt om det är uppdelat i moduler. Olika programmerare kan självständigt utforma olika programmoduler, vilket krävs för ett stort och komplext program.

Effektiv programutveckling

Program kan utvecklas snabbare eftersom små, fristående moduler är lättare att förstå, designa och testa än stora program.

Programmeraren kan tillhandahålla nödvändig inmatning och verifiera att modulen är korrekt genom att undersöka dess utgång.

Flera användning av moduler

Koder skrivna för ett program är ofta användbara i andra. Modulär programmering gör att dessa avsnitt kan sparas för framtida användning. Eftersom koden kan flyttas kan de sparade modulerna kopplas till alla andra program som uppfyller ingångs- och utgångskraven.

Med monolitisk programmering är sådana kodavsnitt inbäddade i programmet och är inte tillgängliga för användning av andra program.

Lätt att felsöka och modifiera

En modul är mindre än ett helt program, så det är lättare att testa. Varje modul kan skrivas och testas separat från resten av programmet. Efter att en modul har testats kan den användas i ett nytt program utan att behöva testa den igen.

När ett program måste modifieras, förenklar modulär programmering jobbet. Nya eller felsökta moduler kan kopplas till ett befintligt program utan att ändra resten av programmet.

nackdelar

Över objektorienterad struktur

Denna programmering använder gränssnitt, vilket är en ganska effektiv idé. För att dra nytta av detta kommer vissa ramverk med en komplett uppsättning utbytbara klasser. För att hantera persistens kan det till exempel finnas flera klasser som implementerar ett persistensgränssnitt.

Integrerade utvecklingsmiljöer (IDE) blir dock förvirrade över detta. Till exempel kan du försöka hitta källan till en metod, och IDE vet inte vilken metod du vill se, vilket visar en lång lista med filer där en metod med det namnet finns.

Moduler för små

Det finns många moduler som bara innehåller en mycket liten funktion. Varje modul kräver ytterligare analys och behandlingstid utöver rubriken i kod.

Därför kommer att använda många små moduler lägga till en omkostnad till kompileringssystemet, vilket ökar paketets storlek.

Sönderdelas utan anledning

Vissa koder förändras nästan aldrig. I dessa fall kanske det inte är så vettigt att försöka få det att se renare ut eller med abstrakt logik, om det bara fungerar bra.

Det finns koder som inte ser för vackra ut, men ändå har de inte förändrats mycket de senaste åren. Det finns ingen anledning att sönderdela kod som aldrig har ändrats och som redan fungerar bra i moduler.

tillämpningar

Modulär programmering är bara ett koncept. Dess praxis kan tillämpas på vilket som helst programmeringsspråk, särskilt de som är processuella, som har ett separat sammanställt program.

Komponentbibliotek byggda från separat kompilerade moduler kan kombineras till en uppsättning med hjälp av ett programmeringsverktyg som kallas en länkare.

Namnen på funktionerna i de olika modulerna måste vara unika för att underlätta deras åtkomst om de funktioner som används av huvudmodulen måste exporteras.

Bland de programmeringsspråk som stöder konceptet för modulär programmering är C, Ada, PL / I, Erlang, Pascal, Algol, COBOL, RPG, Haskell, Python, HyperTalk, IBM / 360 Assembler, MATLAB, Ruby, IBM RPG, SmallTalk, Morpho, Java (paket betraktas som moduler), Perl, etc.

C-språk

Modulär programmering kan tillämpas på C-språk eftersom det gör det möjligt att avhjälpa en stor svårighet genom att dela upp den i flera moduler.

Var och en av dessa moduler löser ett visst problem, medan huvudprogrammet, som är uppsättningen av sådana procedurer, löser problemet som helhet.

Varje funktion som definieras i C är som standard tillgänglig globalt. Detta kan göras genom att inkludera en rubrikfil, där implementeringen av funktionen definieras.

Som exempel vill vi förklara en stapeldatatyp och att implementeringen och datastrukturen är dold för användare.

Detta kan göras genom att först definiera en offentlig fil som heter stack.h, som kommer att innehålla generiska data med stapeldatatypen och de funktioner som stöds av stapeldatatypen.

stack.h:

extern stack_var1;

extern int stack_do_something (tom);

Nu kan du skapa en fil som heter stack.c som innehåller implementeringen av stackdatatypen:

referenser

1. CIO Wiki (2019). Modulär programmering. Hämtad från: cio-wiki.org.
2. IT-definitioner (2020). Modulär programmering. Hämtad från: defit.org.
3. New Mexico Tech (2020). Modulär programmering med funktioner. Hämtad från: ee.nmt.edu.
4. Christian Maioli (2020). 3 kreativa tekniker för att skriva modulkod. Tech Beacon. Hämtad från: techbeacon.com.
5. Geeks for Geeks (2020). Modulär strategi i programmering. Hämtad från: geeksforgeeks.org.
6. Studie (2020). Modulär programmering: Definition och applikation i Java. Hämtad från: study.com.