Programming Paradigms

Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms.

State eller stateful

In information technology and computer science, a program is described as stateful if it is designed to remember preceding events or user interactions; the remembered information is called the state of the system.

Vi måste nästan alltid veta vad vårt föregående state är: har knappen blivit tryckt på eller inte?

Olika programmeringsparadigm sköter detta på olika sätt

JavaScript är multi-paradigm: Objektorienterat/imperativt/deklarativt/funktionellt

De vi använt mest

• Proceduell: gruppering i funktioner, mer steg för steg
• Objektorienterad: gruppering i klasser och objekt, oftast grupperas tillståndet (state) tillsammans med funktionerna som hör till detta state.

Båda dessa tillåter sideffekter och baseras ofta på att man kallar på funktionerna i en viss ordning

Funktionell programmering

• Rena funktioner (pure functions)
• Undvik delat tillstånd (shared state)
• Undvik sidoeffekter

Funktionell är som en undergrupp av deklarativ programmering

Pure functions

• Given the same inputs, always returns the same output, and
• Has no side effects

Vissa funktioner förlitar sig på att annan information utanför funktionens scope ska vara tillgänglig, det gör inte en ren funktion. En ren funktion ändrar inte heller någonting utanför det egna scopet.

Exempel på funktioner som i sin grund är funktionella

• map - går igenom och gör något med varje värde i en array
• filter - filtererar en array
• reduce - reducerar en array (summera oftast)

Alla är exempel på såkallade Higher Order Functions, dessa funktioner returnerar alltid en ny array och manipulerar inte den gamla arrayen

En Higher Order Function är en funktion som tar en annan funktion som ett argument

Funktionen som skickas in som argument bestämmer vad den kallade funktionen ska göra.

Imperativt dubbla varje nummer i en array

const numbers = [5,6,7];
const doubleNumbers = [];
for(let i = 0; i < numbers.length; i++){
  doubleNumbers[i] = numbers[i] * 2;
}

Deklarativt dubbla varje nummer i en array

const numbers = [5,6,7];
const doubleNumbers = numbers.map((number) => number * 2);

Imperativt ta bort ett värde

const numbers = [5,6,7];
const filteredNumbers = [];
for(let i = 0; i < numbers.length; i++){
  if(numbers[i] !== 6){
    filteredNumbers.push(numbers[i]);
  }
}

Deklarativt ta bort ett värde

const numbers = [5,6,7];
const filteredNumbers = numbers.filter((numbers) => number !== 6);

Imperativt summera alla värden i en array

const numbers = [5,6,7];
const sum = 0;
for(let i = 0; i < numbers.length; i++){
  sum = sum + numbers[i];
}

Deklarativt summera alla värden

const numbers = [5,6,7];
const sum = numbers.reduce((total, nextValue) => total + nextValue, 0);

const mapped = thing.map(function(currentValue, index, array){
  return currentValue;
})

filter och map har hela tiden koll på vilket värde de använder för stunden samt vilket index

const reduced = thing.reduce(function(accumulator, currentValue, index , array){
  return currentValue;
})

reduce har koll på värdet, index samt den nuvarande summerade värdet.

const numbers = [5,6,7];
const filteredNumbers = numbers.filter((numbers) => number !== 6);

const numbers = [5,6,7];
const filteredNumbers = numbers.filter(function(number){
  return number !== 6;
});

return blir if-statement, det nuvarande värdet returneras och lagras om if-statement stämmer.

Eftersom JavaScript är ett multiparadigm-språk så behöver vi och kan inte strikt förhålla sig till ett paradigm. Vi kan använda oss av den funktionalitet som passar bäst för scenariot vi har.

Föredra rena funktioner, kan du undvika att skapa sideffekter eller mutera ett delat tillstånd, undvik det, sen går det inte alltid.

Gruppera kod, först i funktioner, sen i moduler eller klasser (module/class)