Método call()

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy — lição 73 de 110.

Dart tem um método especial chamado call() que permite usar um objeto como se fosse uma função. Quando uma classe define um método call(), você pode invocar instâncias dessa classe usando a sintaxe de chamada de função.

class Multiplier {
  int factor;
  
  Multiplier(this.factor);
  
  int call(int value) {
    return value * factor;
  }
}

void main() {
  var double = Multiplier(2);
  var triple = Multiplier(3);
  
  print(double(5));  // 10 - chamando o objeto como uma função
  print(triple(5));  // 15
}

Em vez de escrever double.call(5), você pode simplesmente escrever double(5). O Dart invoca automaticamente o método call() quando você usa parênteses no objeto.

O método call() pode aceitar quaisquer parâmetros e retornar qualquer tipo, assim como um método regular:

class Greeter {
  String prefix;
  
  Greeter(this.prefix);
  
  String call(String name, {String punctuation = '!'}) {
    return '$prefix, $name$punctuation';
  }
}

void main() {
  var hello = Greeter('Hello');
  print(hello('Alice'));  // Hello, Alice!
  print(hello('Bob', punctuation: '?'));  // Hello, Bob?
}

Este padrão é útil quando você precisa de objetos que se comportam como funções, mas que também mantêm estado ou configuração. É comumente usado para criar operações reutilizáveis, validadores ou formatadores que precisam lembrar de configurações entre chamadas.

Desafio

Fácil

Vamos construir um sistema de formatador de texto onde os objetos formatadores podem ser chamados diretamente como funções! Você criará classes chamáveis que transformam texto de diferentes maneiras, mantendo suas configurações.

Você organizará seu código em dois arquivos:

formatters.dart: Crie duas classes chamáveis que transformam strings:
- Uma classe Wrapper que envolve o texto com um prefixo e sufixo configuráveis. Ela deve armazenar as strings prefix e suffix, e seu método call() deve aceitar uma String text e retornar o texto envolvido pelo prefixo e sufixo.
- Uma classe Repeater que repete o texto um número configurável de vezes. Ela deve armazenar um inteiro times, e seu método call() deve aceitar uma String text e retornar o texto repetido aquela quantidade de vezes, separado por espaços.
main.dart: Importe seus formatadores e demonstre como esses objetos podem ser usados exatamente como funções:
- Crie um Wrapper com o prefixo '[' e o sufixo ']'
- Crie outro Wrapper com o prefixo '***' e o sufixo '***'
- Crie um Repeater com times definido como 3
- Chame o primeiro wrapper com 'Hello' e imprima o resultado
- Chame o segundo wrapper com 'Important' e imprima o resultado
- Chame o repeater com 'Go' e imprima o resultado
- Demonstre o encadeamento passando o resultado do primeiro wrapper (com 'Nested') para dentro do segundo wrapper e imprima o resultado

Observe como você pode chamar seus objetos formatadores diretamente usando parênteses, assim como funções regulares. O método call() torna isso possível, e cada objeto lembra sua configuração entre os usos!

Saída esperada:

[Hello]
***Important***
Go Go Go
***[Nested]***

Folha de consulta

O método call() permite que você use um objeto como se fosse uma função. Quando uma classe define um método call(), você pode invocar instâncias dessa classe usando a sintaxe de chamada de função.

class Multiplier {
  int factor;
  
  Multiplier(this.factor);
  
  int call(int value) {
    return value * factor;
  }
}

void main() {
  var double = Multiplier(2);
  print(double(5));  // 10 - chamando o objeto como uma função
}

Em vez de escrever double.call(5), você pode simplesmente escrever double(5). O Dart invoca automaticamente o método call() quando você usa parênteses no objeto.

O método call() pode aceitar quaisquer parâmetros e retornar qualquer tipo:

class Greeter {
  String prefix;
  
  Greeter(this.prefix);
  
  String call(String name, {String punctuation = '!'}) {
    return '$prefix, $name$punctuation';
  }
}

void main() {
  var hello = Greeter('Hello');
  print(hello('Alice'));  // Hello, Alice!
  print(hello('Bob', punctuation: '?'));  // Hello, Bob?
}

Este padrão é útil para criar objetos que se comportam como funções, mas que também mantêm estado ou configuração entre as chamadas.

Experimente você mesmo

import 'formatters.dart';

void main() {
  // TODO: Criar um Wrapper com prefixo '[' e sufixo ']'
  
  // TODO: Criar outro Wrapper com prefixo '***' e sufixo '***'
  
  // TODO: Criar um Repeater com times definido como 3
  
  // TODO: Chamar o primeiro wrapper com 'Hello' e imprimir o resultado
  
  // TODO: Chamar o segundo wrapper com 'Important' e imprimir o resultado
  
  // TODO: Chamar o repeater com 'Go' e imprimir o resultado
  
  // TODO: Demonstrar o encadeamento passando o resultado do primeiro wrapper
  // (com 'Nested') para o segundo wrapper, e imprimir o resultado
}