> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Member Access
The `.` (dot) operator is the standard member access operator in Dart. It is used to extract properties (fields, getters, setters), invoke methods, perform method tear-offs, and access members bound to an object instance, a class namespace, an imported library prefix, or an extension.
## Syntax
```dart theme={"dark"}
expression.memberIdentifier
```
## Technical Mechanics
* **Left-Hand Side (LHS):** An expression that evaluates to an object instance, a class type (for static access), or a library prefix.
* **Right-Hand Side (RHS):** The exact identifier of the member being accessed.
* **Compile-time Resolution:** In statically typed Dart, the analyzer resolves the RHS identifier at compile time against the static type of the LHS interface, class namespace, library namespace, or applicable extension in the current lexical scope.
* **Runtime Evaluation:** The operator evaluates strictly left-to-right. The LHS is evaluated first. Once evaluated, the member is accessed, extracted, or dispatched on the resulting object in memory.
## Syntax Visualization
**Instance Member Access:**
Accessing fields or methods bound to a specific object instance.
```dart theme={"dark"}
// Property read/write
instance.propertyName;
instance.propertyName = value;
// Method invocation
instance.methodName(arguments);
```
**Method Tear-offs:**
Extracting a method as a closure object without invoking it.
```dart theme={"dark"}
var closure = instance.methodName;
```
**Static Member Access:**
Accessing class-level fields or methods bound to the class namespace itself.
```dart theme={"dark"}
ClassName.staticProperty;
ClassName.staticMethod(arguments);
```
**Library Prefix Access:**
Accessing top-level members of an imported library namespace.
```dart theme={"dark"}
import 'dart:math' as math;
math.pi;
math.max(1, 2);
```
**Extension Member Access:**
Invoking extension methods or properties, which are resolved statically based on the LHS type.
```dart theme={"dark"}
instance.extensionMethod();
```
**Chaining:**
Because the `.` operator returns the result of the RHS evaluation, it inherently supports chaining. The evaluated result of the first access becomes the LHS for the subsequent `.` operator.
```dart theme={"dark"}
expression.memberA.memberB.methodC()
```
## Nullability and Type Safety
In Dart's sound null safety system, the `.` operator interacts with nullable types under specific resolution rules:
* **Permitted Nullable Access:** The `.` operator can be safely used on a nullable LHS expression to access members inherited from `Object?` (specifically `toString()`, `hashCode`, and `runtimeType`). It is also used to invoke extension members explicitly defined on a nullable type (e.g., `extension on String?`).
* **Compile-time Restrictions:** Attempting to access any other instance member on a *statically-typed* nullable type (e.g., `T?`) using the `.` operator results in a compilation error. The analyzer enforces the use of the null-aware access operator (`?.`) or explicit null-checks. The `dynamic` type is an exception; while it permits `null` values, it bypasses static type checking and allows `.` access at compile time.
* **Runtime Behavior:** If the LHS expression evaluates to `null` at runtime (which can occur via `dynamic` dispatch or unsafe type casting) and the RHS does not resolve to an `Object?` member or an applicable nullable extension, the `.` operator unconditionally throws a `NoSuchMethodError`.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
