// 15 Essential Flutter Interview Questions

The state of a widget changes when you rebuild it. This is beneficial because it allows the user to see the UI reflect state changes. However, recreating sections of the user interface that do not need to change is wasteful.

There are various things you can do to limit unnecessary widget rebuilding. The first step is to divide a huge widget tree into smaller individual widgets, each with its build process. Use the const constructor whenever possible to convince Flutter that the widget does not need to be rebuilt.

Keep a stateful widget's subtree as minimal as possible. If a stateful widget requires a widget subtree, construct a custom widget for the stateful widget and provide it with a child parameter.

Whenever a method contains a single line of code, it can easily be shortened by returning the result. However, we don’t use the keyword return when using =>.

The makeCoffee() conversion would be:

int get coffee => coffeeBean + milk;

Using the underscore _ as a prefix to the variable name makes it a private variable within the library:

class Milkshake {
  String _milk = 'almond milk';
}

The Dart programming language does not have the concept of private class variables. A library generally can contain multiple classes.

On the other hand, global variables can be made by just moving a variable outside the class:

String _milk = 'almond milk';

When you put it outside the class, it becomes a top-level variable that is available wherever you import the file.

Global variables are often frowned upon because it's easy to lose track of what's changing them. This complicates debugging and testing. They can, however, be advantageous at times, such as when:

• You're putting together a brief demo that you're not going to maintain
• Making Singletons to deliver services such as a database or a network authenticator.
• Creating const variables to share colors, measurements, styles, and themes. These global variables are frequently saved in a separate file, such as constants.dart, which is subsequently imported by the libraries.

It prevents your program from running since counting to one billion is a computationally-intensive process, even for a machine.

Dart code executes within its own section of memory known as an isolate (also known as a memory thread). Each isolate has its own memory heap, ensuring that no isolate can access the state of another isolate.

Making it an async function would also be ineffective because it would continue to run on the same isolate.

You can fix this by running the code on a different isolate:

Future makeSomeoneElseCountForMe() async {
  return await compute(countUp, 100000000);
}

String countUp(int countTo) {
  var counting = 0;
  for (var i = 1; i <= countTo; i++) {
    counting = i;
  }
  return '$Counting over! That's it!';
}

Wrapping the Text widget in an Expanded widget instructs Row to disregard the Text widget's intrinsic width and instead assign it a width based on the available space in the row.

When you use more than one Expanded widget in a Row, Column, or Flex, the space is evenly divided across all the Expanded widgets. So, when there is more than one Expanded widget, use flex to prioritise space allocations

Bonus points if you additionally use the Text widget's overflow property.

Expanded(
  child: Text(
    personNextToMe,
  ),
),

The transformed stream looks like this:

final fishStream = FishHatchery().stream;
final sushiStream = fishStream
    .where((fish) => fish == 'salmon')
    .map((fish) => 'sushi')
    .take(5);

Hot reload keeps the app state while upgrading the UI almost immediately.

Hot restart, on the other hand, takes a little longer because it restores the app's state before updating the UI. Both are quicker than a full restart, which necessitates recompiling the app.

However, both hot restart and hot reload require you to stop and restart the app after making big changes.

StatelessWidget is an immutable class that serves as a prototype for various UI elements. It is used when the widget does not change while displaying and so has no State.

StatefulWidget is also immutable, but it is linked to a State object, which allows you to rebuild the widget with new values whenever setState() is called. When the UI can change dynamically, use StatefulWidget.

If the state becomes more complex or the same state appears in two different widgets, you should investigate a more advanced state management solution.

Yes, it is possible to nest a Scaffold.

The Scaffold is just a widget, so it can go everywhere a widget can. You may layer drawers, snack bars, and bottom sheets by nesting Scaffolds.

For Example:

import 'package:flutter/material.dart';

void main() {
  runApp(MaterialApp(
    title: 'Navigation',
    home: FirstRoute(),
  ));
}

class FirstRoute extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('First Route'),
      ),
      body: Scaffold(
        body: Center(
          child: RaisedButton(
            child: Text('Get directions'),
            onPressed: () {},
          ),
        ),
      ),
    );
  }
}

The main() method originated in Java-like languages, and it is where all programs begin; without it, you cannot develop any program on Flutter, even without UI.

The runApp() function should produce a Widget that will be attached to the screen as the root of the displayed Widget Tree.

We first need a simple import.

import 'package:flutter/foundation.dart' as Foundation;

Then you can use kReleaseMode as follows:

if(Foundation.kReleaseMode){
	print('In release mode!');
} else {
	print('In debugging mode');
}

While asserts can technically be used to manually create an "is debug mode" variable, you should avoid that. The issue with asserts is that our isInReleaseMode boolean is not a constant. So when shipping our app, both the dev and release code are included.

On the other hand, kReleaseMode is a constant. Therefore the compiler is correctly able to remove unused code.

The Future and Stream classes in Dart define asynchronous programming. A stream is an asynchronous sequence of events. It is similar to an asynchronous Iterable in that, instead of returning the next event when requested, the stream informs you that an event will be returned when it is ready.

Streams can be built in a variety of methods, but they always serve the same purpose: the asynchronous for loop (await for).

This is a simple example:

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

Streams provide numerous benefits:

1. Streams provide an asynchronous data series.
2. They allow user-generated events and data retrieved from files in the form of data sequences.
3. Moreover, the Stream API allows you to process a stream using either await for or listen().
4. Streams also allow you to respond to errors.

Dart includes handy operators for dealing with null values.

The ??= assignment operator only assigns a value to a variable when it is null.

int a; // Initial value of a is null.  
a ??= 10;  
print(a); 

This will print 10.

Dart’s ?? null-aware operator evaluates and returns the value of two expressions. It first verifies expression 1 and returns its value if it is not null; otherwise, it evaluates and returns the result of expression 2:

print(3 ?? 10);  
print(null ?? 10); 

The first line here will print 3 and the second line will print 5.

Although the Form is present, there is no method for users to enter text. That is the function of a TextFormField. The TextFormField widget displays validation errors and renders a material design text field.

You can validate the TextFormField input by providing a validator() function. The validator method returns a string containing an error message if the user's input is invalid. If no mistakes are found, the validator must return null.

Here’s how it’s done:

TextFormField(
  validator: (value) {
    if (value == null || value.isEmpty) {
      return 'You did not enter any text. Please enter some text.';
    }
    return null;
  },
),

This code creates a validator that ensures the TextFormField isn’t empty. If it is empty, it returns a friendly error message.

This constructor allows a flutter developer to work with images from a URL. It also supports animated gifs. The following is an example call:

Image.network(URL)

Where URL is the URL of the image.

Note that the default Image.network() constructor doesn’t handle more advanced functionality, such as fading images after loading, or caching images to the device after they’re downloaded.