Clausura (ciência da computação)

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Esta página ou secção não cita nenhuma fonte ou referência, o que compromete sua credibilidade (desde junho de 2011).
Por favor, melhore este artigo providenciando fontes fiáveis e independentes, inserindo-as no corpo do texto por meio de notas de rodapé. Encontre fontes: Googlenotícias, livros, acadêmicoScirusBing. Veja como referenciar e citar as fontes.

Em ciência da computação e na programação uma clausura (do inglês closure) é uma função que referencia variáveis livres no contexto léxico. Uma clausura ocorre normalmente quando uma função é declarada dentro do corpo de outra, e a função interior referencia variáveis locais da função exterior. Em tempo de execução, quando a função exterior é executada, então uma clausura é formada, que consiste do código da função interior e referências para quaisquer variáveis no âmbito da função exterior que a clausura necessita.

Utilização[editar | editar código-fonte]

As clausuras são utilizadas para:

  • Bibliotecas de software podem permitir que os usuários customizem o comportamento passando clausuras como argumentos às funções importantes. Por exemplo, uma função que classifique valores pode aceitar um argumento de clausura que compare os valores a ser classificados de acordo com um critério definido pelo próprio usuário.
  • As funções múltiplas podem ser produzidas num mesmo ambiente, permitindo-as de se comunicar confidencialmente.
  • Sistemas de objetos podem ser construídos com clausuras. Por exemplo, Scheme padrão não suporta programação orientada a objetos, mas há sistemas de objetos construídos para essa linguagem de programação com recurso a clausuras.

Exemplos[editar | editar código-fonte]

def new_counter
  i = 0
  lambda { i += 1 }
end
 
c1 = new_counter
puts c1.call
puts c1.call
puts c1.call
puts c1.call
puts c1.call
(defun foo ()
  (let ((counter 0))
    ;; a função anônima a seguir é definida no escopo de counter,
    ;; por isso foo retornará uma clausura
    (lambda () 
      (setf counter (+ 1 counter))
      counter)))
 
(setf counter-1 (foo))
(setf counter-2 (foo))
 
(funcall counter-1) ==> 1
(funcall counter-1) ==> 2
(funcall counter-2) ==> 1
function novoContador () {
   var i = 0;
    return function ()  { // função anônima
      i += 1;
      return i;
   }
}
 
c1 = novoContador();
alert(c1());
alert(c1());
alert(c1());
alert(c1());
alert(c1());
function newCounter() {
    $i=0;
    return function() use (&$i) {
        return ++$i;
    };
}
$countMe = newCounter();
print($countMe());
print($countMe());
print($countMe());
print($countMe());
>>> def foo(start=0):
...     counter = [start] # counter is 1-element array
...     def bar():
...         counter[0] = counter[0] + 1
...         return counter[0]
...     return bar
...
>>> count = foo(10)
>>> count()
11
>>> count()
12
(define (foo)
  (let ((counter 0))
    (lambda ()
      (set! counter (+ 1 counter))
      counter)))
 
(define counter-1 (foo))
(define counter-2 (foo))
 
(counter-1) ==> 1
(counter-1) ==> 2
(counter-1) ==> 3
(counter-2) ==> 1

Na internet[editar | editar código-fonte]