Interview Questions and Answers

Row(
    mainAxisAlignment: MainAxisAlignment.spaceBetween,
    crossAxisAlignment: CrossAxisAlignment.center,
    children: [
      Container(width: 50, height: 50, color: Colors.red),
      Container(width: 50, height: 100, color: Colors.green),
      Container(width: 50, height: 75, color: Colors.blue),
    ],
)

Row(
    children: [
      Expanded(
        flex: 2,
        child: Container(color: Colors.red),
      ),
      Expanded(
        flex: 1,
        child: Container(color: Colors.blue),
      ),
    ],
)      

Row(
    children: [
      Flexible(
        flex: 2,
        fit: FlexFit.tight,
        child: Container(color: Colors.red),
      ),
      Flexible(
        flex: 1,
        fit: FlexFit.loose,
        child: Container(color: Colors.blue),
      ),
    ],
)

List<int> numbers = [1, 2, 3, 4, 5];
List<int> squaredNumbers = numbers.map((number) => number * number).toList();            

import 'package:flutter/widgets.dart';

class MyObserver extends WidgetsBindingObserver {
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.paused) {
      // App is going into the background
      // Perform any necessary cleanup or state saving
    } else if (state == AppLifecycleState.resumed) {
      // App is coming back to the foreground
      // Perform any necessary restoration or state loading
    }
  }
}
// In your widget's initState:
WidgetsBinding.instance?.addObserver(MyObserver());

// In your widget's dispose:
WidgetsBinding.instance?.removeObserver(MyObserver());   

void main() {
    runApp(MyApp());
}   

void main() {
    runApp(MyApp()); // MyApp is the root widget
}     
 

                                var person = Person();
                                var name = person?.name; // Safe access; name is null if person is null
                              

                                var nullableValue = getValueFromExternalSource();
                                var value = nullableValue ?? defaultValue; // Use defaultValue if nullableValue is null
                              

                                person
                                ..?..setName('John')
                                ..?..setAge(30);
                            

ElevatedButton(
    onPressed: () {
      // This is a callback function that gets executed when the button is pressed.
      // You can put your logic here, like navigating to a new screen or updating data.
    },
    child: Text('Press me'),
)

ElevatedButton(
    onPressed: () {
      // This is a callback function that gets executed when the button is pressed.
      // You can put your logic here, like navigating to a new screen or updating data.
    },
    child: Text('Press me'),
)

void main() {
    double max = double.NEGATIVE_INFINITY;
    List<double> numbers = [3.14, 2.71, 42.0, 7.0, 10.0];
  
    for (var number in numbers) {
      if (number > max) {
        max = number;
      }
    }
  
    print("The maximum value in the list is: $max");
}       

Navigator.push(
    context,
    MaterialPageRoute(builder: (context) => NewScreen()),
);

Navigator.pop(context);

Navigator.pushReplacement(
    context,
    MaterialPageRoute(builder: (context) => UpdatedScreen()),
);

MaterialApp(
    routes: {
      '/home': (context) => HomeScreen(),
      '/profile': (context) => ProfileScreen(),
    },
)

Navigator.pushNamed(context, '/home');

Navigator.popUntil(context, ModalRoute.withName('/home'));

void printName(String firstName, String lastName) {
    print('$firstName $lastName');
  }
  
  void main() {
    printName('John', 'Doe'); // Positional arguments
}     

void printPerson({String firstName = 'John', String lastName = 'Doe'}) {
    print('$firstName $lastName');
  }
  
  void main() {
    printPerson(); // No arguments provided, uses default values
    printPerson(firstName: 'Alice'); // Named arguments, overriding defaults
    printPerson(lastName: 'Smith', firstName: 'Bob'); // Named arguments in any order
}     

dependencies:
    http: ^latest_version

dependencies:
    camera: ^latest_version

ListView.builder(
    itemCount: items.length,
    itemBuilder: (BuildContext context, int index) {
      return ListTile(
        key: Key('item_$index'), // Assign a unique key to each item
        title: Text(items[index]),
      );
    },
)

void printMessage(String message) {
    print(message);
}

printMessage('Hello, World!'); // Correct usage

void printMessageOptional([String? message = 'Default Message']) {
    print(message);
}     

printMessageOptional(); // Uses the default value
printMessageOptional('Custom Message'); // Provides a custom value

Future<int> fetchValue() async {
    // Simulate an asynchronous operation
    await Future.delayed(Duration(seconds: 2));
    return 42;
  }
  
  void main() {
    fetchValue().then((value) {
      print('Value: $value');
    }).catchError((error) {
      print('Error: $error');
    });
}

Future<int> fetchValue() async {
    // Simulate an asynchronous operation
    await Future.delayed(Duration(seconds: 2));
    return 42;
  }
  
  void main() {
    fetchValue().whenCompleted(() {
      print('Future has completed');
    });
}   
 

Scaffold(
    appBar: AppBar(
      title: Text('My App'),
    ),
    drawer: Drawer(
      // Drawer content
    ),
    body: Center(
      child: Text('Hello, Flutter!'),
    ),
)

Container(
    width: 100,
    height: 100,
    color: Colors.blue,
    padding: EdgeInsets.all(16),
    margin: EdgeInsets.all(8),
    child: Center(
      child: Text('Container Widget'),
    ),
)

int? nullableValue;
int result = nullableValue ?? 42;

class Person {
    String name;
    Person(this.name);
    void sayHello() {
      print('Hello, $name!');
    }
} 
Person? person;
person?.sayHello();   

Future<void> fetchData() async {
    print('Fetching data...');
    await Future.delayed(Duration(seconds: 2)); // Simulating an asynchronous operation
    print('Data fetched!');
}
   
void main() {
    print('Starting...');
    fetchData().then((_) {
      print('Data processing...');
    });
    print('Ending...');
}    

int age = 30; // Non-nullable by default
String name = "John"; // Non-nullable by default   

int? nullableAge = null; // Nullable variable
String? nullableName = null; // Nullable variable

                                MediaQueryData mediaQueryData = MediaQuery.of(context);
                                double screenWidth = mediaQueryData.size.width;
                                double screenHeight = mediaQueryData.size.height;
                                Orientation orientation = mediaQueryData.orientation;
                               

                                EdgeInsets safeAreaInsets = mediaQueryData.viewInsets;
                              

                                double textScaleFactor = mediaQueryData.textScaleFactor;
                              

                                String platform = mediaQueryData.platformBrightness == Brightness.dark ? 'Dark' :
                                'Light';
                                double devicePixelRatio = mediaQueryData.devicePixelRatio;
                             

MediaQuery(
    data: MediaQueryData(),
    child: Builder(
      builder: (context) {
        MediaQueryData mediaQueryData = MediaQuery.of(context);
        // Handle screen size changes here.
        return YourWidget();
      },
    ),
)       

if (mediaQueryData.size.width > 600) {
    // Display a different layout for larger screens.
    return LargeScreenLayout();
  } else {
    // Display a default layout for smaller screens.
    return DefaultLayout();
}   

double maxScore = double.INFINITY;
if (score > maxScore) {
  // Handle a score that exceeds the maximum possible value.
}         

MediaQueryData mediaQueryData = MediaQuery.of(context);
double screenWidth = mediaQueryData.size.width;
double screenHeight = mediaQueryData.size.height;

Future<String> fetchUserData() async {
    // Simulate a network request
    await Future.delayed(Duration(seconds: 2));
    return 'User Data';
}     
 

fetchUserData()
.then((data) => processUserData(data))
.then((result) => displayResult(result))
.catchError((error) => handleErrors(error));

void fetchData() async {
    var data = await fetchUserData();
    // Use the fetched data
}    
 

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('SafeArea Example'),
        ),
        body: SafeArea(
          child: Center(
            child: Text(
              'Content within the SafeArea',
              style: TextStyle(fontSize: 24),
            ),
          ),
        ),
      ),
    );
  }
}

if (kReleaseMode) {
    // Code to execute in release builds
    // Disable debugging features, enable performance optimizations, etc.
  } else {
    // Code to execute in debug builds
    // Enable debugging features, additional logging, etc.
}

Future<int> fetchUserData() async {
    // Simulate a network request
    await Future.delayed(Duration(seconds: 2));
    return 42;
}

Stream<int> generateNumbers() async* {
    for (int i = 0; i < 5; i++) {
      // Simulate an asynchronous computation
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
}     

class _MyPrivateClass {
    int _privateField;
  
    _MyPrivateClass(this._privateField);
  
    void _privateMethod() {
      // Some private logic
    }
}     
 

String dateString = '2023-09-12T12:00:00Z'; // Example date string
DateTime dateTime = DateTime.parse(dateString); // Parse the string into a DateTime
object
// Now you can compare dateTime with another DateTime object
DateTime otherDate = DateTime(2023, 9, 12, 12, 0, 0);
if (dateTime.isAfter(otherDate)) {
// Do something
}

String date1String = '2023-09-12T12:00:00Z'; // Example date string 1
String date2String = '2023/09/12 12:00 PM'; // Example date string 2

// Custom parsing functions to convert strings to DateTime
DateTime parseDate1(String input) {
  // Write your custom parsing logic here
  // Example: "2023-09-12T12:00:00Z" to DateTime
}

DateTime parseDate2(String input) {
  // Write your custom parsing logic here
  // Example: "2023/09/12 12:00 PM" to DateTime
}

DateTime date1 = parseDate1(date1String);
DateTime date2 = parseDate2(date2String);

// Now you can compare date1 and date2 as DateTime objects
if (date1.isBefore(date2)) {
  // Do something
}

String date1String = '2023-09-12T12:00:00Z'; // Example date string 1
String date2String = '2023-09-12T12:00:00Z'; // Example date string 2

// You can directly compare them if they are in the same format
if (date1String == date2String) {
  // Do something
}

// Or, if you want to ensure they are both DateTime objects, parse them
DateTime date1 = DateTime.parse(date1String);
DateTime date2 = DateTime.parse(date2String);

// Now you can compare date1 and date2 as DateTime objects
if (date1.isAfter(date2)) {
  // Do something
}    

void main() {
    List<String> fruits = ['apple', 'banana', 'cherry'];
  
    // Convert the List into a Map with the List elements as keys
    // and their lengths as values
    Map<String, int> fruitLengths = Map.fromIterable(
      fruits,
      key: (fruit) => fruit, // Use the element itself as the key
      value: (fruit) => fruit.length, // Use the length as the value
    );
  
    print(fruitLengths); // Output: {apple: 5, banana: 6, cherry: 6}
}

void main() {
    List<String> fruits = ['apple', 'banana', 'cherry'];
    Map<String, int> fruitLengths = {};
  
    for (var fruit in fruits) {
      fruitLengths[fruit] = fruit.length;
    }
  
    print(fruitLengths); // Output: {apple: 5, banana: 6, cherry: 6}
}    

void main() {
    List<String> fruits = ['apple', 'banana', 'cherry'];
    Map<String, int> fruitLengths = {};
  
    fruits.forEach((fruit) {
      fruitLengths[fruit] = fruit.length;
    });
  
    print(fruitLengths); // Output: {apple: 5, banana: 6, cherry: 6}
}

class MyCounterWidget extends StatefulWidget {
    @override
    _MyCounterWidgetState createState() => _MyCounterWidgetState();
  }
  
  class _MyCounterWidgetState extends State<MyCounterWidget> {
    int _counter = 0;
  
    void _incrementCounter() {
      setState(() {
        _counter++;
      });
    }
  
    @override
    Widget build(BuildContext context) {
      return Column(
        children: [
          Text('Counter: $_counter'),
          ElevatedButton(
            onPressed: _incrementCounter,
            child: Text('Increment'),
          ),
        ],
      );
    }
}    

class MyCounterWidget extends StatefulWidget {
    @override
    _MyCounterWidgetState createState() => _MyCounterWidgetState();
  }
  
  class _MyCounterWidgetState extends State<MyCounterWidget> {
    final MyCounterState _counterState = MyCounterState();
  
    @override
    Widget build(BuildContext context) {
      return Column(
        children: [
          Text('Counter: ${_counterState.counter}'),
          ElevatedButton(
            onPressed: _counterState.incrementCounter,
            child: Text('Increment'),
          ),
        ],
      );
    }
  }
  
  class MyCounterState {
    int _counter = 0;
  
    int get counter => _counter;
  
    void incrementCounter() {
      _counter++;
    }
}