> ## 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 Symbol
A `Symbol` in Dart is an opaque, immutable object that represents an operator or identifier (such as a class, function, library, or variable name) declared within a Dart program. Symbols are resolved by the compiler and maintain a programmatic link to code constructs, ensuring identifier references are preserved even when the Dart code is obfuscated or minified.
## Syntax and Instantiation
There are two ways to instantiate a `Symbol` in Dart: using a symbol literal or using the `Symbol` class constructor.
**1. Symbol Literals**
A symbol literal is created by prefixing a valid Dart identifier or operator with a hash/pound sign (`#`). Symbol literals are compile-time constants and can represent both public and private identifiers.
```dart theme={"dark"}
// Standard public identifier
Symbol classSymbol = #MyClass;
// Private identifier
Symbol privateSymbol = #_myPrivateMethod;
// Setter identifier (must end with '=')
Symbol setterSymbol = #myProperty=;
// Operator identifier
Symbol operatorSymbol = #+;
```
**2. The `Symbol` Constructor**
You can dynamically generate a symbol at runtime by passing a `String` to the `Symbol` constructor. However, the constructor enforces a strict restriction: it only accepts **public** identifiers. Attempting to pass a private identifier (a string starting with an underscore) will throw an `ArgumentError` at runtime.
```dart theme={"dark"}
// Valid: Public identifier
Symbol dynamicSymbol = Symbol('calculateTotal');
// Invalid: Throws ArgumentError at runtime
// Symbol invalidPrivate = Symbol('_myPrivateMethod');
```
## Compilation Mechanics and Equality
The primary architectural distinction between a `String` and a `Symbol` lies in how they are treated during compilation and minification. When Dart code is compiled to JavaScript or native machine code via AOT (Ahead-of-Time) compilation, the compiler often minifies identifiers to reduce file size (e.g., renaming `fetchData` to `a`).
This minification directly impacts symbol equality. While a symbol literal and a constructed symbol representing the same string evaluate to `true` in unminified code, they will evaluate to `false` in production/minified environments.
* The literal `#fetchData` is recognized by the compiler and minified alongside the code (e.g., becoming `#a`).
* The string `'fetchData'` passed to `Symbol('fetchData')` remains an unminified string literal.
```dart theme={"dark"}
Symbol literalSym = #fetchData;
Symbol constructedSym = Symbol('fetchData');
// Evaluates to true in JIT/unminified environments.
// Evaluates to false in AOT/minified environments.
print(literalSym == constructedSym);
```
## Modern Context: `noSuchMethod`
Historically, `Symbol` was heavily used with the `dart:mirrors` library for reflection. Because reflection is unsupported in Flutter and Dart AOT compilation, the primary modern encounter with the `Symbol` class is handling dynamic method calls via the `noSuchMethod` override.
When an undefined method or property is invoked on an object, Dart passes an `Invocation` object to `noSuchMethod`. This `Invocation` object exposes the called method or property name strictly as a `Symbol` via the `memberName` property.
```dart theme={"dark"}
class DynamicProxy {
@override
dynamic noSuchMethod(Invocation invocation) {
if (invocation.memberName == #fetchData) {
// Handle the dynamic call to fetchData()
return true;
}
return super.noSuchMethod(invocation);
}
}
```
## Immutability
Once instantiated, a `Symbol` cannot be mutated. It does not expose methods to manipulate its underlying string representation, enforcing its role strictly as an identifier token rather than a data structure for text manipulation.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
