Dart Quiz

Which of the following is a requirement for generative constructors in an enhanced enum in Dart?

• Must be non-constant

• Must be abstract

• Must be final

• Must be static

Answer explanation

在 Dart 中，增強型列舉（enhanced enums）中的生成構造器（generative constructors）必須是 非常量的（Must be non-constant）。這是因為增強型列舉允許列舉值在構造時執行一些邏輯或操作，而這些操作通常需要使用非常量的構造器。

How can you access enumerated values in Dart?

• Through extension methods

• Through static variables

• Through instance methods

• Through static methods

Answer explanation

In Dart, you can access enumerated values through static variables.

What is the purpose of using extension methods in Dart?

• To add new functionality to existing classes

• To remove functionality from existing classes

• To modify existing classes

• To create new classes

Answer explanation

Extension methods in Dart are used to add new functionality to existing classes, allowing developers to extend the capabilities of those classes without modifying their source code.

Which of the following is a valid example of an extension method in Dart?

• extension { ... }

• extension on String { ... }

• extension StringParsing { ... }

• extension StringParsing on String { ... }

Answer explanation

The correct choice is 'extension StringParsing on String { ... }' because it follows the syntax for defining an extension method in Dart by specifying the extension name 'StringParsing' and the target type 'String'.

What is the benefit of using unnamed extensions in Dart?

• They are only visible within the declaring library

• They are visible across all libraries

• They are faster than named extensions

• They can be explicitly applied to resolve API conflicts

Answer explanation

In Dart, unnamed extensions are extensions without a specific name. The primary benefit of using unnamed extensions is that they are only visible within the library where they are declared. This means that they do not leak into other libraries, providing better encapsulation.

Benefits of unnamed extensions:

• Encapsulation: Since unnamed extensions are only visible within the declaring library, this helps in preventing unintended usage or conflicts in other libraries.

• Avoiding API conflicts: By keeping the extension private to the library, it avoids the risk of API conflicts when multiple libraries define similar extensions on the same type.

How can you access static members defined in an extension method in Dart?

• By using the extension method's prefix

• By importing the extension method

• By using the extension method's name

• By calling the static members directly

Answer explanation

### Correct Answer

By using the extension method's name

### Explanation

In Dart, static members defined in an extension method can be accessed by using the extension's name, followed by the static member's name. This is different from instance members, which are accessed through the object that the extension is applied to.

For example:

```dart

extension StringExtension on String {

static String get empty => '';

int get lengthPlusTwo => this.length + 2;

}

void main() {

// Accessing a static member

print(StringExtension.empty); // Outputs: ''

// Accessing an instance member

print('hello'.lengthPlusTwo); // Outputs: 7

}

```

In this example, `StringExtension.empty` accesses the static member `empty` of the `StringExtension`. This is how you access static members defined in an extension method.

What is a key feature of implementing generic extensions in Dart?

• They can only be applied to specific data types

• They allow for dynamic typing

• They can have type parameters

• They are limited to primitive data types

Answer explanation

### Correct Answer

They can have type parameters

### Explanation

A key feature of implementing generic extensions in Dart is that they can have type parameters. This allows you to create extensions that work with a variety of data types while still being type-safe.

For example:

```dart

extension ListUtils<T> on

Which of the following is a valid example of a generic extension in Dart?

• extension MyList on List { ... }

• extension MyList { ... }

• extension MyList on List { ... }

• extension MyList on List { ... }

Answer explanation

It looks like there's some confusion in the options provided, as they all seem quite similar. However, the valid example of a generic extension in Dart should include a type parameter. Here's the correct format:

### Correct Example

```dart

extension MyList<T> on List<T> {

// Extension methods and properties

}

```

This extension is generic because it uses `<T>` as a type parameter, making it applicable to any `List` of any type.

If this is a multiple-choice question and you need to select an answer, the correct option should closely resemble the format above with a type parameter `<T>`. If none of the options provided have this format, it may be an issue with the question options.

What is the purpose of using extension methods in Dart?

• To remove functionality from existing classes

• To create new classes

• To modify existing classes

• To add new functionality to existing classes

Answer explanation

### Correct Answer

To add new functionality to existing classes

### Explanation

The purpose of using extension methods in Dart is to add new functionality to existing classes without modifying the original class. Extension methods allow you to define additional methods or properties on a class, which can then be used as if they were part of the original class.

This is particularly useful when you want to extend the capabilities of classes you don't own or cannot modify, such as classes from external libraries or the Dart SDK itself.

For example:

```dart

extension StringExtensions on String {

bool get isNullOrEmpty => this == null || this.isEmpty;

}

void main() {

String text = '';

print(text.isNullOrEmpty); // Outputs: true

}

```

In this example, the `isNullOrEmpty` method is added to the `String` class through an extension method.

What is the main advantage of using generic extensions in Dart?

• They allow for dynamic typing

• They can only be applied to specific data types

• They can have type parameters

• They are limited to primitive data types

Answer explanation

### Correct Answer

They can have type parameters

### Explanation

The main advantage of using generic extensions in Dart is that they can have type parameters. This allows you to write extensions that are more flexible and can work with multiple data types while maintaining type safety.

For example, a generic extension can be written like this:

```dart

extension MyListExtension<T> on List<T> {

void printAllItems() {

for (var item in this) {

print(item);

}

}

}

void main() {

List<int> numbers = [1, 2, 3];

numbers.printAllItems(); // Outputs: 1 2 3

List<String> words = ['hello', 'world'];

words.printAllItems(); // Outputs: hello world

}

```

In this example, the extension `MyListExtension` can be applied to any `List` type, whether it's a list of integers, strings, or any other type, thanks to the use of the type parameter `<T>`.