Qual è la differenza tra "mostra" e "come" in una dichiarazione di importazione?

Question

Qual è la differenza tra show e as in una dichiarazione di importazione?

Per esempio, qual è la differenza tra

import 'dart:convert' show JSON; 

e

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

Quando posso utilizzare show e quando devo usare as?

Se passaggio a show GoogleMap tutti i riferimenti a GoogleMap (ad esempio GoogleMap.LatLng) gli oggetti sono segnalati come non definiti.

Answer 1

as e show sono due concetti diversi.

Con as si sta dando un nome alla libreria importata. Di solito è fatto per impedire a una libreria di inquinare il tuo spazio dei nomi se ha un sacco di funzioni globali. Se si utilizza as, è possibile accedere a tutte le funzioni e le classi di detta libreria accedendovi come nel proprio esempio: GoogleMap.LatLng.

Con show (e hide) è possibile selezionare classi specifiche che si desidera siano visibili nella propria applicazione. Per il tuo esempio sarebbe:

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

Con questo si sarebbe in grado di accedere LatLng ma nient'altro da quella libreria. L'opposto di questo è:

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

Con questo si sarebbe in grado di accedere a tutto, da quella libreria tranne LatLng.

Se si desidera utilizzare più classi con lo stesso nome, è necessario utilizzare as. È inoltre possibile combinare i due approcci:

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

Answer 2

show caso:

import 'dart:async' show Stream;

In questo modo si importa solo Stream classe da dart:async, quindi se si tenta di utilizzare un'altra classe da dart:async diverso Stream esso genererà un errore.

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 caso:

import 'dart:async' as async;

In questo modo si importano tutte le classi da dart:async e namespace con async parola chiave.

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 di solito è usato quando ci sono classi in conflitto nella vostra libreria importata, ad esempio se si dispone di un 'my_library biblioteca.dardo' che contiene una classe denominata Stream e si vogliono anche usare Stream classe da dart:async e poi:

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

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

In questo modo, non sappiamo se questa classe Stream è dalla libreria asincrona o la vostra libreria. Dobbiamo usare 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 
} 

Per show, credo che questo viene utilizzato quando sappiamo abbiamo solo bisogno di una classe specifica. Inoltre può essere utilizzato quando ci sono classi in conflitto nella libreria importata. Diciamo che nella tua libreria hai una classe chiamata CustomStream e Stream e anche tu vuoi usare dart:async, ma in questo caso hai solo bisogno di CustomStream dalla tua libreria.

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 
} 

Alcuni soluzione:

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 
}