equatable 0.1.9 copy "equatable: ^0.1.9" to clipboard
equatable: ^0.1.9 copied to clipboard

outdated

An abstract class that helps to implement equality without needing to explicitly override == and hashCode.

logo

Simplify Equality Comparisons

Build Status Code Coverage Pub Package
MIT License Gitter


Overview #

Being able to compare objects in Dart often involves having to override the == operator as well as hashCode.

Not only is it verbose and tedious, but failure to do so can lead to inefficient code which does not behave as we expect.

By default, == returns true if two objects are the same instance.

Let's say we have the following class:

class Person {
  final String name;

  const Person(this.name);
}

We can create create instances of Person like so:

void main() {
  final Person bob = Person("Bob");
}

Later if we try to compare two instances of Person either in our production code or in our tests we will run into a problem.

print(bob == Person("Bob")); // false

For more information about this, you can check out the official Dart Documentation.

In order to be able to compare two instances of Person we need to change our class to override == and hashCode like so:

class Person {
  final String name;

  const Person(this.name);

  @override
  bool operator ==(Object other) =>
    identical(this, other) ||
    other is Person &&
    runtimeType == other.runtimeType &&
    name == other.name;

  @override
  int get hashCode => name.hashCode;
}

Now if we run the following code again:

print(bob == Person("Bob")); // true

it will be able to compare different instances of Person.

You can see how this can quickly become a hassle when dealing with complex classes. This is where Equatable comes in!

What does Equatable do? #

Equatable overrides == and hashCode for you so you don't have to waste your time writing lots of boilerplate code.

There are other packages that will actually generate the boilerplate for you; however, you still have to run the code generation step which is not ideal.

With Equatable there is no code generation needed and we can focus more on writing amazing applications and less on mundane tasks.

Usage #

First, we need to do add equatable to the dependencies of the pubspec.yaml

dependencies:
  equatable: ^0.1.0

Next, we need to install it:

# Dart
pub get

# Flutter
flutter packages get

Lastly, we need to extend Equatable

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  final String name;

  Person(this.name) : super([name]);
}

We can now compare instances of Person just like before without the pain of having to write all of that boilerplate.

Recap #

Without Equatable #

class Person {
  final String name;

  const Person(this.name);

  @override
  bool operator ==(Object other) =>
    identical(this, other) ||
    other is Person &&
    runtimeType == other.runtimeType &&
    name == other.name;

  @override
  int get hashCode => name.hashCode;
}

With Equatable #

import 'package:equatable/equatable.dart';

class Person extends Equatable {
  final String name;

  Person(this.name) : super([name]);
}

Performance #

You might be wondering what the performance impact will be if you use Equatable.

Performance Tests have been written to test how Equatable stacks up to manually overriding == and hashCode in terms of class instantiation as well as equality comparison.

Results (average over 10 runs) #

Equality Comparison A == A

Class Runtime (microseconds)
RAW 0.143
Empty Equatable 0.124
Hydrated Equatable 0.126

Instantiation A()

Class Runtime (microseconds)
RAW 0.099
Empty Equatable 0.121
Hydrated Equatable 0.251
2880
likes
0
pub points
100%
popularity

Publisher

verified publisherfluttercommunity.dev

An abstract class that helps to implement equality without needing to explicitly override == and hashCode.

Repository (GitHub)
View/report issues

License

unknown (LICENSE)

More

Packages that depend on equatable