Como criar widgets stateless

Ao começar com Flutter, uma das primeiras coisas que você precisa aprender são os widgets stateless.

Ao começar com o Flutter, uma das primeiras coisas que você precisa aprender são os stateless widgets. Gravamos uma série que cobre stateless widgets, stateful widgets, inherited widgets e keys.

No vídeo a seguir, explico o que é um widget do Flutter e como usar StatelessWidgets em um app Flutter:

Watch on YouTube in a new tab: "How to Create Stateless Widgets - Flutter Widgets 101 Ep. 1"

Para quem prefere ler artigos a assistir vídeos, este post explica o que são os widgets do Flutter, como eles se combinam para formar interfaces e como compor uma UI com stateless widgets.

Parte 1 — Criando um app de cachorros com stateless widgets

Para manter as coisas rápidas, estou começando com um app básico aqui. Ele contém um widget Scaffold, um widget AppBar e alguns widgets Text que exibem informações sobre meu labrador amarelo, Rocky.

Widgets são os blocos básicos de construção de um app Flutter. Cada um é uma declaração imutável de um aspecto da interface do usuário, e eles podem assumir muitas tarefas.

Por exemplo, existem:

  • widgets estruturais — como um botão ou menu

  • widgets de estilo que propagam uma fonte ou esquema de cores

  • widgets de layout — como padding

  • e muitos outros

Você também pode compor novos widgets a partir de widgets existentes, então as combinações são infinitas. Deixe-me mostrar o que quero dizer.

Digamos que eu queira uma cor de fundo atrás do nome do meu cachorro.

Posso fazer isso envolvendo o widget Text com um DecoratedBox.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: DecoratedBox( // here is where I added my DecoratedBox
           decoration: BoxDecoration(color: Colors.lightBlueAccent),
           child: Text('Rocky'),
         ),
       ),
     ),
   );
 }
}

E agora meu widget Text tem uma cor de fundo.

Talvez eu queira um padding em volta do texto.

Posso conseguir isso adicionando um widget Padding. Vou especificar 8 pixels lógicos de padding em volta do nome do Rocky.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: DecoratedBox(
           decoration: BoxDecoration(color: Colors.lightBlueAccent),
           child: Padding(
             padding: const EdgeInsets.all(8.0)
             child: Text('Rocky'),
           ),
         ),
       ),
     ),
   );
 }

E agora eu tenho padding.

Esse processo de juntar widgets é o que chamamos de “composição”. Estou compondo minha interface combinando widgets simples, cada um fazendo uma tarefa específica: Padding dá padding, DecoratedBox decora uma caixa, e assim por diante.

Agora, digamos que eu vá ao abrigo de animais e conheça alguns labradores amarelos sem os quais não consigo viver. Posso adicionar um widget Column dentro do widget Center e incluir os nomes deles.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
             DecoratedBox(
               decoration: BoxDecoration(color: Colors.lightBlueAccent),
               child: Padding(
                 padding: const EdgeInsets.all(8.0),
                 child: Text('Rocky'),
               ),
             ),
             DecoratedBox(
               decoration: BoxDecoration(color: Colors.lightBlueAccent),
               child: Padding(
                 padding: const EdgeInsets.all(8.0),
                 child: Text('Spot'),
               ),
             ),
             DecoratedBox(
               decoration: BoxDecoration(color: Colors.lightBlueAccent),
               child: Padding(
                 padding: const EdgeInsets.all(8.0),
                 child: Text('Fido'),
               ),
             ),
           ],
         ),
       ),
     ),
   );
 }
}

Uso um widget chamado SizedBox para adicionar espaço em branco entre eles, o que resulta em:

Mas, sabe, tenho muito código repetido (também chamado de boilerplate) nessas três caixas de nome. Não seria ótimo se eu pudesse criar meu próprio widget que recebe um nome e cuida dos detalhes para mim?

Bom, eu posso.

Vou criar um StatelessWidget e chamá-lo de DogName. Um stateless widget é um widget composto de filhos (por isso ele contém um método build()) e não contém nenhum estado mutável que precise rastrear. Quando digo estado mutável, me refiro a qualquer propriedade que muda com o tempo. Por exemplo, uma caixa de texto com uma string que o usuário atualiza, ou um stream de dados que atualiza um painel de chegadas e partidas.

dart
class DogName extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
  }
}

Este widget não tem nada disso. Ele só precisa de uma string para o nome, que não vai mudar, então StatelessWidget é a escolha perfeita. Posso até deixar essa string como final.

dart
class DogName extends StatelessWidget {
 final String name;
​
 @override
 Widget build(BuildContext context) {
 }
}

Posso especificar a string pelo construtor e, como todas as suas propriedades são final, posso marcar isso como um construtor const.

dart
class DogName extends StatelessWidget {
 final String name;
​
const DogName(this.name);
​
 @override
 Widget build(BuildContext context) {
  }
}

Agora, só preciso definir o método build usando os mesmos widgets, só que agora o widget Text exibe a string da propriedade name do widget.

dart
class DogName extends StatelessWidget {
 final String name;
​
const DogName(this.name);
​
 @override
 Widget build(BuildContext context) {
   return DecoratedBox(
     decoration: BoxDecoration(color: Colors.lightBlueAccent),
     child: Padding(
       padding: const EdgeInsets.all(8.0),
       child: Text(name),
     ),
   );
 }
}

Uso esse widget para simplificar o código original.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
             DogName('Rocky'),
             SizedBox(height: 8.0),
             DogName('Spot'),
             SizedBox(height: 8.0),
             DogName('Fido'),
           ],
         ),
       ),
     ),
   );
 }
}

Como você pode ver, isso resulta na mesma UI, mas o código fica mais enxuto graças ao StatelessWidget e ao uso de composição do Flutter.

Parte 2 — Árvores de widgets e árvores de elementos

Esse é um pequeno exemplo de como funciona a composição com StatelessWidget. Neste ponto, você pode se perguntar: “Entendi como esses métodos build funcionam, mas quando eles são chamados?” Bem, vamos começar com um único widget DogName.

Costumamos pensar em apps feitos com Flutter como uma árvore de widgets, e isso não é ruim. Mas, como mencionei no início, widgets são na verdade apenas configurações para partes da UI de um app. Eles são plantas. Então, para que servem essas configurações? Para elementos. Um elemento é um widget que se tornou real e foi montado na tela. A árvore de elementos representa o que está de fato exibido no dispositivo a qualquer momento.

Cada classe de widget tem uma classe de elemento correspondente e um método para criar uma instância.

StatelessWidget, por exemplo, cria um StatelessElement.

Quando um widget é montado na árvore, o Flutter chama o método createElement(). O Flutter pede ao widget um elemento e coloca esse elemento na árvore de elementos, com uma referência de volta ao widget que o criou.

O StatefulElement então pergunta “Será que tenho algum filho?” e chama o método build() do Widget.

Neste app, há vários. Esses widgets então criam seus próprios elementos correspondentes.

E eles também são montados na árvore de elementos.

Assim, o app agora tem duas árvores: uma que representa o que está de fato na tela (os elementos), e outra que guarda as plantas a partir das quais eles foram feitos (os widgets).

Agora você pode estar se perguntando o que inicia o processo de construir e criar elementos, o que dá o pontapé inicial, por assim dizer. Deixe-me mostrar algo que você talvez não tenha notado lá no começo…

A classe DogApp, que representa o app inteiro, é ela mesma um StatelessWidget.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
             DogName('Rocky'),
             SizedBox(height: 8.0),
             DogName('Spot'),
             SizedBox(height: 8.0),
             DogName('Fido'),
           ],
         ),
       ),
     ),
   );
 }
}

Eu disse que widgets podem fazer quase tudo, certo? Se você olhar para main(), que é o ponto de entrada do app, verá que ele chama o método runApp(), e esse é o ponto de partida. O método runApp() recebe um widget e o monta como o elemento raiz do app, com restrições de altura e largura que correspondem ao tamanho da tela.

dart
import 'package:flutter/material.dart';
​
void main() {
 runApp(new DogApp());
}
​
class DogApp extends StatelessWidget {
 @override
 Widget build(BuildContext context) {
   return MaterialApp(
     title: 'My Dog App',
     home: Scaffold(
       appBar: AppBar(
         title: Text('Yellow Lab'),
       ),
       body: Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
             DogName('Rocky'),
             SizedBox(height: 8.0),
             DogName('Spot'),
             SizedBox(height: 8.0),
             DogName('Fido'),
           ],
         ),
       ),
     ),
   );
 }
}

Depois disso, o Flutter percorre todos os métodos build() da árvore de widgets, criando widgets e usando-os para fazer elementos, até que tudo esteja construído, montado na tela e pronto para ser layoutado e renderizado.

É assim que ele exibe três pequenas caixas contendo os nomes dos labradores amarelos.

Então essa é uma introdução a compor com StatelessWidgets e construir uma interface. Uma coisa que não mencionei é como atualizar ou reconstruir uma interface quando os dados mudam. Isso porque StatelessWidgets não fazem isso. Eles são stateless, então não conseguem rastrear dados ao longo do tempo nem disparar reconstruções por conta própria.

Felizmente, o Flutter também tem StatefulWidgets, sobre os quais falaremos no próximo episódio desta série.

Para mais informações sobre o Flutter e todos os seus muitos widgets, acesse flutter.io.

Você também pode assistir aos outros episódios da série aqui ou experimentar um codelab do Flutter.

Mais do Flutter