Vad är procedurprogrammering exakt? Hur exakt skiljer det sig från OOP? Är det samma som funktionell programmering?

Wikipedia har bra förklaringar för dessa termer. Oavsett, här är sammanfattningen:

• Tvingande programmering modellerar beräkning som en sekvens av uttalanden som ändrar det förändrade tillståndet.
• Procedurell programmering är tvingande programmering som bryter ner koden i underrutiner.
• Strukturerad programmering är en mer disciplinerad metod för procedurell programmering som förbjuder godtyckliga hopp (t.ex. goto) och globala tillståndsförändringar.

• Deklarativ programmering är motsatsen till tvingande programmering – den anger vad man ska beräkna snarare än hur (t.ex. SQL, regexes).

• Funktionellt program ming modellerar beräkning som uttryck som (kan) ge värden. Funktioner är värden och kan skickas till eller returneras från andra funktioner. Mutation är avskräckt; alla variabler är oföränderliga som standard. Som ett resultat är det ”mer deklarativt än nödvändigt, eftersom det betonar vad som beräknas snarare än sekvensen av tillståndsförändringar som behövs för att uppnå det.

• Ren funktionell programmering tillåter inte mutation helt och hållet (men i motsats till populär tro finns det fortfarande mekanismer för att uppnå sida effekter).
• Total funktionell programmering dessutom förbjuder undantag och oändlig looping. (En total funktion i matematik är en funktion som returnerar ett värde för alla av dess ingångar.)

• Objektorienterad programmering betonar användning av objekt / gränssnitt för att uppnå abstraktion och modularitet.

Deras förhållanden är lite komplicerade eftersom OOP är en ganska laddad term. Du kan använda objekt på både funktionella språk och procedurspråk, men de språk som annonserar sig själva som OO är procedurella. För att förvirra problemet ytterligare:

• De flesta vet inte skillnaden mellan ett objekt och en abstrakt datatyp
• Vanliga OOP-språk nämner inte ADT: er, ger mycket dåligt stöd för dem och visar objekt som The One True Way.
• Ingen säger Abstrakt datatyp-orienterad programmering (eftersom det skulle vara en fånig sak att göra; du behöver både ADT och objekt.)

Detta får människor att tro att OOP är det enda sättet att uppnå abstraktion, och att funktionell programmering och OOP är på något sätt motsatser eller utesluter varandra. Många människor tycker också att alla funktionella språk är rena och inte tillåter mutation.

Dessutom slänger folk i allmänhet imperativt / procedurellt utbytbart, ibland kontrasterar det med OOP (antyder abstraktionslös kod, generellt C) och ibland kontrasterar det med funktionell programmering.Termen strukturerad programmering har för det mesta gått ur bruk så vitt jag kan säga (troligtvis för att de flesta vid den här tiden tar för givet att goto och globala anses vara skadliga.)

Kommentarer

• ” förbjuder hopp ” är ganska generiskt; som inkluderar om / medan / etc .. kanske ” förbjuder godtyckliga hopp ”?
• @Izkata Bra poäng, ändrats.
• Det kan vara värt att faktiskt länka till wikipedia-posterna.
• Och att ’ är anledningen till att det ’ heter Objekt ” Orienterat ” och inte endast Objekt.
• @OrangeDog Hur är det skiljer sig från en abstrakt datatyp, vilken definierar också en inkapslad uppsättning data och funktioner som kan agera på den? Dessutom kan du ha oföränderliga objekt, så i så fall, vilket tillstånd ?

Procedurell programmering är ett tillvägagångssätt för programmering som är en av grundstenarna för byggstenar för många andra språkdesigner (funktionell är inte en).

De flesta språk faller i uppsättningen ”Procedurell programmering” och det är förmodligen den mest naturliga designmetoden för de flesta (om du tänker i termer av OO, skulle jag säga att du är i minoritet).

BASIC är procedurellt.

Som andra har sagt är det en mekanism för att strukturera program på ett sekventiellt sätt.

• Först gör jag x
• För det andra gör jag
• För det tredje gör jag Z

Det kräver en mekanism för att definiera ”procedurer” – block med namngiven kod som liknar OO-metoder, som kan acceptera noll till många parametrar och valfritt returnera ett värde (som skulle då vanligtvis kallas en funktion – vilket förmodligen leder till din förvirring med funktionella språk)

Para digm dikterar inte vad saker du gör kommer att vara, eller hur sakerna skickas runt.

Det beskriver helt enkelt att programmet kommer att struktureras som en serie procedurer (eller funktioner) som fungerar i ett sekventiellt sätt. Data definieras sedan oberoende av procedurerna.

Detta skiljer sig från objektorienterad programmering, som strukturerar programmet kring datainsamlingar och metoder (inte funktioner) som verkar på den informationen.

Ett sätt att tänka på det är i termer av dataomfång.

I ett procedurmässigt språk är omfattningen ganska enkel. En variabel kan vara inom ramen för ett visst förfarande (deklareras lokalt), upp till nivån för det bästa som ringer saker (deklareras globalt), med kapslade räckvidd mellan.

I ett objektorienterat språk lägg till ett nytt räckviddssammanhang, det vill säga det objekt som för närvarande används, vilket är ortogonalt med ovanstående.

Ett annat sätt att tänka på procedur, jämfört med objektorienterat är att betrakta ett objektorienterat språk där alla metoder måste förklaras som statiska. Resultatet är ett processpråk där klasser kan användas för att gruppera procedurer tillsammans.

Procedurell programmering är definitivt inte funktionell programmering.

Procedurell programmering är när du har en modell av datorn som maskin i huvudet och du funderar på hur den ”ändrar data i minnet. Så först ställer du in A till värdet 3, sedan lägger du till 1 och lagrar det på minnesplatsen A igen (skriv över det tidigare värdet) .

Funktionell programmering skulle säga A är 3, och B är A + 1 och sedan låta datorn ta reda på hur man beräknar B. När du väl har definierat A ska det vara oföränderligt (utan förändring). Funktionell låter dig också göra saker som att skicka en funktion som en första- klassvärde (en funktion kan ta en funktion som ett argument).

Objektorienterad programmering kombinerar ofta båda, och är typ av ortogonal för båda. Du kan använda funktionell programmering och returnera ett oföränderligt objekt, och det objekt kan ha en metod som returnerar något beräknat värde, och till och med göra det lat – det är funktionell objektorienterad programmering. Du kan också ha ett objekt som representerar ett ”förråd” (abstrakt version av en databas), och du kan ”spara” saker i förvaret och ”få ut” saker igen och låta det objektet hantera alla detaljer om hur det ” Det är i princip objektorienterad procedurell programmering.

OOP är inget annat än en lite förfinad form av procedurell programmering , som åter tillhör den större familjen av tvingande programmering.Bevis på det påståendet är att många C # / Java-programmerare tenderar att ”göra något” och föredrar metoder som:

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

Så, ett program som består av en massa av ogiltiga metoder (tidigare känd som procedurer (sic!)) och kod som:

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

är perfekt procedurprogrammering.

Kommentarer

• doThisAndThat (….) innebär att en metod kommer att göra mer än en sak som i allmänhet inte är en bra praxis. Java- och C # -utvecklare följer mestadels principen om ett enda ansvar. Jag tror att din analogi är bristfällig. objectmentor.com/resources/articles/srp.pdf
• @JohnK Jag vet att det inte är någon bra praxis. Ändå en vanlig. Särskilt bland Java-utvecklare, om man kan bedöma efter vad man ser varje dag på SO.
• @JohnK Java- och C # -utvecklare följer mestadels principen om ett enda ansvar – Läpptjänst?
• Java-utvecklare följer mestadels Single Responsibility? Om det bara var sant i verkliga livet …