Show And Hide In Import

In Dart, the concept of "show" and "hide" in import statements provides a mechanism to control which parts of a library are visible to the importing file. This feature is particularly useful in large applications where you might want to avoid name clashes or simply reduce the amount of imported code into your file. By selectively importing only the necessary elements, you can enhance code readability and maintainability.

What is "Show and Hide" in Import?

When you import a library in Dart, you can choose to import all its public members or limit the import to specific classes, functions, or variables. The show keyword allows you to specify only the members you want to include, while the hide keyword lets you exclude specific members from the import. This selective importation can help prevent naming conflicts and optimize your codebase.

History/Background

The show and hide features were introduced in Dart to promote modular programming and code organization. As Dart evolved, it became essential for developers to manage dependencies effectively, especially in larger projects. By allowing selective imports, Dart enhances the modularity and clarity of code, making it easier to navigate and maintain.

Syntax

import 'library_name.dart' show Member1, Member2; // Only imports Member1 and Member2
import 'library_name.dart' hide Member3; // Imports everything except Member3

Key Features

Example 1: Basic Usage

// library.dart
library my_library;

class A {
  void methodA() {
    print("Method A");
  }
}

class B {
  void methodB() {
    print("Method B");
  }
}

// main.dart
import 'library.dart' show A; // Only importing class A

void main() {
  A a = A();
  a.methodA(); // Calls methodA from class A
}

Output:

Method A

Example 2: Using Hide

// library.dart
library my_library;

class A {
  void methodA() {
    print("Method A");
  }
}

class B {
  void methodB() {
    print("Method B");
  }
}

// main.dart
import 'library.dart' hide A; // Hiding class A

void main() {
  B b = B();
  b.methodB(); // Calls methodB from class B
}

Output:

Method B

Example 3: Combining Show and Hide

// library.dart
library my_library;

class A {
  void methodA() {
    print("Method A");
  }
}

class B {
  void methodB() {
    print("Method B");
  }
}

class C {
  void methodC() {
    print("Method C");
  }
}

// main.dart
import 'library.dart' show A hide B; // Importing A and hiding B

void main() {
  A a = A();
  a.methodA(); // Calls methodA from class A
  // B b = B(); // This will cause an error as B is hidden
}

Output:

Method A

Comparison Table

Common Mistakes to Avoid

1. Importing Everything

Problem: Beginners often import entire libraries when they only need a single class or function, which can lead to namespace pollution and larger bundle sizes.

// BAD - Don't do this
import 'dart:math'; // Importing the entire library

void main() {
  var result = sqrt(16); // Using 'sqrt' function
}

Solution:

// GOOD - Do this instead
import 'dart:math' show sqrt; // Import only what you need

void main() {
  var result = sqrt(16); // Using 'sqrt' function
}

Why: Importing everything can increase the size of your application unnecessarily and make your code harder to read. Limit your imports to only what’s necessary to keep your codebase clean and efficient.

2. Forgetting to Use 'as' for Namespace Clarity

Problem: Beginners often use classes from different libraries without using the as keyword, which can lead to naming conflicts.

// BAD - Don't do this
import 'package:library1/class.dart';
import 'package:library2/class.dart';

void main() {
  var obj1 = Class(); // What Class is this?
}

Solution:

// GOOD - Do this instead
import 'package:library1/class.dart' as lib1;
import 'package:library2/class.dart' as lib2;

void main() {
  var obj1 = lib1.Class(); // Now it's clear which Class you're using
}

Why: Using as helps maintain clarity in your code, especially when dealing with multiple libraries that might have overlapping class names. This avoids confusion and potential runtime errors.

3. Not Using Conditional Imports

Problem: Beginners may fail to use conditional imports when targeting multiple platforms (e.g., web vs. mobile), leading to code that breaks on certain platforms.

// BAD - Don't do this
import 'package:some_library/some_library.dart';

void main() {
  // Code that may not work on all platforms
}

Solution:

// GOOD - Do this instead
import 'dart:io' show Platform;

void main() {
  if (Platform.isAndroid) {
    import 'package:android_specific/android_library.dart';
  } else {
    import 'package:ios_specific/ios_library.dart';
  }
}

Why: Conditional imports help ensure that your code runs smoothly on all target platforms by only importing the necessary libraries for each platform. This prevents runtime errors and improves code portability.

4. Ignoring Library Documentation

Problem: Beginners often ignore the documentation of libraries they import, leading to misunderstandings about how to use the classes or functions provided.

// BAD - Don't do this
import 'package:some_library/some_library.dart';

void main() {
  // Use classes/functions without understanding their purpose
  var obj = SomeClass(); // Not sure how to use it effectively
}

Solution:

// GOOD - Do this instead
import 'package:some_library/some_library.dart';

void main() {
  // Read the documentation to understand how to use SomeClass effectively
  var obj = SomeClass().initialize(); // Use it according to the documentation
}

Why: Ignoring documentation can lead to inefficient use of libraries and errors in your code. Always read the documentation to understand the intended usage of imported libraries, functions, and classes.

5. Overusing 'show' and 'hide'

Problem: Beginners sometimes overuse the show and hide keywords when importing, leading to confusion and difficulty in maintaining their code.

// BAD - Don't do this
import 'dart:math' hide sqrt, pow; // Overly restrictive import

void main() {
  var result = sqrt(16); // Error: sqrt is not defined
}

Solution:

// GOOD - Do this instead
import 'dart:math' show sqrt; // Import only what's necessary

void main() {
  var result = sqrt(16); // Works correctly
}

Why: While show and hide can help manage your imports, overusing them can lead to confusion about what is available for use. Be judicious in their application to maintain clarity.

Best Practices

1. Use Specific Imports

Using specific imports (e.g., import 'dart:math' show sqrt;) helps keep your namespace clean.

2. Leverage Alias Imports

Utilize the as keyword to alias your imports when dealing with multiple libraries that might share class names.

3. Conditional Imports for Platform-Specific Code

When writing Dart applications targeting multiple platforms, use conditional imports to manage platform-specific code effectively.

4. Consult Documentation Frequently

Refer to the documentation of any library you are importing to understand its functions and classes.

5. Avoid Overusing `show` and `hide`

Be cautious with show and hide when importing to prevent confusion about what is available for use.

6. Keep Imports Organized

Maintain a consistent order for your imports (standard libraries first, then third-party libraries).

Key Points