TypeScript StringMapWrapper.forEach方法代码示例

 /** @internal */
 _reduceControls(controlsConfig: any): {[key: string]: modelModule.AbstractControl} {
   var controls: {[key: string]: modelModule.AbstractControl} = {};
   StringMapWrapper.forEach(controlsConfig, (controlConfig, controlName) => {
     controls[controlName] = this._createControl(controlConfig);
   });
   return controls;
 }

 static _mergeErrors(control: modelModule.AbstractControl, res: StringMap<string, any[]>): void {
   StringMapWrapper.forEach(control.errors, (value, error) => {
     if (!StringMapWrapper.contains(res, error)) {
       res[error] = [];
     }
     var current: any[] = res[error];
     current.push(control);
   });
 }

 static group(group: modelModule.ControlGroup): StringMap<string, boolean> {
   var res = {};
   StringMapWrapper.forEach(group.controls, (control, name) => {
     if (group.contains(name) && isPresent(control.errors)) {
       Validators._mergeErrors(control, res);
     }
   });
   return StringMapWrapper.isEmpty(res) ? null : res;
 }

 events.forEach(event => {
   if (StringWrapper.equals(event['ph'], 'X')) {
     needSort = true;
     var startEvent = {};
     var endEvent = {};
     StringMapWrapper.forEach(event, (value, prop) => {
       startEvent[prop] = value;
       endEvent[prop] = value;
     });
     startEvent['ph'] = 'B';
     endEvent['ph'] = 'E';
     endEvent['ts'] = startEvent['ts'] + startEvent['dur'];
     this._remainingEvents.push(startEvent);
     this._remainingEvents.push(endEvent);
   } else {
     this._remainingEvents.push(event);
   }
 });

function normalizeEvent(chromeEvent: {[key: string]: any},
                        data: {[key: string]: any}): {[key: string]: any} {
  var ph = chromeEvent['ph'];
  if (StringWrapper.equals(ph, 'S')) {
    ph = 'b';
  } else if (StringWrapper.equals(ph, 'F')) {
    ph = 'e';
  }
  var result =
      {'pid': chromeEvent['pid'], 'ph': ph, 'cat': 'timeline', 'ts': chromeEvent['ts'] / 1000};
  if (chromeEvent['ph'] === 'X') {
    var dur = chromeEvent['dur'];
    if (isBlank(dur)) {
      dur = chromeEvent['tdur'];
    }
    result['dur'] = isBlank(dur) ? 0.0 : dur / 1000;
  }
  StringMapWrapper.forEach(data, (value, prop) => { result[prop] = value; });
  return result;
}

 describe(): {[key: string]: any} {
   var res = {
     'scriptTime': 'script execution time in ms, including gc and render',
     'pureScriptTime': 'script execution time in ms, without gc nor render'
   };
   if (this._perfLogFeatures.render) {
     res['renderTime'] = 'render time in ms';
   }
   if (this._perfLogFeatures.gc) {
     res['gcTime'] = 'gc time in ms';
     res['gcAmount'] = 'gc amount in kbytes';
     res['majorGcTime'] = 'time of major gcs in ms';
     if (this._forceGc) {
       res['forcedGcTime'] = 'forced gc time in ms';
       res['forcedGcAmount'] = 'forced gc amount in kbytes';
     }
   }
   if (this._captureFrames) {
     if (!this._perfLogFeatures.frameCapture) {
       var warningMsg = 'WARNING: Metric requested, but not supported by driver';
       // using dot syntax for metric name to keep them grouped together in console reporter
       res['frameTime.mean'] = warningMsg;
       res['frameTime.worst'] = warningMsg;
       res['frameTime.best'] = warningMsg;
       res['frameTime.smooth'] = warningMsg;
     } else {
       res['frameTime.mean'] = 'mean frame time in ms (target: 16.6ms for 60fps)';
       res['frameTime.worst'] = 'worst frame time in ms';
       res['frameTime.best'] = 'best frame time in ms';
       res['frameTime.smooth'] = 'percentage of frames that hit 60fps';
     }
   }
   StringMapWrapper.forEach(this._microMetrics,
                            (desc, name) => { StringMapWrapper.set(res, name, desc); });
   return res;
 }

 descriptions.forEach(description => {
   StringMapWrapper.forEach(description, (value, prop) => this.description[prop] = value);
 });

 static _sortedProps(obj) {
   var props = [];
   StringMapWrapper.forEach(obj, (value, prop) => props.push(prop));
   props.sort();
   return props;
 }

 map => { StringMapWrapper.forEach(map, (value, prop) => { result[prop] = value; }); });

 function sortedKeys(stringMap) {
   var res = [];
   StringMapWrapper.forEach(stringMap, (_, key) => { res.push(key); });
   res.sort();
   return res;
 }