房地产开发公司网站源代码 墨绿色风格,小程序开发教程个人,河北最新发布最新,安徽网络技术服务推广Flutter开发之下标
在iOS开发中使用下标就很方便#xff0c;本文主要是记录一下Flutter中系统自带的下标#xff0c;还可以通过对应的方法编写自己的下标。
在Objective-C中的下标
关键字Subscript。
NSArray
- (ObjectType)objectAtIndexedSubscript:(NSUInteger)idx A…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) - Elementinlinable public subscript(bounds: RangeInt) - ArraySliceElementinlinable public subscriptR(r: R) - ArraySliceElement where R : RangeExpression, Int R.Bound { get }inlinable public subscript(x: (UnboundedRange_) - ()) - ArraySliceElement { get }inlinable public subscriptR(r: R) - ArraySliceElement where R : RangeExpression, Int R.Boundinlinable public subscript(x: (UnboundedRange_) - ()) - ArraySliceElementDart中的下标
关键字operator。
List
abstract interface class ListE implements IterableE, _ListIterableE
对应的下标 /// 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.]);ListE operator (ListE 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 MapK, 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 Comparablenum
对应的下标 /// 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 twos 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 twos 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 twos 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 twos 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 Listint, _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 itll be a normal list of integers.Listint operator (Listint other);Float32x4List
abstract final class Float32x4List implements ListFloat32x4, 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 ListFloat32x4.ListFloat32x4 operator (ListFloat32x4 other);Int32x4List
abstract final class Int32x4List implements ListInt32x4, 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 ListInt32x4.ListInt32x4 operator (ListInt32x4 other);Float64x2List
abstract final class Float64x2List implements ListFloat64x2, 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 ListFloat64x2.ListFloat64x2 operator (ListFloat64x2 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, its 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 FutureOrObject and Object).bool operator (Object other);String
abstract final class String implements ComparableString, 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/// childrens 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.nonVirtualoverride// ignore: avoid_equals_and_hash_code_on_mutable_classes, hash_and_equalsbool operator (Object other) identical(this, other);IndexedSlot
class IndexedSlotT 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;}
