22 Dart Interview Questions (ANSWERED) Flutter Dev Must Know

Dart is an object-oriented, garbage-collected programming language that you use to develop Flutter apps. It was also created by Google, but is open-source, and has community inside and outside Google. Dart was chosen as the language of Flutter for the following reason:

• Dart is AOT (Ahead Of Time) compiled to fast, predictable, native code, which allows almost all of Flutter to be written in Dart. This not only makes Flutter fast, virtually everything (including all the widgets) can be customized.
• Dart can also be JIT (Just In Time) compiled for exceptionally fast development cycles and game-changing workflow (including Flutter’s popular sub-second stateful hot reload).
• Dart allows Flutter to avoid the need for a separate declarative layout language like JSX or XML, or separate visual interface builders, because Dart’s declarative, programmatic layout is easy to read and visualize. And with all the layout in one language and in one place, it is easy for Flutter to provide advanced tooling that makes layout a snap.

The fat arrow syntax is simply a short hand for returning an expression and is similar to (){ return expression; }.

The fat arrow is for returning a single line, braces are for returning a code block.

Only an expression—not a statement—can appear between the arrow (=>) and the semicolon (;). For example, you can’t put an if statement there, but you can use a conditional expression

// Normal function
void function1(int a) {
  if (a == 3) {
    print('arg was 3');
  } else {
    print('arg was not 3');
  }
}

// Arrow Function
void function2(int a) => print('arg was ${a == 3 ? '' : 'not '}3');

Both named and positional parameters are part of optional parameter:

Optional Positional Parameters:

• A parameter wrapped by [ ] is a positional optional parameter.

  	```dart
  	getHttpUrl(String server, String path, [int port=80]) {
  	  // ...
  	}
  	```

• You can specify multiple positional parameters for a function:

  	```dart
  	getHttpUrl(String server, String path, [int port=80, int numRetries=3]) {
  	  // ...
  	}
  	```
  	In the above code, `port` and `numRetries` are optional and have default values of 80 and 3 respectively. You can call `getHttpUrl` with or without the third parameter.  The optional parameters are  _positional_  in that you can't omit  `port`  if you want to specify  `numRetries`.

Optional Named Parameters:

• A parameter wrapped by { } is a named optional parameter.

  	```dart
  	getHttpUrl(String server, String path, {int port = 80}) {
  	  // ...
  	}
  	```

• You can specify multiple named parameters for a function:

  	```dart
  	getHttpUrl(String server, String path, {int port = 80, int numRetries = 3}) {
  	  // ...
  	}
  	```
  	You can call `getHttpUrl` with or without the third parameter. You **must** use the parameter name when calling the function.

• Because named parameters are referenced by name, they can be used in an order different from their declaration.

  	```dart
  	getHttpUrl('example.com', '/index.html', numRetries: 5, port: 8080);
  	getHttpUrl('example.com', '/index.html', numRetries: 5);
  	```

Required Parameters

Dart required parameters are the arguments that are passed to a function and the function or method required all those parameters to complete its code block.

findVolume(int length, int breath, int height) {
 print('length = $length, breath = $breath, height = $height');
}

findVolume(10,20,30);

Optional Parameters

• Optional parameters are defined at the end of the parameter list, after any required parameters.
• In Flutter/Dart, there are 3 types of optional parameters: - Named - Parameters wrapped by { } - eg. getUrl(int color, [int favNum]) - Positional - Parameters wrapped by [ ]) - eg. getUrl(int color, {int favNum}) - Default - Assigning a default value to a parameter. - eg. getUrl(int color, [int favNum = 6])

There are two kinds of streams. 1. Single subscription streams - The most common kind of stream. - It contains a sequence of events that are parts of a larger whole. Events need to be delivered in the correct order and without missing any of them. - This is the kind of stream you get when you read a file or receive a web request. - Such a stream can only be listened to once. Listening again later could mean missing out on initial events, and then the rest of the stream makes no sense. - When you start listening, the data will be fetched and provided in chunks.

2. Broadcast streams
   • It intended for individual messages that can be handled one at a time. This kind of stream can be used for mouse events in a browser, for example.
   • You can start listening to such a stream at any time, and you get the events that are fired while you listen.
   • More than one listener can listen at the same time, and you can listen again later after canceling a previous subscription.

Changing the return type to Future<void>.

Future<void> save(Folder folder) async {  
   .....
}

Then you can do await save(...); or save().then(...);

• .whenComplete will fire a function either when the Future completes with an error or not, while .then returns a new Future which is completed with the result of the call to onValue (if this future completes with a value) or to onError (if this future completes with an error)
• .whenCompleted is the asynchronous equivalent of a "finally" block.

Using collection-for if we need different instances of Ball()

final List<Ball> _ballList = [
  for (var i = 0; i < 5; i += 1) Ball(),
];

If we need the same instance of Ball(), List.filled should be used

final List<Ball> _ballList = List<Ball>.filled(5, Ball());

Async functions are normal functions with some sugar on top. The function variable type just needs to specify that it returns a Future:

class Example {
  Future<void> Function() asyncFuncVar;
  Future<void> asyncFunc() async => print('Do async stuff...');

  Example() {
    asyncFuncVar = asyncFunc;
    asyncFuncVar().then((_) => print('Hello'));
  }
}

void main() => Example();

You can do something like this:

List<double> first = [1,2,3,4,5,6,7];
List<double> second = [3,5,6,7,9,10];
List<double> output = first.where((element) => !second.contains(element));

alternative answer:

List<double> first = [1,2,3,4,5,6,7];
List<double> second = [3,5,6,7,9,10];
List<double> output = [];

first.forEach((element) {
    if(!second.contains(element)){
    output.add(element);
}
});

//at this point, output list should have the answer

note that for both cases, you need to loop over the larger list.

• Asynchronous programming in Dart is characterized by the Future and Stream classes.
• A stream is a sequence of asynchronous events. It is like an asynchronous Iterable—where, instead of getting the next event when you ask for it, the stream tells you that there is an event when it is ready.
• Streams can be created in many ways but they all are used in the same way; the asynchronous for loop( await for). E.g

	Future<int> sumStream(Stream<int> stream) async {
	  var sum = 0;
	  await for (var value in stream) {
	    sum += value;
	  }
	  return sum;
	}

• Streams provide an asynchronous sequence of data.
• Data sequences include user-generated events and data read from files.
• You can process a stream using either await for or listen() from the Stream API.
• Streams provide a way to respond to errors.
• There are two kinds of streams: single subscription or broadcast.

• Dart offers some handy operators for dealing with values that might be null.
• One is the ??= assignment operator, which assigns a value to a variable only if that variable is currently null:

	int a; // The initial value of a is null.
	a ??= 3;
	print(a); // <-- Prints 3.

	a ??= 5;
	print(a); // <-- Still prints 3.

• Another null-aware operator is ??, which returns the expression on its left unless that expression’s value is null, in which case it evaluates and returns the expression on its right:

	print(1 ?? 3); // <-- Prints 1.
	print(null ?? 12); // <-- Prints 12.