A feature do Dart 2.7 que adiciona funcionalidade às bibliotecas existentes
Com a vinda do Dart 2.7, veio junto a ele uma feature muito interessante que nos ajuda bastante durante o desenvolvimento, que seria o Extension Methods. Basicamente ele é uma forma de adicionar funcionalidade às bibliotecas existentes.
Antes de darmos continuidade…
É importante lembrar que, para conseguir usar o Extension Methods, você precisa apontar para a versão do SDK 2.7 ou maior. Sim, existe lugares que falam para colocar o SDK 2.6 ou maior, mas segundo a documentação, é indicado colocar do SDK 2.7 ou maior. Então, abra o arquivo pubspec.yaml e atualize o sdk, dessa forma:
environment:
sdk: “>=2.7.0 <3.0.0”
Feito isso, podemos seguir em frente.
Agora, vamos para um exemplo simples e prático do que é e como usar o Extension Methods.
Vamos implementar algo!
Imagine que você tem uma String e precisa colocar a primeira letra dessa String maiúscula e o resto minúscula.
Para resolver esse problema, você talvez faria algo do tipo:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| void main() { | |
| final String _text = 'ExTEnSiON'; | |
| String _capitalize(String text){ | |
| return "${text[0].toUpperCase()}${text.toLowerCase().substring(1)}"; | |
| } | |
| print(_capitalize(_text)); //Extension | |
| } |
Simples, certo? Agora, onde o Extension Methods entra nessa história? Com ele, podemos deixar esse código ainda melhor e bem mais intuitivo para quem for usar essa função no futuro, fazendo da seguinte maneira:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| void main() { | |
| final String _text = 'ExTEnSiON'; | |
| print(_text.capitalize()); //Extension | |
| } | |
| extension StringExtensions on String { | |
| String capitalize() { | |
| return "${this[0].toUpperCase()}${this.toLowerCase().substring(1)}"; | |
| } | |
| } |
O uso da função capitalize parece mais intuitivo, certo? Sendo usado da mesma forma que usamos um .toUpperCase(), .toLowerCase() por exemplo, como se fosse realmente uma função da Classe String.
Caso queira executar esses códigos, aqui está o link do Exemplo 1 e Exemplo 2 no DartPad.
Ai você me pergunta, Extension Methods seria só isso? De forma básica, sim! Legal, né?
E o melhor de tudo, você não precisa fazer apenas para a Classe String, você consegue fazer para Classe Double, Int e até para suas Classes criadas no seu projeto de atuação.
E sim, dá pra usar em coisas do Flutter! Deixa eu te mostrar.
Extension Methods no Flutter
Como você deve estar pensando nesse momento, sim dá pra fazer muita coisa no Flutter usando Extension Methods! Vamos ver algumas :)
Na prática
Imagine que você tem uma tela e que nela existem dois textos. Cada texto desse tem um style diferente e também uma certa distância entre eles. Algo do tipo:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import 'package:flutter/material.dart'; | |
| void main() => runApp(MyApp()); | |
| class MyApp extends StatelessWidget { | |
| @override | |
| Widget build(BuildContext context) { | |
| return MaterialApp( | |
| title: 'Flutter Demo', | |
| debugShowCheckedModeBanner: false, | |
| theme: ThemeData.dark(), | |
| home: MyHomePage(title: 'Flutter Extension methods'), | |
| ); | |
| } | |
| } | |
| class MyHomePage extends StatefulWidget { | |
| MyHomePage({Key key, this.title}) : super(key: key); | |
| final String title; | |
| @override | |
| _MyHomePageState createState() => _MyHomePageState(); | |
| } | |
| class _MyHomePageState extends State<MyHomePage> { | |
| @override | |
| Widget build(BuildContext context) { | |
| return Scaffold( | |
| appBar: AppBar( | |
| title: Text(widget.title), | |
| ), | |
| body: Center( | |
| child: Column( | |
| mainAxisAlignment: MainAxisAlignment.center, | |
| children: <Widget>[ | |
| Padding( | |
| padding: EdgeInsets.all(20), | |
| child: Text( | |
| 'You can use Extension methods in Dart!', | |
| style: TextStyle( | |
| fontSize: 24, | |
| color: Colors.red, | |
| ), | |
| ), | |
| ), | |
| Padding( | |
| padding: EdgeInsets.all(30), | |
| child: Text( | |
| 'You can use Extension methods in Flutter too!', | |
| style: TextStyle( | |
| fontSize: 32, | |
| color: Colors.blue, | |
| ), | |
| ), | |
| ), | |
| ], | |
| ), | |
| ), | |
| ); | |
| } | |
| } |
Certo, mas onde entra a possibilidade Extension Methods nesse exemplo?
Aqui, vamos criar dois Extension Methods! Uma para o TextStyle e outro para o Padding. Ele fica assim:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import 'package:flutter/material.dart'; | |
| void main() => runApp(MyApp()); | |
| class MyApp extends StatelessWidget { | |
| @override | |
| Widget build(BuildContext context) { | |
| return MaterialApp( | |
| title: 'Flutter Demo', | |
| debugShowCheckedModeBanner: false, | |
| theme: ThemeData.dark(), | |
| home: MyHomePage(title: 'Flutter Extension methods'), | |
| ); | |
| } | |
| } | |
| class MyHomePage extends StatefulWidget { | |
| MyHomePage({Key key, this.title}) : super(key: key); | |
| final String title; | |
| @override | |
| _MyHomePageState createState() => _MyHomePageState(); | |
| } | |
| class _MyHomePageState extends State<MyHomePage> { | |
| @override | |
| Widget build(BuildContext context) { | |
| return Scaffold( | |
| appBar: AppBar( | |
| title: Text(widget.title), | |
| ), | |
| body: Center( | |
| child: Column( | |
| mainAxisAlignment: MainAxisAlignment.center, | |
| children: <Widget>[ | |
| Text( | |
| 'You can use Extension methods in Dart!', | |
| ).h1().paddingAll(20), | |
| Text( | |
| 'You can use Extension methods in Flutter too!', | |
| ) | |
| .h1( | |
| style: TextStyle( | |
| fontSize: 32, | |
| color: Colors.blue, | |
| ), | |
| ) | |
| .paddingAll(30), | |
| ], | |
| ), | |
| ), | |
| ); | |
| } | |
| } | |
| extension TextExtensions on Text { | |
| Text h1({TextStyle style}) { | |
| final TextStyle defaultStyle = TextStyle(fontSize: 24, color: Colors.red); | |
| return Text(data, | |
| key: key, | |
| locale: locale, | |
| maxLines: maxLines, | |
| overflow: overflow, | |
| semanticsLabel: semanticsLabel, | |
| softWrap: softWrap, | |
| strutStyle: strutStyle, | |
| textAlign: textAlign, | |
| textDirection: textDirection, | |
| textScaleFactor: textScaleFactor, | |
| textWidthBasis: textWidthBasis, | |
| style: (this.style ?? defaultStyle).merge(style ?? defaultStyle)); | |
| } | |
| } | |
| extension on Widget { | |
| Widget paddingAll(double padding) => Padding( | |
| padding: EdgeInsets.all(padding), | |
| child: this, | |
| ); | |
| } |
Você pode perceber que no Extension Methods do Text eu coloquei o nome TextExtensions, mas no do Padding, eu não coloquei. Sim, o nome não é obrigatório, mas é bom colocar, de forma que fique bem explicado ao que se referem essas Extension Methods.
Esse foi dois exemplos de vários tipos de Extension Methods que podem ser feitos no Flutter. Caso queira executar esses códigos, aqui está o link do Exemplo 3 e Exemplo 4 no DartPad.
Agora que falamos sobre o que é e como implementar o Extension Methods, precisamos falar de outro ponto bem importante que precisamos ter atenção com relação a ele.
Com grandes poderes vem grandes responsabilidades
Como assim? Não é só pegar, implementar os Extension Methods e ser feliz? Sim, mas lembre-se, use com moderação! Sim, usar ele vai facilitar, ajudar e até mesmo melhorar sua experiência de desenvolvimento (em alguns casos), mas tenha bom senso na hora de criar suas Extension Methods.
Minha dica seria, use para coisas simples e não coisas complexas! Use ponderadamente. Pois em alguns momentos, o uso excessivo dele pode vir a dificultar mais do que realmente facilitar, ajudar e melhorar sua experiência de desenvolvimento.
Aí talvez, agora você se pergunte: “Eita, com esses pontos destacados, será que posso/devo usar Extension Methods em produção?” Sim, você pode! Mas tenha em mente que não é pra usar em tudo! Apenas usamos em casos de preferência simples e que façam sentido.
Inclusive, usamos Extension Methods no app do iFood para Parceiros que é desenvolvido em Flutter — sim, temos um app no iFood que é desenvolvido em Flutter e eu contei todos os detalhes dessa escolha nesse artigo aqui!
Então, usem Extension Methods com Sabedoria!
Caso queiram saber ainda mais sobre Extension Methods e suas possibilidades, recomendo a leitura dessa documentação e assistir a esse vídeo.
Vlw galera, até a próxima 🙋🏾♂️ 🚀!
Gostou do artigo? Você também pode se interessar por:
- É desenvolvedor(a) mobile? Está eperando o que para ficar rico?
- Utilizando a nova versão do Jetpack Paging
- O que é Redis e como usá-lo ainda hoje
Quer receber artigos como este direto em seu e-mail? Inscreva-se aqui!
