How to use

forIn

function

in

LoDashStatic

/**
   * Register service events
   *
   * @param {Node} node
   * @param {ServiceItem} service
   * @param {Object} events
   * @memberof Registry
   */
  registerEvents(node, service, events) {
    _.forIn(events, event => {

      if (node.local)
        event.handler = this.broker.middlewares.wrapHandler("localEvent", event.handler, event);

      this.events.add(node, service, event);
      service.addEvent(event);
    });
  }

/**
   * Register service actions
   *
   * @param {Node} node
   * @param {Service} service
   * @param {Object} actions
   * @memberof Registry
   */
  registerActions(node, service, actions) {
    _.forIn(actions, action => {

      if (!this.checkActionVisibility(action, node))
        return;

      if (node.local) {
        action.handler = this.broker.middlewares.wrapHandler("localAction", action.handler, action);
      } else if (this.broker.transit) {
        action.handler = this.broker.middlewares.wrapHandler("remoteAction", this.broker.transit.request.bind(this.broker.transit), { ...action, service });
      }
      if (this.broker.options.disableBalancer && this.broker.transit)
        action.remoteHandler = this.broker.middlewares.wrapHandler("remoteAction", this.broker.transit.request.bind(this.broker.transit), { ...action, service });

      this.actions.add(node, service, action);
      service.addAction(action);
    });
  }

_.forIn(service.actions, action => {
  if (action.protected) return;
_.forIn(service.events, event => {

} else if (isObject(urls) && !Array.isArray(urls)) {
  const list = [];
  _.forIn(urls, (s, nodeID) => list.push(`${s}/${nodeID}`));
  urls = list;

item.actions = {};
_.forIn(service.actions, action => {
  if (action.protected) return;
item.events = {};
_.forIn(service.events, event => {

_.forIn(groupedEP, item => {
  const newCtx = ctx.copy(item.ep);
  newCtx.eventGroups = item.groups;

_.forIn(prevActions, (action, name) => {
  if (!svc.actions || !svc.actions[name]) {
    this.unregisterAction(node, name);
_.forIn(prevEvents, (event, name) => {
  if (!svc.events || !svc.events[name]) {
    this.unregisterEvent(node, name);

_.forIn(schema.methods, (method, name) => {
_.forIn(schema.actions, (action, name) => {
  if (action === false)
    return;
_.forIn(schema.events, (event, name) => {
  const innerEvent = this._createEvent(event, name);
  serviceSpecification.events[innerEvent.name] = innerEvent;

function getDefaultOptions(cmd) {
  var cmdOptions = {};

  if (_.isUndefined(commands[cmd])) {
   return cmdOptions;
  }

  _.forIn(commands[cmd].options, function(config, name) {
   if (!_.isUndefined(config.defaultValue)) {
    cmdOptions[name] = config.defaultValue;
   }
  });

  return cmdOptions;
 }

_rebuild() {
  this.tree = {};
  _.forIn(this.schema, (value, key) => {
   if (_.isObject(value)) {
    this._addField(key, value);
   } else {
    this._addField(key, { type: value });
   }
  });
  this.requiredFields = getRequiredFields(this.tree);
  this.forbiddentFields = getForbiddenFields(this.tree);
 }

// Foreach sub task
 _.forIn(this._tasks[taskName], function(task, taskName) {

  // Not a task property
  if (!self._isTask(taskName)) {
   return;
  }

  callback(task, taskName);

 });

_.forIn(_.omit(criteria, ['types', 'tracks', 'typeIds', 'trackIds', 'type', 'name', 'trackId', 'typeId', 'description', 'page', 'perPage', 'tag',
  'group', 'groups', 'memberId', 'ids', 'createdDateStart', 'createdDateEnd', 'updatedDateStart', 'updatedDateEnd', 'startDateStart', 'startDateEnd', 'endDateStart', 'endDateEnd',
  'tags', 'registrationStartDateStart', 'registrationStartDateEnd', 'currentPhaseName', 'submissionStartDateStart', 'submissionStartDateEnd',
  'registrationEndDateStart', 'registrationEndDateEnd', 'submissionEndDateStart', 'submissionEndDateEnd', 'includeAllEvents', 'events',
  'forumId', 'track', 'reviewType', 'confidentialityType', 'directProjectId', 'sortBy', 'sortOrder', 'isLightweight', 'isTask', 'taskIsAssigned', 'taskMemberId']), (value, key) => {
  if (!_.isUndefined(value)) {
   const filter = { match_phrase: {} }
   filter.match_phrase[key] = value
   boolQuery.push(filter)
  }
 })

_.forIn(actions, function(value, key) {
   if (!bigpipe.hasOwnProperty(key)) {
    bigpipe['$' + key] = value;
    // console.log('add props', key);
   } else {
    console.info('新增实例方法[' + key + ']与Bigpipe原实例方法冲突');
   }
  });

const parseErrors = (nodeRestfulErrors) => {
  const errors = []
  _.forIn(nodeRestfulErrors, error => errors.push(error.message))
  return errors
}

_.forIn(schema.virtuals, (value, key) => {
   obj[key] = doc[key];
  });