Flutter开发之下标
在iOS开发中使用下标就很方便，本文主要是记录一下Flutter中系统自带的下标，还可以通过对应的方法编写自己的下标。
在Objective-C中的下标
关键字Subscript。
NSArray
- (ObjectType)objectAtIndexedSubscript:(NSUInteger)idx API_AVAILABLE(macos(10.8), ios(6.0), watchos(2.0), tvos(9.0));
- (void)setObject:(ObjectType)obj atIndexedSubscript:(NSUInteger)idx API_AVAILABLE(macos(10.8), ios(6.0), watchos(2.0), tvos(9.0));
在Swift中的下标
关键字subscript。
Array
@inlinable public subscript(index: Int) -> Element
@inlinable public subscript(bounds: Range<Int>) -> ArraySlice<Element>
@inlinable public subscript<R>(r: R) -> ArraySlice<Element> where R : RangeExpression, Int == R.Bound { get }
@inlinable public subscript(x: (UnboundedRange_) -> ()) -> ArraySlice<Element> { get }
@inlinable public subscript<R>(r: R) -> ArraySlice<Element> where R : RangeExpression, Int == R.Bound
@inlinable public subscript(x: (UnboundedRange_) -> ()) -> ArraySlice<Element>
Dart中的下标
关键字operator。
List
abstract interface class List<E> implements Iterable<E>, _ListIterable<E>
对应的下标
/// The object at the given [index] in the list.
///
/// The [index] must be a valid index of this list,
/// which means that `index` must be non-negative and
/// less than [length].
E operator [](int index);
/// Sets the value at the given [index] in the list to [value].
///
/// The [index] must be a valid index of this list,
/// which means that `index` must be non-negative and
/// less than [length].
void operator []=(int index, E value);
/// Returns the concatenation of this list and [other].
///
/// Returns a new list containing the elements of this list followed by
/// the elements of [other].
///
/// The default behavior is to return a normal growable list.
/// Some list types may choose to return a list of the same type as themselves
/// (see [Uint8List.+]);
List<E> operator +(List<E> other);
/// Whether this list is equal to [other].
///
/// Lists are, by default, only equal to themselves.
/// Even if [other] is also a list, the equality comparison
/// does not compare the elements of the two lists.
bool operator ==(Object other);
Map
abstract interface class Map<K, V>
对应的下标
/// The value for the given [key], or `null` if [key] is not in the map.
///
/// Some maps allow `null` as a value.
/// For those maps, a lookup using this operator cannot distinguish between a
/// key not being in the map, and the key being there with a `null` value.
/// Methods like [containsKey] or [putIfAbsent] can be used if the distinction
/// is important.
V? operator [](Object? key);
/// Associates the [key] with the given [value].
///
/// If the key was already in the map, its associated value is changed.
/// Otherwise the key/value pair is added to the map.
void operator []=(K key, V value);
bool
final class bool
对应的下标
/// The logical conjunction ("and") of this and [other].
///
/// Returns `true` if both this and [other] are `true`, and `false` otherwise.
@Since("2.1")
bool operator &(bool other) => other && this;
/// The logical disjunction ("inclusive or") of this and [other].
///
/// Returns `true` if either this or [other] is `true`, and `false` otherwise.
@Since("2.1")
bool operator |(bool other) => other || this;
/// The logical exclusive disjunction ("exclusive or") of this and [other].
///
/// Returns whether this and [other] are neither both `true` nor both `false`.
@Since("2.1")
bool operator ^(bool other) => !other == this;
num
sealed class num implements Comparable<num>
对应的下标
/// Test whether this value is numerically equal to `other`.
///
/// If both operands are [double]s, they are equal if they have the same
/// representation, except that:
///
/// * zero and minus zero (0.0 and -0.0) are considered equal. They
/// both have the numerical value zero.
/// * NaN is not equal to anything, including NaN. If either operand is
/// NaN, the result is always false.
///
/// If one operand is a [double] and the other is an [int], they are equal if
/// the double has an integer value (finite with no fractional part) and
/// the numbers have the same numerical value.
///
/// If both operands are integers, they are equal if they have the same value.
///
/// Returns false if [other] is not a [num].
///
/// Notice that the behavior for NaN is non-reflexive. This means that
/// equality of double values is not a proper equality relation, as is
/// otherwise required of `operator==`. Using NaN in, e.g., a [HashSet]
/// will fail to work. The behavior is the standard IEEE-754 equality of
/// doubles.
///
/// If you can avoid NaN values, the remaining doubles do have a proper
/// equality relation, and can be used safely.
///
/// Use [compareTo] for a comparison that distinguishes zero and minus zero,
/// and that considers NaN values as equal.
bool operator ==(Object other);
/// Adds [other] to this number.
///
/// The result is an [int], as described by [int.+],
/// if both this number and [other] is an integer,
/// otherwise the result is a [double].
num operator +(num other);
/// Subtracts [other] from this number.
///
/// The result is an [int], as described by [int.-],
/// if both this number and [other] is an integer,
/// otherwise the result is a [double].
num operator -(num other);
/// Multiplies this number by [other].
///
/// The result is an [int], as described by [int.*],
/// if both this number and [other] are integers,
/// otherwise the result is a [double].
num operator *(num other);
/// Euclidean modulo of this number by [other].
///
/// Returns the remainder of the Euclidean division.
/// The Euclidean division of two integers `a` and `b`
/// yields two integers `q` and `r` such that
/// `a == b * q + r` and `0 <= r < b.abs()`.
///
/// The Euclidean division is only defined for integers, but can be easily
/// extended to work with doubles. In that case, `q` is still an integer,
/// but `r` may have a non-integer value that still satisfies `0 <= r < |b|`.
///
/// The sign of the returned value `r` is always positive.
///
/// See [remainder] for the remainder of the truncating division.
///
/// The result is an [int], as described by [int.%],
/// if both this number and [other] are integers,
/// otherwise the result is a [double].
///
/// Example:
/// ```dart
/// print(5 % 3); // 2
/// print(-5 % 3); // 1
/// print(5 % -3); // 2
/// print(-5 % -3); // 1
/// ```
num operator %(num other);
/// Divides this number by [other].
double operator /(num other);
/// Truncating division operator.
///
/// Performs truncating division of this number by [other].
/// Truncating division is division where a fractional result
/// is converted to an integer by rounding towards zero.
///
/// If both operands are [int]s, then [other] must not be zero.
/// Then `a ~/ b` corresponds to `a.remainder(b)`
/// such that `a == (a ~/ b) * b + a.remainder(b)`.
///
/// If either operand is a [double], then the other operand is converted
/// to a double before performing the division and truncation of the result.
/// Then `a ~/ b` is equivalent to `(a / b).truncate()`.
/// This means that the intermediate result of the double division
/// must be a finite integer (not an infinity or [double.nan]).
int operator ~/(num other);
/// The negation of this value.
///
/// The negation of a number is a number of the same kind
/// (`int` or `double`) representing the negation of the
/// numbers numerical value (the result of subtracting the
/// number from zero), if that value *exists*.
///
/// Negating a double gives a number with the same magnitude
/// as the original value (`number.abs() == (-number).abs()`),
/// and the opposite sign (`-(number.sign) == (-number).sign`).
///
/// Negating an integer, `-number`, is equivalent to subtracting
/// it from zero, `0 - number`.
///
/// (Both properties generally also hold for the other type,
/// but with a few edge case exceptions).
num operator -();
/// Whether this number is numerically smaller than [other].
///
/// Returns `true` if this number is smaller than [other].
/// Returns `false` if this number is greater than or equal to [other]
/// or if either value is a NaN value like [double.nan].
bool operator <(num other);
/// Whether this number is numerically smaller than or equal to [other].
///
/// Returns `true` if this number is smaller than or equal to [other].
/// Returns `false` if this number is greater than [other]
/// or if either value is a NaN value like [double.nan].
bool operator <=(num other);
/// Whether this number is numerically greater than [other].
///
/// Returns `true` if this number is greater than [other].
/// Returns `false` if this number is smaller than or equal to [other]
/// or if either value is a NaN value like [double.nan].
bool operator >(num other);
/// Whether this number is numerically greater than or equal to [other].
///
/// Returns `true` if this number is greater than or equal to [other].
/// Returns `false` if this number is smaller than [other]
/// or if either value is a NaN value like [double.nan].
bool operator >=(num other);
int
abstract final class int extends num
对应的下标
/// Bit-wise and operator.
///
/// Treating both `this` and [other] as sufficiently large two's component
/// integers, the result is a number with only the bits set that are set in
/// both `this` and [other]
///
/// If both operands are negative, the result is negative, otherwise
/// the result is non-negative.
/// ```dart
/// print((2 & 1).toRadixString(2)); // 0010 & 0001 -> 0000
/// print((3 & 1).toRadixString(2)); // 0011 & 0001 -> 0001
/// print((10 & 2).toRadixString(2)); // 1010 & 0010 -> 0010
/// ```
int operator &(int other);
/// Bit-wise or operator.
///
/// Treating both `this` and [other] as sufficiently large two's component
/// integers, the result is a number with the bits set that are set in either
/// of `this` and [other]
///
/// If both operands are non-negative, the result is non-negative,
/// otherwise the result is negative.
///
/// Example:
/// ```dart
/// print((2 | 1).toRadixString(2)); // 0010 | 0001 -> 0011
/// print((3 | 1).toRadixString(2)); // 0011 | 0001 -> 0011
/// print((10 | 2).toRadixString(2)); // 1010 | 0010 -> 1010
/// ```
int operator |(int other);
/// Bit-wise exclusive-or operator.
///
/// Treating both `this` and [other] as sufficiently large two's component
/// integers, the result is a number with the bits set that are set in one,
/// but not both, of `this` and [other]
///
/// If the operands have the same sign, the result is non-negative,
/// otherwise the result is negative.
///
/// Example:
/// ```dart
/// print((2 ^ 1).toRadixString(2)); // 0010 ^ 0001 -> 0011
/// print((3 ^ 1).toRadixString(2)); // 0011 ^ 0001 -> 0010
/// print((10 ^ 2).toRadixString(2)); // 1010 ^ 0010 -> 1000
/// ```
int operator ^(int other);
/// The bit-wise negate operator.
///
/// Treating `this` as a sufficiently large two's component integer,
/// the result is a number with the opposite bits set.
///
/// This maps any integer `x` to `-x - 1`.
int operator ~();
/// Shift the bits of this integer to the left by [shiftAmount].
///
/// Shifting to the left makes the number larger, effectively multiplying
/// the number by `pow(2, shiftAmount)`.
///
/// There is no limit on the size of the result. It may be relevant to
/// limit intermediate values by using the "and" operator with a suitable
/// mask.
///
/// It is an error if [shiftAmount] is negative.
///
/// Example:
/// ```dart
/// print((3 << 1).toRadixString(2)); // 0011 -> 0110
/// print((9 << 2).toRadixString(2)); // 1001 -> 100100
/// print((10 << 3).toRadixString(2)); // 1010 -> 1010000
/// ```
int operator <<(int shiftAmount);
/// Shift the bits of this integer to the right by [shiftAmount].
///
/// Shifting to the right makes the number smaller and drops the least
/// significant bits, effectively doing an integer division by
/// `pow(2, shiftAmount)`.
///
/// It is an error if [shiftAmount] is negative.
///
/// Example:
/// ```dart
/// print((3 >> 1).toRadixString(2)); // 0011 -> 0001
/// print((9 >> 2).toRadixString(2)); // 1001 -> 0010
/// print((10 >> 3).toRadixString(2)); // 1010 -> 0001
/// print((-6 >> 2).toRadixString); // 111...1010 -> 111...1110 == -2
/// print((-85 >> 3).toRadixString); // 111...10101011 -> 111...11110101 == -11
/// ```
int operator >>(int shiftAmount);
/// Bitwise unsigned right shift by [shiftAmount] bits.
///
/// The least significant [shiftAmount] bits are dropped,
/// the remaining bits (if any) are shifted down,
/// and zero-bits are shifted in as the new most significant bits.
///
/// The [shiftAmount] must be non-negative.
///
/// Example:
/// ```dart
/// print((3 >>> 1).toRadixString(2)); // 0011 -> 0001
/// print((9 >>> 2).toRadixString(2)); // 1001 -> 0010
/// print(((-9) >>> 2).toRadixString(2)); // 111...1011 -> 001...1110 (> 0)
/// ```
int operator >>>(int shiftAmount);
/// Return the negative value of this integer.
///
/// The result of negating an integer always has the opposite sign, except
/// for zero, which is its own negation.
int operator -();
double
abstract final class double extends num
对应的下标
double operator +(num other);
double operator -(num other);
double operator *(num other);
double operator %(num other);
double operator /(num other);
int operator ~/(num other);
double operator -();
Uint8List
abstract final class Uint8List implements List<int>, _TypedIntList
对应的下标
/// Returns a concatenation of this list and [other].
///
/// If [other] is also a typed-data list, then the return list will be a
/// typed data list capable of holding both unsigned 8-bit integers and
/// the elements of [other], otherwise it'll be a normal list of integers.
List<int> operator +(List<int> other);
Float32x4List
abstract final class Float32x4List implements List<Float32x4>, TypedData
对应的下标
/// Returns the concatenation of this list and [other].
///
/// If [other] is also a [Float32x4List], the result is a new [Float32x4List],
/// otherwise the result is a normal growable `List<Float32x4>`.
List<Float32x4> operator +(List<Float32x4> other);
Int32x4List
abstract final class Int32x4List implements List<Int32x4>, TypedData
对应的下标
/// Returns the concatenation of this list and [other].
///
/// If [other] is also a [Int32x4List], the result is a new [Int32x4List],
/// otherwise the result is a normal growable `List<Int32x4>`.
List<Int32x4> operator +(List<Int32x4> other);
Float64x2List
abstract final class Float64x2List implements List<Float64x2>, TypedData
对应的下标
/// Returns the concatenation of this list and [other].
///
/// If [other] is also a [Float64x2List], the result is a new [Float64x2List],
/// otherwise the result is a normal growable `List<Float64x2>`.
List<Float64x2> operator +(List<Float64x2> other);
Float32x4
abstract final class Float32x4
对应的下标
/// Addition operator.
Float32x4 operator +(Float32x4 other);
/// Negate operator.
Float32x4 operator -();
/// Subtraction operator.
Float32x4 operator -(Float32x4 other);
/// Multiplication operator.
Float32x4 operator *(Float32x4 other);
/// Division operator.
Float32x4 operator /(Float32x4 other);
Float64x2
abstract final class Float64x2
对应的下标
/// Addition operator.
Float64x2 operator +(Float64x2 other);
/// Negate operator.
Float64x2 operator -();
/// Subtraction operator.
Float64x2 operator -(Float64x2 other);
/// Multiplication operator.
Float64x2 operator *(Float64x2 other);
/// Division operator.
Float64x2 operator /(Float64x2 other);
Object
class Object
对应的下标
/// The equality operator.
///
/// The default behavior for all [Object]s is to return true if and
/// only if this object and [other] are the same object.
///
/// Override this method to specify a different equality relation on
/// a class. The overriding method must still be an equivalence relation.
/// That is, it must be:
///
/// * Total: It must return a boolean for all arguments. It should never throw.
///
/// * Reflexive: For all objects `o`, `o == o` must be true.
///
/// * Symmetric: For all objects `o1` and `o2`, `o1 == o2` and `o2 == o1` must
/// either both be true, or both be false.
///
/// * Transitive: For all objects `o1`, `o2`, and `o3`, if `o1 == o2` and
/// `o2 == o3` are true, then `o1 == o3` must be true.
///
/// The method should also be consistent over time,
/// so whether two objects are equal should only change
/// if at least one of the objects was modified.
///
/// If a subclass overrides the equality operator, it should override
/// the [hashCode] method as well to maintain consistency.
external bool operator ==(Object other);
Type
abstract interface class Type
对应的下标
/// Whether [other] is a [Type] instance representing an equivalent type.
///
/// The language specification dictates which types are considered
/// to be the equivalent.
/// If two types are equivalent, it's guaranteed that they are subtypes
/// of each other,
/// but there are also types which are subtypes of each other,
/// and which are not equivalent (for example `dynamic` and `void`,
/// or `FutureOr<Object>` and `Object`).
bool operator ==(Object other);
String
abstract final class String implements Comparable<String>, Pattern
对应的下标
/// The character (as a single-code-unit [String]) at the given [index].
///
/// The returned string represents exactly one UTF-16 code unit, which may be
/// half of a surrogate pair. A single member of a surrogate pair is an
/// invalid UTF-16 string:
/// ```dart
/// var clef = '\u{1D11E}';
/// // These represent invalid UTF-16 strings.
/// clef[0].codeUnits; // [0xD834]
/// clef[1].codeUnits; // [0xDD1E]
/// ```
/// This method is equivalent to
/// `String.fromCharCode(this.codeUnitAt(index))`.
String operator [](int index);
/// Whether [other] is a `String` with the same sequence of code units.
///
/// This method compares each individual code unit of the strings.
/// It does not check for Unicode equivalence.
/// For example, both the following strings represent the string 'Amélie',
/// but due to their different encoding, are not equal:
/// ```dart
/// 'Am\xe9lie' == 'Ame\u{301}lie'; // false
/// ```
/// The first string encodes 'é' as a single unicode code unit (also
/// a single rune), whereas the second string encodes it as 'e' with the
/// combining accent character '◌́'.
bool operator ==(Object other);
/// Creates a new string by concatenating this string with [other].
///
/// Example:
/// ```dart
/// const string = 'dart' + 'lang'; // 'dartlang'
/// ```
String operator +(String other);
/// Creates a new string by concatenating this string with itself a number
/// of times.
///
/// The result of `str * n` is equivalent to
/// `str + str + ...`(n times)`... + str`.
///
/// ```dart
/// const string = 'Dart';
/// final multiplied = string * 3;
/// print(multiplied); // 'DartDartDart'
/// ```
/// Returns an empty string if [times] is zero or negative.
String operator *(int times);
Element
abstract class Element extends DiagnosticableTree implements BuildContext
对应的下标
/// Compare two widgets for equality.
///
/// When a widget is rebuilt with another that compares equal according
/// to `operator ==`, it is assumed that the update is redundant and the
/// work to update that branch of the tree is skipped.
///
/// It is generally discouraged to override `operator ==` on any widget that
/// has children, since a correct implementation would have to defer to the
/// children's equality operator also, and that is an O(N²) operation: each
/// child would need to itself walk all its children, each step of the tree.
///
/// It is sometimes reasonable for a leaf widget (one with no children) to
/// implement this method, if rebuilding the widget is known to be much more
/// expensive than checking the widgets' parameters for equality and if the
/// widget is expected to often be rebuilt with identical parameters.
///
/// In general, however, it is more efficient to cache the widgets used
/// in a build method if it is known that they will not change.
@nonVirtual
@override
// ignore: avoid_equals_and_hash_code_on_mutable_classes, hash_and_equals
bool operator ==(Object other) => identical(this, other);
IndexedSlot
class IndexedSlot<T extends Element?>
对应的下标
@override
bool operator ==(Object other) {
if (other.runtimeType != runtimeType) {
return false;
}
return other is IndexedSlot
&& index == other.index
&& value == other.value;
}
OffsetPair
class OffsetPair
对应的下标
/// Adds the `other.global` to [global] and `other.local` to [local].
OffsetPair operator+(OffsetPair other) {
return OffsetPair(
local: local + other.local,
global: global + other.global,
);
}
/// Subtracts the `other.global` from [global] and `other.local` from [local].
OffsetPair operator-(OffsetPair other) {
return OffsetPair(
local: local - other.local,
global: global - other.global,
);
}
Velocity
class Velocity
对应的下标
/// Return the negation of a velocity.
Velocity operator -() => Velocity(pixelsPerSecond: -pixelsPerSecond);
/// Return the difference of two velocities.
Velocity operator -(Velocity other) {
return Velocity(pixelsPerSecond: pixelsPerSecond - other.pixelsPerSecond);
}
/// Return the sum of two velocities.
Velocity operator +(Velocity other) {
return Velocity(pixelsPerSecond: pixelsPerSecond + other.pixelsPerSecond);
}
@override
bool operator ==(Object other) {
return other is Velocity
&& other.pixelsPerSecond == pixelsPerSecond;
}
本文含有隐藏内容，请 开通VIP 后查看