What is the difference between “show” and “as” in

问题:

What is the difference between show and as in an import statement?

For example, what's the difference between

import 'dart:convert' show JSON;

and

import 'package:google_maps/google_maps.dart' as GoogleMap;

When do I use show and when should I use as?

If I switch to show GoogleMap all references to GoogleMap (e.g. GoogleMap.LatLng) objects are reported as undefined.

回答1:

as and show are two different concepts.

With as you are giving the imported library a name. It's usually done to prevent a library from polluting your namespace if it has a lot of global functions. If you use as you can access all functions and classes of said library by accessing them the way you did in your example: GoogleMap.LatLng.

With show (and hide) you can pick specific classes you want to be visible in your application. For your example it would be:

import 'package:google_maps/google_maps.dart' show LatLng;

With this you would be able to access LatLng but nothing else from that library. The opposite of this is:

import 'package:google_maps/google_maps.dart' hide LatLng;

With this you would be able to access everything from that library except for LatLng.

If you want to use multiple classes with the same name you'd need to use as. You also can combine both approaches:

import 'package:google_maps/google_maps.dart' as GoogleMap show LatLng;

回答2:

show case:

import 'dart:async' show Stream;

This way you only import Stream class from dart:async, so if you try to use another class from dart:async other than Stream it will throw an error.

void main() {
  List data = [1, 2, 3];
  Stream stream = new Stream.fromIterable(data); // doable
  StreamController controller = new StreamController(); // not doable
                                                        // because you only show Stream
}

as case:

import 'dart:async' as async;

This way you import all class from dart:async and namespaced it with async keyword.

void main() {
  async.StreamController controller = new async.StreamController(); // doable
  List data = [1, 2, 3];
  Stream stream = new Stream.fromIterable(data); // not doable
                                                 // because you namespaced it with 'async'
}

as is usually used when there are conflicting classes in your imported library, for example if you have a library 'my_library.dart' that contains a class named Stream and you also want to use Stream class from dart:async and then:

import 'dart:async';
import 'my_library.dart';

void main() {
  Stream stream = new Stream.fromIterable([1, 2]);
}

This way, we don't know whether this Stream class is from async library or your own library. We have to use as :

import 'dart:async';
import 'my_library.dart' as myLib;

void main() {
  Stream stream = new Stream.fromIterable([1, 2]); // from async
  myLib.Stream myCustomStream = new myLib.Stream(); // from your library
}

For show, I guess this is used when we know we only need a specific class. Also can be used when there are conflicting classes in your imported library. Let's say in your own library you have a class named CustomStream and Stream and you also want to use dart:async, but in this case you only need CustomStream from your own library.

import 'dart:async';
import 'my_library.dart';

void main() {
  Stream stream = new Stream.fromIterable([1, 2]); // not doable
                                                   // we don't know whether Stream 
                                                   // is from async lib ir your own
  CustomStream customStream = new CustomStream();// doable
}

Some workaround:

import 'dart:async';
import 'my_library.dart' show CustomStream;

void main() {
  Stream stream = new Stream.fromIterable([1, 2]); // doable, since we only import Stream
                                                   // async lib
  CustomStream customStream = new CustomStream();// doable
}