TypeScript List.get方法代码示例

    updateActivityInMention(kind: TimelineActivityKind, status: Tweet, from: TwitterUser): [List<Item>, number] {
        const status_id = status.id;
        const index = this.mention.findIndex(item => {
            if (item instanceof TimelineActivity) {
                return item.kind === kind && item.status.id === status_id;
            } else {
                return false;
            }
        });

        const next_focus_index =
            this.kind === 'mention' && (index === -1 || index < this.focus_index) ?
                this.nextFocusIndex(this.mention.size + 1) : this.focus_index;

        if (index === -1) {
            return [this.mention.unshift(new TimelineActivity(kind, status, [from])), next_focus_index];
        } else {
            const will_updated = this.mention.get(index);
            if (will_updated instanceof TimelineActivity) {
                const updated = will_updated.update(status, from);
                return [this.mention.delete(index).unshift(updated), next_focus_index];
            } else {
                log.error('Invalid activity for update:', will_updated);
                return [this.mention, next_focus_index];
            }
        }
    }

function findVerticalCollisions(timelineDuration: number, stacks: List<List<Record<Annotation>>>, stackStartIndex: number, annotations: List<Record<Annotation>>) {
  const collisions: {annotation: Record<Annotation>, index: number, annotationStackIndex: number}[] = []
  let spread = Set(annotations)
  for(let i = stackStartIndex; i < stacks.size; i++) {
    const stack = stacks.get(i)!
    const spreadList = spread.toList()
    const withInsertions = stack.concat(spreadList).sort(recordSort)
    const insertionIndices = spreadList.map(a => {
      return withInsertions.findIndex(wi => {
        return wi.get('id', null) === a.get('id', null)
      })
    })
    const hCollisions = findHorizontalCollisions(timelineDuration, withInsertions, insertionIndices, true)
    spread = spread.union(hCollisions.map(({annotation}) => annotation))
    // Get actual indices of horiz. collisions
    stack.forEach((annotation, annotationIndex) => {
      const isCollision = hCollisions.find(hColl => {
        return hColl.annotation.get('id', null) === annotation.get('id', null)
      }) !== undefined
      if(isCollision) {
        collisions.push({annotation, index: annotationIndex, annotationStackIndex: i})
      }
    })
  }
  return collisions
}

 private getDesiredPrice(): number {
   return this.integerifyCash(
     this.lines
       .get(0) // First line contains the desiredPrice
       .match(/(?:\$)(\S*)/)[1] // Match non-space characters after dollar sign
   );
 }

function serializeMapItemList(list: List<MapItem>): string[] {
  const result: string[] = []
  for (let row = 0; row < FIELD_BLOCK_SIZE; row += 1) {
    const array: string[] = []
    for (let col = 0; col < FIELD_BLOCK_SIZE; col += 1) {
      const { type, hex } = list.get(row * FIELD_BLOCK_SIZE + col)
      if (type === 'B') {
        if (hex > 0) {
          array.push('B' + hex.toString(16))
        } else {
          array.push('X')
        }
      } else if (type === 'E') {
        array.push('E')
      } else if (type === 'R') {
        array.push('R')
      } else if (type === 'S') {
        array.push('S')
      } else if (type === 'T') {
        if (hex > 0) {
          array.push('T' + hex.toString(16))
        } else {
          array.push('X')
        }
      } else if (type === 'F') {
        array.push('F')
      } else {
        array.push('X')
      }
    }
    result.push(array.map(s => s.padEnd(3)).join(''))
  }
  return result
}

 indices.forEach(i => {
   // Collision to right
   n = 1
   nextIndex = i+n
   while(nextIndex < list.size && !isInIndices(nextIndex) && recordHasCollision(list.get(i)!, list.get(nextIndex)!, timelineDuration)) {
     collisions.push({annotation: list.get(nextIndex)!, index: nextIndex})
     nextIndex = i+(++n)
   }
   // Collision to left
   n = 1
   nextIndex = i-n
   while(nextIndex >= 0 && !isInIndices(nextIndex) && recordHasCollision(list.get(i)!, list.get(nextIndex)!, timelineDuration)) {
     collisions.push({annotation: list.get(nextIndex)!, index: nextIndex})
     nextIndex = i-(++n)
   }
 })

function fitOptimized(timelineDuration: number, annotationStacks: List<List<Record<Annotation>>>, annotations: List<Record<Annotation>>) {
  const fittedStacks: Array<List<Record<Annotation>>> = []
  let rest = annotations
  let stackCounter = 0
  while(rest.size > 0) {
    const stack = stackCounter < annotationStacks.size ? annotationStacks.get(stackCounter)! : List([])
    let updatedStack = stack
    const collisions = []
    const justFitted = []
    for(let j = 0; j < rest.size; j++) {
      const annotation = rest.get(j)!
      // TODO: instead of concat+sort+binarysearch, just insert sorted
      const withInsertion = updatedStack.push(annotation).sort(recordSort)
      const insertionIndex = binarySearch(withInsertion, withInsertion.size, (list, k) => {
        return list.getIn([k, 'utc_timestamp'])
      }, annotation.get('utc_timestamp', null))

      if(findHorizontalCollisions(timelineDuration, withInsertion, List([insertionIndex])).length > 0) {
        collisions.push(annotation)
      } else {
        justFitted.push(annotation)
        updatedStack = withInsertion
      }
    }
    fittedStacks.push(List(justFitted.sort(recordSort)))
    rest = List(collisions)
    stackCounter++
  }

  return List(fittedStacks)
}

function findFirstNonEmptyIncome(incomes: List<Income>): number {
  for (let i = 0; i < incomes.size; ++i) {
    let income = incomes.get(i);
    if (income.spentForeignAmount.lessThan(income.foreignAmount)) {
      return i;
    }
  }
  return incomes.size - 1;
}

export function moveInList<T>(list: List<T>, itemIndex: number, insertPoint: number): List<T> {
  var n = list.size;
  if (itemIndex < 0 || itemIndex >= n) throw new Error('itemIndex out of range');
  if (insertPoint < 0 || insertPoint > n) throw new Error('insertPoint out of range');
  var newArray: T[] = [];
  list.forEach((value, i) => {
    if (i === insertPoint) newArray.push(list.get(itemIndex));
    if (i !== itemIndex) newArray.push(value);
  });
  if (n === insertPoint) newArray.push(list.get(itemIndex));
  return List(newArray);
}

function focusPreviousCellEditor(
  state: NotebookModel,
  action: actionTypes.FocusPreviousCellEditor
): RecordOf<DocumentRecordProps> {
  const cellOrder: List<CellId> = state.getIn(["notebook", "cellOrder"]);
  const curIndex = cellOrder.findIndex(
    (id: CellId) => id === action.payload.id
  );
  const nextIndex = Math.max(0, curIndex - 1);

  return state.set("editorFocused", cellOrder.get(nextIndex));
}

function isTankCollidedWithRivers(rivers: List<boolean>, tankTarget: Rect, threshhold: number) {
  for (const t of IndexHelper.iter('river', tankTarget)) {
    if (rivers.get(t)) {
      const subject = IndexHelper.getRect('river', t)
      // 因为要考虑threshhold, 所以仍然要调用testCollide来判断是否相撞
      if (testCollide(subject, tankTarget, threshhold)) {
        return true
      }
    }
  }
  return false
}