Wat is procedureel programmeren precies? Hoe verschilt het precies van OOP? Is het hetzelfde als functioneel programmeren?

Wikipedia heeft goede verklaringen voor deze termen. Hoe dan ook, hier is de samenvatting:

• Noodzakelijk programmeren modelleert de berekening als een reeks statements die de veranderlijke toestand veranderen.
• Procedureel programmeren is een noodzakelijke programmering die de code opsplitst in subroutines.
• Gestructureerd programmeren is een meer gedisciplineerde benadering van procedureel programmeren die willekeurige sprongen verbiedt (bijv. goto) en globale statuswijzigingen.

• Declaratief programmeren is het tegenovergestelde van imperatief programmeren – het specificeert wat moet worden berekend in plaats van hoe (bijv. SQL, regexes).

• Functioneel programma ming modelleert berekening als uitdrukkingen die (kunnen) waarden opleveren. Functies zijn waarden en kunnen worden doorgegeven aan of geretourneerd door andere functies. Mutatie wordt ontmoedigd; alle variabelen zijn standaard onveranderlijk. Dientengevolge is het “meer declaratief dan noodzakelijk, aangezien het de nadruk legt op wat wordt berekend in plaats van op de volgorde van toestandsveranderingen die nodig zijn om dit te bereiken.

• Puur functionele programmering staat mutatie helemaal niet toe (hoewel in tegenstelling tot wat vaak wordt gedacht, nog steeds mechanismen heeft om effecten).
• Totale functionele programmering verbiedt bovendien uitzonderingen en oneindige herhalingen. (Een totale functie in de wiskunde is een functie die een waarde retourneert voor alle invoer.)

• Objectgeoriënteerd programmeren benadrukt de gebruik van objecten / interfaces om abstractie en modulariteit te bereiken.

Hun relaties zijn een beetje gecompliceerd omdat OOP een behoorlijk beladen term. U kunt objecten in zowel functionele talen als proceduretalen gebruiken, maar de talen die zichzelf adverteren als OO zijn procedureel. Om het probleem verder te verwarren:

• De meeste mensen “weten niet het verschil tussen een object en een abstract gegevenstype
• Mainstream OOP-talen maken geen melding van ADTs, bieden er zeer slechte ondersteuning voor, en noemen objecten als The One True Way.
• Niemand zegt Abstract Data Type-Oriented Programming (omdat het “dom zou zijn om te doen; je hebt zowel ADTs als objecten nodig.)

Dit zorgt ervoor dat mensen denken dat OOP de enige manier is om abstractie te bereiken, en dat functionele programmering en OOP zijn op de een of andere manier tegengesteld of sluiten elkaar uit. Veel mensen denken ook dat alle functionele talen puur zijn en mutatie niet toestaan.

Bovendien gooien mensen over het algemeen imperatief / procedureel door elkaar heen, soms in contrast met OOP (impliceert abstractieloze code, meestal C) en soms in tegenstelling tot functioneel programmeren.De term gestructureerd programmeren is voor zover ik kan nagaan grotendeels buiten gebruik geraakt (waarschijnlijk omdat de meeste mensen op dit moment als vanzelfsprekend beschouwen dat goto en globals als schadelijk worden beschouwd.)

Opmerkingen

• ” verbiedt sprongen ” is nogal algemeen; dat omvat if / while / etc .. misschien verbiedt ” willekeurige sprongen “?
• @Izkata Goed punt, gewijzigd.
• Het zou de moeite waard kunnen zijn om daadwerkelijk naar de Wikipedia-vermeldingen te linken.
• En dat ‘ is waarom het ‘ s genaamd Object ” Georiënteerd ” en niet alleen Object.
• @OrangeDog Hoe is dat anders dan een abstract gegevenstype, dat ook definieert een ingekapselde set gegevens en functies die erop kunnen reageren? Bovendien kun je onveranderlijke objecten hebben, dus in dat geval welke staat ?

Procedureel programmeren is een benadering van programmeren die een van de basisbouwstenen is voor veel andere taalontwerpen (functioneel niet zijnde één).

De meeste talen vallen onder de reeks “Procedureel programmeren” en het is waarschijnlijk de meest natuurlijke ontwerpbenadering voor de meeste mensen (als je denkt in termen van OO, dan “zou ik zeggen dat je in een minderheid bent).

BASIC is procedureel.

Zoals anderen al hebben gezegd, is het een mechanisme om programmas op een sequentiële manier te structureren.

• Ten eerste doe ik x
• Ten tweede doe ik y
• Ten derde doe ik Z

Het vereist een mechanisme voor het definiëren van “procedures” – blokken met benoemde code vergelijkbaar met OO-methoden, die nul tot veel parameters kunnen accepteren en optioneel een waarde retourneren (die zou dan over het algemeen een functie worden genoemd – waarschijnlijk leidend tot uw verwarring met functionele talen)

De para digm dicteert niet wat de dingen die u doet zullen zijn, of de manier waarop de dingen worden doorgegeven.

Het beschrijft eenvoudig dat het programma zal worden gestructureerd als een reeks procedures (of functies) die werken in een opeenvolgende manier. De gegevens worden dan onafhankelijk van de procedures gedefinieerd.

Dit verschilt van objectgeoriënteerd programmeren, dat het programma structureert rond verzamelingen gegevens en methoden (geen functies) die op die gegevens werken.

Een manier om erover na te denken is in termen van gegevensbereik.

In een procedurele taal is scoping vrij eenvoudig. Een variabele kan binnen het bereik van een bepaalde procedure vallen (lokaal gedeclareerd), tot het niveau van het hoogste niveau dat dingen aanroept (globaal gedeclareerd), met geneste scopes ertussen.

In een objectgeoriënteerde taal voeg een nieuwe scopingcontext toe, namelijk die van het object dat momenteel in gebruik is, die orthogonaal is ten opzichte van het bovenstaande.

Een andere manier om procedureel te denken, in vergelijking met objectgeoriënteerd, is om een objectgeoriënteerde taal te beschouwen waarbij alle methoden moeten worden gedeclareerd als statisch. Het resultaat is een proceduretaal waarin klassen kunnen worden gebruikt om procedures te groeperen.

Procedureel programmeren is beslist geen functioneel programmeren.

Procedureel programmeren is wanneer je een model van de computer als een machine in je hoofd hebt en je nadenkt over hoe het s wijzigen van gegevens in het geheugen. Dus stel je eerst A in op de waarde 3, daarna tel je er 1 op en sla je die weer op in geheugenlocatie A (waarbij je de vorige waarde overschrijft) .

Functioneel programmeren zou zijn: A is 3, en B is A + 1, en laat de computer vervolgens uitzoeken hoe B moet worden berekend. Als je eenmaal “A hebt gedefinieerd, zou moeten zijn onveranderlijk (niet veranderend). Functioneel stelt je ook in staat om dingen te doen zoals het doorgeven van een functie als eerste- class waarde (een functie kan een functie als argument aannemen).

Objectgeoriënteerd programmeren combineert vaak beide, en is min of meer orthogonaal op beide. U kunt functioneel programmeren gebruiken en een onveranderlijk object retourneren, en dat object kan een methode hebben die een bepaalde berekende waarde retourneert, en het zelfs lui doen – dat is functionele objectgeoriënteerde programmering. Je kunt ook een object hebben dat een “repository” (abstracte versie van een database) vertegenwoordigt, en je kunt dingen in de repository “opslaan” en dingen er weer uit halen, en dat object alle details laten afhandelen over hoe dat ” klaar. Dat is in wezen objectgeoriënteerd procedureel programmeren.

OOP is niets dan een beetje verfijnde vorm van procedureel programmeren. , die weer tot de grotere familie van imperatieve programmering behoort.Het bewijs van die bewering is dat veel C # / Java-programmeurs de neiging hebben om “iets te doen” en de voorkeur geven aan methoden zoals:

void doThisAndThat(....) { ... do something ... } 

Dus een programma dat uit een hoop van void-methoden (voorheen bekend als procedures (sic!)) en code zoals:

doThis(); if (state is that) doSomethingElse(); doThat(); 

is perfect procedureel programmeren.

Opmerkingen

• doThisAndThat (….) impliceert dat een methode meer dan één ding zal doen dat in het algemeen niet een goede gewoonte is. Java- en C # -ontwikkelaars houden zich meestal aan het Single Responsibility Principle. Ik denk dat uw analogie niet klopt. objectmentor.com/resources/articles/srp.pdf
• @JohnK Ik weet dat het geen goede gewoonte is. Maar een veel voorkomende. Vooral onder Java-ontwikkelaars, als men kan beoordelen op wat men elke dag op SO ziet.
• @JohnK Java- en C # -ontwikkelaars houden zich meestal aan het Single Responsibility Principle – Lip-service?
• Java-ontwikkelaars houden zich meestal aan de Single Responsibility? Was dat maar waar in het echte leven …