Dart interview questions with detailed answers

In Dart, variables can be declared using the var, dynamic, and final keywords.

• var: Variables declared using var are inferred to be the type of the value that is assigned to them.
• dynamic: Variables declared using dynamic can hold any type of value.
• final: Variables declared using final are similar to const variables, but their values can be set only once.

Here's an example of how to declare variables in Dart:

var x = 5; // inferred as int
dynamic y = "hello";
final z = true;

Dart has a strong type system and by default, it does not allow null values. To express that a variable can have null value, it needs to be explicitly declared as nullable. For example, a variable can be declared as int? or String?. Dart also provides the ?? null-aware operator, which returns the left-hand side operand if it is non-null and the right-hand side operand otherwise.

Here's an example of how to use the ?? operator:

int count;
print(count ?? 0); // prints 0

In Dart, lists can be created using the List class. They can be initialized using the [] operator or the List() constructor.

Here's an example of how to create and initialize a list in Dart:

List<int> numbers = [1, 2, 3];
List<String> fruits = new List();

In Dart, maps can be created using the Map class. They can be initialized using the {} operator or the Map() constructor.

Here's an example of how to create and initialize a map in Dart:

Map<String, int> scores = {"Alice": 10, "Bob": 20};
Map<String, String> user = new Map();

In Dart, classes are defined using the class keyword and they can contain properties, methods and constructors. To create an object of a class, the new keyword is used along with the class name.

Here's an example of how to create and use a class and its object in Dart:

class Person {
  String name;
  int age;
  Person(this.name, this.age);
  void sayHello() {
    print("Hello, my name is $name and I am $age years old.");
  }
}

var me = new Person("John", 30);
me.sayHello(); // Output: Hello, my name is John and I am 30 years old.

In this example, the Person class has two properties name and age and a constructor that assigns them from the constructor's arguments. It also has a method sayHello that prints a message using the class properties.

In Dart, a constructor is a special method that is used to create and initialize an object. It is called when an object of a class is created and it allows the developer to set the initial state of the object. A constructor is defined using the constructor keyword and it can be parameterized or not.

On the other hand, a factory constructor is a constructor that returns an instance of the same class or a subclass. It is useful when the class is not able to create the object directly, for example when the class is abstract. A factory constructor is defined using the factory keyword before the constructor name.

Here's an example of how to use a constructor and a factory constructor in Dart:

class Point {
  int x, y;
  Point(this.x, this.y);
  factory Point.fromJson(Map<String, num> json) {
    return Point(json['x'], json['y']);
  }
}

In this example, the class Point has a constructor that takes two int arguments and assigns them to the class properties x and y. And also it has a factory constructor that takes a Map<String, num> argument and create an instance of the class Point from it.

In Dart, the switch statement is used to evaluate a value and execute a specific block of code depending on its value. The switch statement is followed by an expression and a number of case clauses, each one with its own value. The last clause can be default clause which execute if no case match.

Here's an example of how to use the switch statement in Dart:

int grade = 80;

switch (grade) {
  case 100:
    print("A+");
    break;
  case 90:
    print("A");
    break;
  case 80:
    print("B");
    break;
  default:
    print("Failed");
}

In this example, the value of grade is evaluated in the switch statement and the corresponding case is executed. If the value of grade is 80 the output will be "B"

In dart, the for loop is used to execute a block of code for a specific number of times. The for loop consists of a counter variable, a condition and an increment/decrement statement.

Here's an example of how to use the for loop in Dart:

for (var i = 0; i < 5; i++) {
    print(i);
}

In this example, the for loop starts with an initial value of 0 for the counter variable i, continues as long as i is less than 5 and increment the value of i by 1 after each iteration. The output will be the numbers from 0 to 4.

You can also use the for-in loop to iterate over the elements of an iterable, such as a list or a map:

List<String> fruits = ['Apple', 'Banana', 'Mango'];
for (String fruit in fruits) {
    print(fruit);
}

In this example, the for-in loop iterates over the elements of the fruits list, assigns each element to the variable fruit and prints the value of fruit in each iteration.

In Dart, the while loop is used to execute a block of code while a certain condition is true. The do-while loop is similar to the while loop but it guarantees that the block of code inside the loop will be executed at least once.

Here's an example of how to use the while and do-while loops in Dart:

int counter = 0;
while (counter < 5) {
    print(counter);
    counter++;
}

int counter = 0;
do {
    print(counter);
    counter++;
} while (counter < 5);

In this example, the while loop starts with an initial value of 0 for the counter variable and continues as long as counter is less than 5. It increments the value of counter by 1 after each iteration. The output will be the numbers from 0 to 4.

The do-while loop is similar, but the block of code inside the loop is executed at least once before checking the condition. The output will also be the numbers from 0 to 4.

In Dart, the break keyword is used to exit a loop early and the continue keyword is used to skip an iteration of a loop.

Here's an example of how to use the break and continue keywords in Dart:

for (var i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    if (i % 2 == 0) {
        continue;
    }
    print(i);
}

In this example, the for loop starts with an initial value of 0 for the counter variable i and continues as long as i is less than 10. If the value of i is equal to 5, the break statement is executed and the loop is exited. If the value of i is even, the continue statement is executed and the current iteration is skipped. As a result, the output will be the odd numbers from 1 to 4 and the loop will exit as soon as it reaches the value of 5.

In addition, the break keyword can also be used to exit a switch statement early, and the continue keyword can be used to skip an iteration in a for loop or a while loop.

In Dart, the try-catch statement is used to handle exceptions that might occur in a block of code. The try block encloses the code that might throw an exception and the catch block handles the exception if one occurs.

Here's an example of how to use the try-catch statement in Dart:

void divide(int a, int b) {
  try {
    print(a ~/ b);
  } catch (e) {
    print("An error occurred: $e");
  }
}

In this example, the divide function takes two integers as input and performs an integer division. The try block encloses the division operation, which might throw an exception if the second argument is zero. The catch block catches any exception that might occur and prints an error message.

In Dart, a class can inherit from another class using the extends keyword. The class that is inherited from is called the superclass or parent class, and the class that inherits is called the subclass or child class. A subclass inherits all the properties, methods and constructors from its superclass.

Here's an example of how to use inheritance in Dart:

class Animal {
  int legs;
  Animal(this.legs);
}

class Dog extends Animal {
  String breed;
  Dog(this.breed, int legs) : super(legs);
  void bark() {
    print("Woof woof!");
  }
}

var myDog = new Dog("Golden Retriever", 4);
print(myDog.legs); // Output: 4
myDog.bark(); // Output: Woof woof!

In this example, the Dog class inherits from the Animal class and it also has an additional property breed and a method bark. The constructor of the Dog class takes two arguments, breed and legs, and assigns them to the corresponding properties. The super(legs) call in the constructor is used to call the constructor of the superclass and pass the legs argument to it.

In Dart, polymorphism allows objects of different classes to be treated as objects of a common superclass. This is achieved by using interfaces or abstract classes. An interface defines a set of methods that a class must implement, and an abstract class can define both methods and properties.

Here's an example of how to use polymorphism in Dart:

abstract class Shape {
  double getArea();
}

class Square extends Shape {
  double side;
  Square(this.side);
  double getArea() => side * side;
}

class Circle extends Shape {
  double radius;
  Circle(this.radius);
  double getArea() => 3.14 * radius * radius;
}

List<Shape> shapes = [Square(10), Circle(5)];
shapes.forEach((shape) => print(shape.getArea()));

In this example, the Shape class is an abstract class that defines a getArea method. The Square and Circle classes extend the Shape class and implement the getArea method in their own way. The shapes list is a list of Shape type, but it contains objects of the Square and Circle classes. The forEach method is used to iterate over the list and call the getArea method on each object, which is polymorphic and calls the appropriate implementation for each object.

In Dart, exceptions are handled using the try, catch, and finally keywords. The try block is used to enclose the code that might throw an exception, the catch block is used to handle the exception, and the finally block is used to execute code regardless of whether an exception is thrown or not.

Here's an example of how to handle exceptions in Dart:

void divide(int a, int b) {
  try {
    print(a ~/ b);
  } on IntegerDivisionByZeroException {
    print("Cannot divide by zero.");
  } catch (e) {
    print("An error occurred: $e");
  } finally {
    print("This is always executed.");
  }
}

In this example, the divide function takes two integers as input and performs an integer division. The try block encloses the division operation, which can throw an IntegerDivisionByZeroException if the second argument is zero. The on block is used to catch this specific exception and print a message. The catch block is used to catch any other exception that might be thrown and print the error message. The finally block is used to execute a piece of code regardless of whether an exception is thrown or not.

In Dart, the assert statement is used to check if a certain condition is true and throw an exception if it is not. The assert statement is usually used for debugging and testing purposes.

Here's an example of how to use the assert statement in Dart:

void checkAge(int age) {
  assert(age >= 18);
  print("You are an adult");
}

In this example, the checkAge function takes an integer as input and checks if the value is greater than or equal to 18 using the assert statement. If the value is not greater than or equal to 18, an exception is thrown with a message "age >= 18" that can be captured by try-catch block.

In Dart, the final keyword is used to indicate that a variable or a property can only be set once. Once a final variable or property is set, it cannot be changed.

Here's an example of how to use the final keyword in Dart:

final name = 'John Doe';
name = 'Jane Doe'; // error: a final variable cannot be changed

In this example, the name variable is declared as final and initialized with the value John Doe. Attempting to change the value of a final variable will result in a compile-time error.

In Dart, the const keyword is used to indicate that a variable or a property is a compile-time constant. A compile-time constant is a value that is known at compile-time and cannot be changed at runtime.

Here's an example of how to use the const keyword in Dart:

const pi = 3.14;
print(pi); // Output: 3.14

In this example, the pi variable is declared as a compile-time constant and initialized with the value 3.14. The value of pi cannot be changed at runtime and attempting to do so will result in a compile-time error.

It's also worth noting that in addition to variables, const can also be used for instantiating objects or creating collections that are guaranteed to be immutable.

const point = Point(1, 2);
final point2 = Point(1, 2);

const list = [1, 2, 3];
final list2 = [1, 2, 3];

Here, point is a compile-time constant and point2 is a runtime constant, but both are immutable. Similarly, list is a compile-time constant and list2 is a runtime constant but both are immutable.

In Dart, the new keyword is used to create an instance of a class. The new keyword is optional when creating an instance of a class, but it is recommended to use it for clarity.

Here's an example of how to use the new keyword in Dart:

class Person {
  String name;

  Person(this.name);
}

var person1 = new Person("John Doe");
var person2 = Person("Jane Doe");

In this example, the Person class has a constructor that takes a single argument name. The new keyword is used to create an instance of the Person class and assign it to the person1 variable. The new keyword is also optional and can be omitted when creating an instance of the Person class, as shown with the person2 variable.

In Dart, the .. cascade notation is used to chain multiple operations on an object. The .. operator is used to invoke multiple methods or set multiple properties on an object in a single line of code.

Here's an example of how to use the .. cascade notation in Dart:

var person = new Person("John Doe")
  ..age = 30
  ..address = "New York";

In this example, the .. operator is used to invoke multiple setters on the person object. The age and address properties are set to 30 and "New York" respectively.

In Dart, JSON data can be parsed and converted using the dart:convert library. The jsonDecode function can be used to parse a JSON string and convert it to a Map or a List object. The jsonEncode function can be used to convert a Map or a List object to a JSON string.

Here's an example of how to parse and convert JSON data in a Dart application:

String jsonString = '{"name": "John Doe", "age": 30}';
Map<String, dynamic> jsonData = jsonDecode(jsonString);

print(jsonData["name"]); // Output: "John Doe"
print(jsonData["age"]); // Output: 30

Map<String, dynamic> jsonData2 = {"name": "Jane Doe", "age": 25};
String jsonString2 = jsonEncode(jsonData2);

print(jsonString2); // Output: '{"name":"Jane Doe","age":25}

In this example, the jsonDecode function is used to parse the JSON string jsonString and convert it to a Map object jsonData. The jsonData object can then be accessed like a regular map, using the key to retrieve the value.

The jsonEncode function is used to convert the Map object jsonData2 to a JSON string jsonString2.

It's also worth noting that in some cases, you may want to use a custom JsonConverter to handle the decoding and encoding of JSON data. This is particularly useful when working with complex JSON structures or custom data models.

In Dart, the => fat arrow notation is used to define a shorthand syntax for a single-line function. The => operator separates the function's parameters from its body.

Here's an example of how to use the => fat arrow notation in Dart:

var addNumbers = (int a, int b) => a + b;
print(addNumbers(1, 2)); // Output: 3

In this example, the addNumbers function takes two integers as input and returns their sum. Instead of writing the function body in curly braces {}, we use the fat arrow notation => followed by the function body a + b. This shorthand syntax makes the code more concise and easier to read.

You can also use the fat arrow notation for functions that don't take any arguments or return any value:

var printHello = () => print("Hello!");
printHello();

In this example, the printHello function doesn't take any arguments and returns null. It simply prints "Hello!" when invoked.

In Dart, the async and await keywords are used to handle asynchronous programming. The async keyword is used to mark a function as asynchronous, which means that it can run concurrently with other code. The await keyword is used to wait for the result of an asynchronous operation before continuing the execution of the code.

Here's an example of how to use the async and await keywords in Dart:

Future<String> fetchData() async {
  var response = await http.get('https://example.com/data');
  return response.body;
}

void main() async {
  var data = await fetchData();
  print(data);
}

In this example, the fetchData function is marked as asynchronous and it uses the await keyword to wait for the result of an HTTP request before returning the response body. The main function also uses the await keyword to wait for the result of the fetchData function before printing it.

In Dart, streams are used to handle asynchronous data sequences. A stream is a sequence of data events that can be listened to. The Stream class is used to create streams and the StreamController class is used to control the events of a stream.

Here's an example of how to create and use a stream in Dart:

var controller = new StreamController();
var stream = controller.stream;
stream.listen((data) => print(data));
controller.add(1);
controller.add(2);
controller.add(3);

In this example, the StreamController class is used to create a stream stream and a stream controller controller. The listen method is used to listen to the events of the stream and the add method is used to add events to the stream.

In Dart, a Future is an object that represents a delayed computation. A Future can be in one of three states: unfulfilled (pending), fulfilled (completed successfully), or rejected (completed with an error). The Future class is used to create Futures and the then and catchError methods are used to handle the outcome of a Future.

Here's an example of how to work with Futures in Dart:

Future<String> fetchData() async {
  var response = await http.get('https://example.com/data');
  return response.body;
}

void main() {
  fetchData().then((data) => print(data))
    .catchError((error) => print("An error occurred: $error"));
}

In this example, the fetchData function returns a Future that will be fulfilled with the response body of an HTTP request. The then method is used to handle the successful outcome of the Future and the catchError method is used to handle any errors that might occur.

In Dart, asynchronous code execution allows you to perform multiple tasks simultaneously, without blocking the execution of other code. Dart supports asynchronous programming using the async and await keywords.

The async keyword is used to mark a function as asynchronous and the await keyword is used to wait for the completion of an asynchronous operation.

Here's an example of how to handle async and synchronous code execution in Dart:

Future<void> fetchData() async {
  var response = await http.get('https://example.com/data');
  print(response.body);
}

void main() {
  fetchData();
  print("Fetching data...");
}

In this example, the fetchData function is marked as asynchronous using the async keyword. The await keyword is used to wait for the completion of the HTTP request before printing the response body. The main function calls the fetchData function and prints "Fetching data..." while the data is being fetched. This way, the execution of main function won't be blocked while waiting for the response.

It is important to note that code after the await keyword will only execute after the Future is completed.

In Dart, errors in asynchronous code can be handled using the catchError method on a Future or the onError property on a Stream.

Here's an example of how to handle errors in asynchronous code using the catchError method:

Future<void> fetchData() async {
  try {
    var response = await http.get('https://example.com/data');
    print(response.body);
  } catch (e) {
    print("An error occurred: $e");
  }
}

In this example, the try-catch statement is used to catch any errors that might occur while fetching data. The catch block prints an error message with the exception e.

Here's an example of how to handle errors in asynchronous code using the onError property:

Stream<int> countStream() {
  return Stream.periodic(Duration(seconds: 1), (i) => i)
    .take(5)
    .handleError((error) {
      print("An error occurred: $error");
    });
}

In this example, the handleError method is used to catch any errors that might occur while counting. The handleError block prints an error message with the exception error.

In Dart, the listen method is used to start listening to a Stream and the cancel method is used to stop listening.

Here's an example of how to use the listen and cancel methods in a Stream:

Stream<int> countStream() {
  return Stream.periodic(Duration(seconds: 1), (i) => i)
    .take(5);
}

var subscription = countStream().listen((data) {
  print(data);
});

// later
subscription.cancel();

In this example, the countStream function returns a stream that emits an increasing integer every second for a total of 5 times. The listen method is used to start listening to the stream and the print(data) callback is executed every time a new value is emitted. The subscription variable holds a reference to the subscription, so it can be used to stop listening to the stream later on by calling the cancel() method.

It's also worth noting that the listen method returns a StreamSubscription object that can be used to pause and resume the stream using the pause and resume methods, respectively.

In a Flutter application, real-time data streams can be handled using the StreamBuilder widget. The StreamBuilder widget takes a stream as an input and rebuilds the widget tree every time a new value is emitted.

Here's an example of how to use the StreamBuilder widget to handle real-time data streams in a Flutter application:

Stream<int> countStream() {
  return Stream.periodic(Duration(seconds: 1), (i) => i);
}

StreamBuilder<int>(
  stream: countStream(),
  builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
    if (snapshot.hasError) {
      return Text("An error occurred: ${snapshot.error}");
    }
    if (!snapshot.hasData) {
      return CircularProgressIndicator();
    }
    return Text("Count: ${snapshot.data}");
  },
)

In this example, the countStream function returns a stream that emits an increasing integer every second. The StreamBuilder widget takes the stream as an input and rebuilds the widget tree every time a new value is emitted. The builder callback is executed every time the widget is rebuilt and it checks if there's an error or if the data is missing. If there's an error, it shows an error message, if the data is missing, it shows a loading indicator and if the data is present, it shows the count.

In a Flutter application, interoperability between Dart and JavaScript can be achieved using the dart:js library. The dart:js library allows you to call JavaScript functions from Dart and vice versa.

Here's an example of how to call a JavaScript function from Dart using the dart:js library:

import 'dart:js' as js;

void callJSFunction() {
  var result = js.context.callMethod("myJsFunction", ["Hello from Dart!"]);
  print(result);
}

In this example, the callJSFunction function is called from Dart and it calls the JavaScript function myJsFunction passing the string "Hello from Dart!" as an argument. The callMethod method returns the result of the JavaScript function, which can be saved in the result variable and printed.

To call Dart function from javascript you can use js.allowInterop(function) and call it like any other javascript function.

Implementing interoperability between Dart and JavaScript in a Flutter application allows you to leverage the strengths of both languages and build robust and efficient applications.

In a Dart application, pagination can be handled by sending a page number or offset as a parameter in the network request and updating it with every new request. The server should return a fixed number of records per request, and a flag indicating if there are more records to retrieve.

Here's an example of how to handle pagination when fetching data dynamically in a Dart application:

class DataFetcher {
  int _page = 0;
  bool _hasMore = true;

  Future<List<Data>> fetchData() async {
    if (!_hasMore) {
      return [];
    }
    var response = await http.get('https://example.com/data?page=$_page');
    var data = jsonDecode(response.body);
    _page++;
    _hasMore = data['hasMore'];
    return data['data'];
  }
}

var fetcher = DataFetcher();
var dataList = await fetcher.fetchData();
print(dataList);

In this example, the DataFetcher class has a _page variable that starts at 0, and a _hasMore variable that starts as true. The fetchData function checks the _hasMore variable before making a request, if there is no more data, it returns an empty list. The fetchData function sends the _page variable as a parameter in the network request and increments it by one on every call. After the response, it updates the _hasMore variable based on the response received from the server.

You can also use a package like dio which has built-in support for pagination like dio.get("/test",queryParameters: {"page":1,"per_page":20})

Handling pagination in this way allows you to fetch data dynamically and efficiently, without overwhelming the server or the client with unnecessary requests.