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_equalsbool operator ==(Object other) => identical(this, other);

IndexedSlot

class IndexedSlot<T extends Element?>

对应的下标

  @overridebool 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);}@overridebool operator ==(Object other) {return other is Velocity&& other.pixelsPerSecond == pixelsPerSecond;}