TypeScript lodash.forOwn函数代码示例

 worker.addEventListener("message", ({data}) => {
     _.forOwn(callbacks, (callback, name) => {
         if (data.type == name) {
             callback(data.content)
         }
     })
 })

export const pricingServiceReducer = (state: PricingOperationsReducerState = {}, action): PricingOperationsReducerState => {

  const { type, payload } = action
  switch (type) {
    case ACTION_TYPES.SPOT_PRICES_UPDATE:

      const updatedPrices = keyBy(action.payload, 'symbol')
      const updatedPricesDataObj = {}

      _.forOwn(updatedPrices, (value, key) => {
        const prevItem = state[key] || {}
        const newItem:SpotPriceTick = { ...value }
        newItem.priceStale = false
        newItem.priceMovementType = getPriceMovementType(prevItem, newItem)
        updatedPricesDataObj[key] = newItem
      })

      return { ...state, ...updatedPricesDataObj }
    case ACTION_TYPES.PRICING_STALE:
      return {
        ...state,
        [payload.symbol]: {
          ...state[payload.symbol],
          priceStale: true,
          notification: buildNotification(null, stalePriceErrorMessage)
        }
      }
    default:
      return state
  }
}

 _.forEach(result, (resource) => {
   _.forOwn(resource["metrics"], (id, name) => {
     if (re.test(name)) {
       metrics[id] = this._compute_label(user_label, resource, name, target.aggregator);
     }
   });
 });

    it('successful password update', co(function *isSuccessfulPasswordUpdate() {
      const oldPassword = 'oldPassword';
      const newPassword = 'newPassword';
      const otherPassword = 'otherPassword';

      nock(bgUrl)
      .post('/api/v1/user/encrypted')
      .reply(200, {
        keychains: {
          xpub1: bitgo.encrypt({ input: 'xprv1', password: oldPassword }),
          xpub2: bitgo.encrypt({ input: 'xprv2', password: otherPassword })
        },
        version: 1
      });

      const result = yield keychains.updatePassword({ oldPassword: oldPassword, newPassword: newPassword });
      _.forOwn(result.keychains, function(encryptedXprv, xpub) {
        xpub.should.startWith('xpub');
        try {
          const decryptedPrv = bitgo.decrypt({ input: encryptedXprv, password: newPassword });
          decryptedPrv.should.startWith('xprv');
        } catch (e) {
          // the decryption didn't work because of the wrong password, this is one of the keychains that didn't match
          // the old password
          e.message.should.startWith('password error');
        }
      });
      result.should.hasOwnProperty('version');
    }));

 transform(iterable: any, args: any[]): any {
     let result = [];
     _.forOwn(iterable, (value, key) => {
          result.push({key: key, value: value, id: cuid() });
     });
     return result;
 }

 _.forEach(groupPaths, (groupPath) => {
     badgesByGroup[groupPath] = [];
     _.forOwn(badges, (badge) => {
         if (_.includes(badge.groups, groupPath)) {
             badgesByGroup[groupPath].push(badge);
         }
     });
 });

    private getQueryStringPrams(settings: RequestSettings): HttpParams {
        let queryParams = new HttpParams();

        _.forOwn(settings.queryString.getParams(), (value: string, key: string) => {
            queryParams = queryParams.set(key, value);
        });
        return queryParams;
    }

function objectToMap(input: object): Map<string, object> {
  const result = new Map<string, object>();

  forOwn(input, (value, key) => {
    result.set(key, value);
  });

  return result;
}

  private buildLookupTable(periodStarts: object): Map<string, TimePeriod> {
    let result = new Map<string, TimePeriod>();

    forOwn(periodStarts, (value, key) => {
      result.set(key, value);
    });

    return result;
  }

    private replaceTemplateTokensWithValues(urlTemplate: string, tokens: {[name: string]:any} ): string {
        
        forOwn(tokens, (value: any, key: string) => {
            urlTemplate = this.replaceRouteTokens(urlTemplate, key, value);
            urlTemplate = this.replaceRouteTokens(urlTemplate, lowerFirst(key), value);
        });

        return this.removeOptionalRouteTokens(urlTemplate);
    }

 return forOwn(groupsByProvider, (groupsByRegion: IRegions, provider: string) => {
   forOwn(groupsByRegion, (groups: IRegionAccount[]) => {
     groups.forEach((group: IRegionAccount) => {
       group.provider = provider;
       group.account = account;
     });
   });
   securityGroups.push({account, provider, securityGroups: groupsByProvider[provider]});
 });

 return forOwn(groupsByProvider, (groupsByRegion, provider) => {
   forOwn(groupsByRegion, (groups: ISecurityGroup[]) => {
     groups.forEach((group) => {
       group.provider = provider;
       group.account = account;
     });
   });
   securityGroups.push({account, provider, securityGroups: groupsByProvider[provider]});
 });

    return function(items, checkModel) {
        const keyArr = [];
        _.forOwn(checkModel, (value, key) => {
            if (value) {
                keyArr.push(key);
            }
        });

        return _.filter(items, (item: any) => _.some(keyArr, key => key === item.OrderStatus));
    };

export function getOperatonFunctionName(term: ParsedTerm): string {
    if (term.type !== 'function') {
        return null;
    }
    let result = null;
    _.forOwn(operationFunctions, (value, key) => {
        if (value === term.name) {
            result = key;
            return false;
        }
    });
    _.forOwn(singleArgOperationFunctions, (value, key) => {
        if (value === term.name) {
            result = key;
            return false;
        }
    });
    return result;
}

    private getLinks(resource: IHalResource): Link[] {
        let links: Link[] = [];

        _.forOwn(resource._links, (link: Link, rel: string) => {
            link.rel = rel;
            links.push(link);
        });

        return links;
    }