Skip to content

Latest commit

 

History

History
330 lines (269 loc) · 19 KB

clase37.md

File metadata and controls

330 lines (269 loc) · 19 KB
Raw

shieldsIO shieldsIO shieldsIO

WideImg

Máster en Programación FullStack con JavaScript y Node.js

JS, Node.js, Frontend, Backend, Firebase, Express, Patrones, HTML5_APIs, Asincronía, Websockets, Testing

Clase 37

Programación Funcional

img

En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en el uso de funciones matemáticas, en contraste con la programación imperativa, que enfatiza los cambios de estado mediante la mutación de variables.1​ La programación funcional tiene sus raíces en el cálculo lambda, un sistema formal desarrollado en los años 1930 para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda. Wikipedia

/* Objetivo: Reducir a una dimension, filtrar, modificar, ordenar...
- Punto de partida: [[5,8], [3], [4,2,6,1], [7,9]];
- REDUCIR a una dimension
- FILTRAR los < 5
- MAPEAR los elementos * 10
- ORDENAR de mayor a menor
- Resultado Final: [40,30,20,10]
*/

const matrix = [[5,8], [3], [4,2,6,1], [7,9]];
const lista = matrix;
		.reduce((a,b) => a.concat(b))
		.filter(item => item < 5)
		.map(item => item * 10)
		.sort((a,b) => b - a);

console.log("lista:", lista);

Un universo funcional...

img

Lenguajes que lo implementan

Conceptos básicos y jerga

Ventajas

  • El código es más conciso y expresivo
  • El estado sea inmutable, evita muchos errores (sin efectos colaterales)
  • Ideado para sistemas concurrentes (paralelos)
  • Entrada y salida; Las funciones reciben parámetros y devuelven un resultado.
  • Las funciones puras son muy previsibles y testeables
  • Código infinitamente más expresivo
  • Proceso de depuración simplificado
  • Fomenta mucho la descomposición de las tareas complejas
  • Hacemos uso de composiciones partiendo de fragmentos pequeños y especializados
  • Métodos encadenados, tuplas y currificación

Desventajas

  • Falta soporte nativo (tuplas, curry, etc...)
  • Es un paradigma menos extendido
  • Propensión a los errores, ya que JS no es estrcito con el pardaigma funcional
  • El tipado debil puede ser preocupante
  • Se acerca mucho a las matemáticas
  • Gestión de recursos
  • Necesidad de realizar una gran cantidad de abstracciones ad hoc

Recursos Clave

Más Recursos

Programación funcional en JavaScript: ¡Manos a la obra!

img

La Programación Funcional se refiere a la evaluación declarativa de funciones puras para crear programas inmutables y así evitar efectos secundarios que son observados externamente. El abismo de null

Programación declarativa

  • Nos centramos en describir lo que hacer
  • Evitamos especificar el flujo y los cambios de estado
  • Sistema de cajas negras
// Imperativa (COMO hacerlo)
var lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (let i = 0; i < lista.length; i++) {
    lista[i] = lista[i]*lista[i];
}
console.log("Lista:", lista) // [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

// Declarativa (QUE hacer)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(num => num*num);
// [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Funciones puras (Pure Functions)

  • Mantine las modificaciones en su scope
  • Solo toma los argumentos como entrada de información
  • No modifica el contexto externo, por lo que se retorna la información directamente
  • Transparencia referencial
  • Inmutabilidad
// Función Impura
let numero = 1;
const incremento = () => numero += 1;
incremento(); // 2

//Función Pura
const incremento = n => n + 1;
incremento(1); // 2
// Función Impura
window.nombre = 'Ulises'
const saludos = () => `Hola, ${window.nombre}`
saludos() // 'Hola, Ulises'

//Función Pura
const saludos = (nombre) => `Hola, ${nombre}`
saludos('Ulises') // 'Hola, Ulises'

⚠️ Casos especiales:

  • modificar el valor de un argumento
  • manipulación del DOM, BOM, Cookies, etc...
  • Excepciones y gestión de errores
  • APIs del navegador

Funciones de Orden Superior (Higher-order functions - HOF)

  • Funcion que toma una funcion como argumento
  • La función puede o no retornar una funcion
const sumador = (x, y) => x + y;
const calcular = (fn, x, y) => fn(x, y);
calcular(sumador, 1, 2); // 3

// Filtrado (Filter)
let coches = [
    {id: 'X0001', kilometros: 60000},
    {id: 'X0002', kilometros: 40000},
    {id: 'X0003', kilometros: 90000}
];
const estaViejo = coche => coche.kilometros >= 60000;
coches.filter(estaViejo);
// [{id: "X0001", kilometros: 60000},{id: "X0003", kilometros: 90000}]

Recursividad (Recursion)

  • Evitaremos el uso de bucles
  • Utilizaremos funciones que se llaman a si mismas para generar una estructura similar al bucle
const cuentaAtras = numero => {
  console.log(numero)
  numero < 1 ? numero : cuentaAtras(numero - 1)
}

cuentaAtras(5);


const factorial = (num) => {
  return num <= 0 ? 1 : num * factorial(num - 1)
}

factorial(5); //120

Programación funcional en JavaScript: Cosas importantes...

Composición funcional (Compose)

  • Juntamos dos funciones para retornar una función nueva
const compositor = (f,g) => x => f(g(x));
const convMayusculas = x => x.toUpperCase();
const contador = x => `${x} [${x.length}]`;
const exclamar = x => `${x}!!!`

const textoContado = compositor(contador, convMayusculas);
const textoContadoExclamado = compositor(exclamar, compositor(contador, convMayusculas));
const textoExclamadoContado = compositor(contador, compositor(exclamar, convMayusculas));

textoContado("Lorem Ipsum");            // "LOREM IPSUM [11]"
textoContadoExclamado("Lorem Ipsum");   // "LOREM IPSUM [11]!!!"
textoExclamadoContado("Lorem Ipsum");   // "LOREM IPSUM!!! [14]"

Currificación (Currying)

La currificación es una técnica muy usada en programación funcional. Poder convertir funciones de varios parámetros en una sucesión de funciones con un único parámetro hace que consigamos sistemas más modulares y flexibles, lo que a la larga hará que mantengamos mejor nuestras aplicaciones y reutilicemos componentes. El abismo de null

const suma = (a, b) => a + b
const cumaCurrificada = (a) => (b) => a + b
cumaCurrificada(40)(2) // 42.
const sumaSegunda = cumaCurrificada(2) // (b) => 2 + b
sumaSegunda(10) // 12

Aridad

En el análisis matemático, la aridad de un operador matemático o de una función es el número de argumentos necesarios para que dicho operador o función se pueda calcular. Wikipedia

function fun2 (arg1, arg2) {
    //...
}

function fun3 (arg1, arg2, arg3) {
    //...
}

console.log(fun2.length) // 2 -> Binaria
console.log(fun2.length) // 3 -> Ternaria

Programación funcional en JavaScript: Más allá...

Aplicación parcial (Partial Application)

Aplicar parcialmente una funcion, significa crear una nueva funcion rellenando previamente alguno de los argumentos de la funcion original. idcmardelplata/functional-programming-jargon

Continuación (Continuation)

En cualquier punto dado de un programa, la parte del codigo que aun esta por ejecutarse se conoce como continuación. idcmardelplata/functional-programming-jargon

Idempotente (Idempotent)

Una funcion es idempotente si al volver a aplicarla sobre su resultado, no produce resultados diferentes. idcmardelplata/functional-programming-jargon

Y mucho más...

Programación funcional en JavaScript: Librerías y frameworks

img