Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Paradigmas de Programação: Uma Visão Geral sobr...

Paradigmas de Programação: Uma Visão Geral sobre Orientação a Objetos e Programação Funcional

Sabe-se que não existe solução única para todos os problemas em tecnologia. O mesmo acontece para linguagens de programação! As linguagens de programação possuem diferentes propósitos e características. Entendê-las bem permite conhecer melhor os seus limites e se são adequadas para a solução de determinados problemas. Nesta apresentação falarei sobre paradigmas de programação (definições e exemplos), orientação a objetos (pilares da OO, princípios e práticas), programação funcional (funções de primeira classe, de alta ordem e puras, estado, imutabilidade, currying, aplicação parcial e composição de funções), as diferenças entre os paradigmas e as vantagens/desvantagens de utilizá-los.

Marcel dos Santos

April 26, 2019
Tweet

More Decks by Marcel dos Santos

Other Decks in Programming

Transcript

  1. Marcel Gonçalves dos Santos @marcelgsantos paradigmas de programação uma visão

    geral sobre orientação a objetos e programação funcional
  2. Interaja nas mídias sociais!
 
 - fale sobre o evento,

    palestrantes e conteúdo - tire fotos do evento e publique
 - interaja com outros participantes do evento - tire dúvidas ou dê feedbacks para os palestrantes
  3. 1. seguir @marcelgsantos no Twitter
 2. tuitar utilizando as hashtags

    #TheDevConf,
 #TrilhaJavaScript e #JavaScript
 3. não vale tuíte em branco e retuíte
 4. ler e preencher este simples formulário
 bit.ly/sorteio-tdc-4 Concorra a um livro da Casa do Código!
  4. paradigma imperativo
 descreve a resolução de um problema através de

    comandos que o computador pode compreender e executar
  5. let result = 0; !// Imperative code to sum 1

    to 10 for (let i = 0; i !<= 10; i!++) { result += i; } console.log(result); !// 55
  6. const numbers = [1, 2, 3, 4, 5, 6, 7,

    8, 9, 10]; !// Declarative code to sum 1 to 10 const sum = (a, b) !=> a + b; const result = numbers.reduce(sum); console.log(result);
  7. paradigmas de linguagens de programação
 
 imperativo
 procedural - C

    e Pascal orientado a objetos - C++, Java, JavaScript, PHP, Python e Ruby
 
 declarativo
 lógico - Prolog funcional - Clojure, Elixir, Elm, Erlang, F#, Haskell, Lisp, OCaml e Scala
  8. em programação orientada a objetos baseada em classes as classes

    são definidas de antemão e objetos são instanciados baseados em classes
  9. !// class to create a Person object class Person {

    constructor(name, age) { this.name = name; this.age = age; } sayName() { console.log(`Hi, my name is ${this.name}!`); } } !// create an instance of Person let person = new Person('John', 32); person.sayName(); !// Hi, my name is John!
  10. em programação orientada a objetos baseada em protótipos os objetos

    são as entidades primárias e não existe nenhuma classe
  11. !// constructor function to create a Person object function Person(name,

    age) { this.name = name; this.age = age; } !// sayName method is added to the prototype of Person Person.prototype.sayName = function() { console.log('Hi, my name is ' + this.name + '!'); }; !// create an instance of Person let person = new Person('John', 32); person.sayName(); !// Hi, my name is John!
  12. class Person { constructor(name, age) { this.name = name; this.age

    = age; } sayName() { console.log(`Hi, my name is ${this.name}!`); } } !// add sayAge method to the Person prototype Person.prototype.sayAge = function() { console.log('I\'m ' + this.age + ' years old!'); }; let person = new Person('John', 32); person.sayName(); !// Hi, my name is John! person.sayAge(); !// I'm 32 years old!
  13. !// class to create a Person object class Person {

    constructor(name, age) { this.name = name; this.age = age; } sayName() { console.log(`Hi, my name is ${this.name}!`); } } !// create an instance of Person let person = new Person('John', 32); person.sayName(); !// Hi, my name is John!
  14. herança
 permite o reaproveitamento de código em que uma classe

    herda características e atributos de uma classe base
  15. !// hiding data through convention class Person { constructor(name, age)

    { this._name = name; this._age = age; } sayName() { console.log(`Hi, my name is ${this._name}!`); } } let person = new Person('John', 'Doe', 32); !// accessing hidden data console.log(person._name); !// John
  16. class Person { #name; #age; constructor(name, age) { this.#name =

    name; this.#age = age; } sayName() { console.log(`Hi, my name is ${this.#name}!`); } } let person = new Person('John', 'Doe', 32); console.log(person.sayName()); !// Hi, my name is John! console.log(person.name); !// undefined console.log(person.#name); !// Uncaught SyntaxError: Undefined private field #name: must be declared in an…
  17. !// not cohesive class class Cart { constructor() { this._items

    = []; } numberOfItems() { return this._length; } calculateDeliveryPrice() { !// calculates the delivery price } }
  18. o acoplamento ocorre quando o código de um módulo utiliza

    código de outro módulo, seja ao chamar uma função ou acessar algum dado
  19. class Engine { start() { console.log('Starting the engine'); } }


    
 class Car { constructor() { this.engine = new Engine; } start() { this.engine.start(); } } let toyota = new Car(); toyota.start(); !// Starting the engine
  20. class Engine { !// engine implementation }
 class Car {

    constructor(engine) { this.engine = engine; } start() { this.engine.start(); } } !// inject an engine dependency into the car let engine = new Engine(); let toyota = new Car(engine); toyota.start(); !// Starting the engine
  21. utilizar injeção de dependências auxilia nos testes unitários pois tornam

    os módulos fracamente acoplados, altamente coesos e facilita o mocking de objetos
  22. Uma função matemática trata-se de um simples mapeamento entre o

    domínio e o contra-domínio. 1 2 3 D B A C X Y
  23. o estado de uma aplicação é alterado a cada interação

    feita pelo usuário ou pelo próprio sistema…
  24. funções puras
 
 1. ter parâmetros de entrada 
 2.

    não depender do estado externo 
 3. retorno baseado nos valores de entrada 
 4. não devem causar efeitos colaterais
  25. !// pure or impure function? let counter = 0; function

    increment() { counter!++; return counter; } console.log(increment()); !// 1
  26. !// pure function (ES5 syntax) function add(x, y) { return

    x + y; } console.log(add(2, 3)); !// 5
  27. !// pure function (ES6 syntax) const add = (x, y)

    !=> x + y; console.log(add(2, 3)); !// 5
  28. transparência referencial
 propriedade que garante que a saída de uma

    função pura sempre será a mesma dado um mesmo conjunto de argumentos
  29. !// referential transparency const add = (x, y) !=> x

    + y; console.log(add(2, 3) !!=== 5); !// true console.log(5 !!=== 5); !// true
  30. funções de alta ordem e 
 funções de primeira classe


    são funções que podem ser atribuídas a variáveis, passadas como argumentos e retornadas de uma função
  31. !// high-order function const add = (x, y) !=> x

    + y; const numbers = [1, 2, 3, 4, 5]; const sum = numbers.reduce(add); const sum10 = numbers.reduce(add, 10); console.log(sum); !// 15 console.log(sum10); !// 25
  32. !// anonymous function const numbers = [1, 2, 3, 4,

    5]; const sum = numbers.reduce((x, y) !=> x + y); console.log(sum); !// 15
  33. !// closure function function greet(greeting) { return function (name) {

    return `${greeting} ${name}!`; }; } const greet2 = greeting !=> name !=> `${greeting} ${name}!`; console.log(greet('Hello')('Mary')); !// Hello Mary! console.log(greet2('Hello')('John')); !// Hello John!
  34. recursão
 é quando uma função é definida em termos de

    si própria, ou seja, quando a função chama ela mesma
  35. diferença entre função e procedimento (procedure)
 uma função recebe um

    valor e retorna um resultado; um procedimento é um conjunto de comandos executados numa ordem
  36. “Don't think of functions as a collection of instructions. Think

    of them as non-destructive operations on input `double = n => n * 2;`” Eric Elliott, 2016. https:/ /twitter.com/_ericelliott/status/685172918784004097
  37. …em uma função que recebe apenas um argumento e que

    retorna uma função que aceita os argumentos restantes
  38. a aplicação parcial é quando se executa uma função e

    passa apenas parte de seus argumentos
  39. !// specialization from a curried function !// using partial application

    const greet = R.curry((greeting, name) !=> `${greeting} ${name}`); const greetMorning = greet('Good Morning'); console.log(greetMorning('Alice')); !// Good Morning Alice
  40. os parâmetros mais genéricos devem vir mais para o início

    e os parâmetros mais específicos devem vir mais para o final
  41. o JavaScript não possui suporte nativo para currying como nas

    linguagens puramente funcionais Elm ou Haskell
  42. a composição é o processo de combinar uma ou mais

    funções para criar uma nova função
  43. !// creating a new function from others by composition const

    sentence = 'estava à toa na vida o meu amor me 
 chamou pra ver a banda passar cantando coisas de amor'; const wordCount = R.length(R.split(' ', sentence)); console.log(wordCount); !// 19
  44. é uma solução elegante e legível e ajuda a evitar

    a utilização do aninhamento de funções
  45. o Ramda possui uma função que permite criar uma nova

    função a partir da composição de funções
  46. !// create a function using composition const sentence = 'estava

    à toa na vida o meu amor me 
 chamou pra ver a banda passar cantando coisas de amor’; const countWords = R.compose(R.length, R.split); console.log(countWords(' ', sentence)); !// 19
  47. uma biblioteca construída para o estilo de programação funcional que

    facilita a utilização de pipelines e dados imutáveis
  48. !// shopping cart const cart = [ {id: 1, product:

    'iPhone', price: 499}, {id: 2, product: 'Kindle', price: 179}, {id: 3, product: 'Macbook Pro', price: 1199}, ]; !// get prices from shopping cart and sum them
 !// using intermediate values const cartPrices = R.map(item !=> item.price, cart); const cartSum = R.sum(cartPrices); console.log(cartSum); !// 1877 realiza o mapeamento da lista de produtos (objetos) para uma lista de preços (números) faz a somatória da lista de números e retorna o total Passo 1
  49. !// shopping cart const cart = [ {id: 1, product:

    'iPhone', price: 499}, {id: 2, product: 'Kindle', price: 179}, {id: 3, product: 'Macbook Pro', price: 1199}, ]; !// get prices from shopping cart and sum them
 !// using function composition const totalCart = R.compose( R.sum, R.map(item !=> item.price), ); console.log(totalCart(cart)); !// 1877 cria uma nova função a partir da composição de funções e elimina valores intermediários aplicação parcial da função map a composição é feita da direita para a esquerda Passo 2
  50. !// shopping cart const cart = [ {id: 1, product:

    'iPhone', price: 499}, {id: 2, product: 'Kindle', price: 179}, {id: 3, product: 'Macbook Pro', price: 1199}, ]; !// get prices from shopping cart and sum them !// using function composition with pipe const totalCart = R.pipe( R.map(item !=> item.price), R.sum, ); console.log(totalCart(cart)); !// 1877 o pipe de funções é feito da esquerda para a direita e facilita a leitura do código Passo 3
  51. !// cleaning data from an input const price = '100';

    const discount = (perc, value) !=> perc * value; let priceInt = parseInt(price); let priceDiscount = discount(0.2, priceInt); console.log(priceDiscount); !// 20 Passo 1
  52. !// cleaning data from an input const price = '100';

    const discount = (perc, value) !=> perc * value; !// using partial application const discount20 = R.partial(discount, [0.2]); let priceInt = parseInt(price); let priceDiscount = discount20(priceInt); console.log(priceDiscount); !// 20 cria uma nova função a partir da aplicação parcial de uma existente Passo 2
  53. !// cleaning data from an input const price = '100';

    const discount = (perc, value) !=> perc * value; !// using function composition const priceDiscount = R.pipe( parseInt, R.partial(discount, [0.2]), ); console.log(priceDiscount(price)); !// 20 cria uma nova função a partir da composição de funções utilizando a função pipe e elimina valores intermediários Passo 3
  54. !// cleaning data from an input const price = 'lambda!';

    const discount = (perc, value) !=> perc * value; !// using function composition const priceDiscount = R.pipe( parseInt, R.partial(discount, [0.2]), ); console.log(priceDiscount(price)); !// null erro ao receber um valor não numérico Passo 4
  55. !// cleaning data from an input const price = 'lambda!';

    const discount = (perc, value) !=> perc * value; !// using function composition const priceDiscount = R.pipe( parseInt, R.defaultTo(0), R.partial(discount, [0.2]), ); console.log(priceDiscount(price)); !// 0 retorna o valor padrão para o caso de um valor não truthy Passo 5
  56. …e sim sobre eliminar estado e efeito colateral sempre que

    possível e controlar efeitos colaterais quando necessário