How to use

filter

function

in

LoDashStatic

// Categorize and colorize URLS if and as appropriate
 _.forEach(app.info, info => {
  if (_.has(info, 'urls') && !_.isEmpty(info.urls)) {
   urls[info.service] = _.filter(app.urls, item => {
    item.theme = chalk[item.color](item.url);
    return _.includes(info.urls, item.url);
   });
  }
 });

/*
  * Return a data source
  */
 read(source, filters = {}) {
  const result = this.yaml.load(path.resolve(this.base, `${source}.yml`)) || [];
  if (!_.isEmpty(filters)) return _.filter(result, filters);
  return result;
 }

// Get sponsors by type
 api.get('/v1/sponsors/:type', handler((req, res) => {
  return _.filter(utils.loadFile(sponsorsFile), {type: req.params.type});
 }));

// Helper to get scannable or not scannable services
const getScannable = (app, scan = true) => _.filter(app.info, service => {
 return _.get(app, `config.services.${service.service}.scanner`, true) === scan;
})

app.init().then(() => console.log(lando.cli.formatData(
    _.filter(app.info, service => filterServices(service.service, options.service)),
    options
   )))

// Discover portforward true info
 app.events.on('ready', () => {
  app.log.verbose('discovering dynamic portforward info...');
  const forwarders = _.filter(app.info, service => _.get(service, 'external_connection.port', false));
  return lando.engine.list({project: app.project})
  .filter(service => _.includes(_.flatMap(forwarders, service => service.service), service.service))
  .map(service => ({
   id: service.id,
   service: service.service,
   internal: _.get(_.find(app.info, {service: service.service}), 'internal_connection.port'),
  }))
  .map(service => lando.engine.scan(service).then(data => {
   const key = `NetworkSettings.Ports.${service.internal}/tcp`;
   const port = _.filter(_.get(data, key, []), forward => forward.HostIp === lando.config.bindAddress);
   if (_.has(port[0], 'HostPort')) {
    _.set(_.find(app.info, {service: service.service}), 'external_connection.port', port[0].HostPort);
   }
  }));
 });

_.map(res, p => {
  index++
  const pd = p.dataValues
  const { code, name } = pd
  log(index, count, code, name, 2)
  const arr = []
  pd.children = _.map(_.filter(p.cities, c => {
   const { dataValues: { name }, areas } = c
   if (f.includes(name)) {
    arr.push(..._.map(areas, a => _.pick(a.dataValues, cField)))
    return false
   }
   return true
  }), c => _.pick(c.dataValues, cField))
  pd.children.push(...arr)

  r[pd.name] = pd.children.map(c => c.name)
  return _.pick(pd, fField)
 })

async getTempItemForderList(ctx, app) {

    try {
      let defaultTemp = await this._getDefaultTempInfo(ctx, app);
      let filePath = ctx.helper.scanJustFolder(app.config.temp_view_forder + defaultTemp.alias);
      let newFilePath = _.filter(filePath, (file) => {
        return file.name.indexOf('stage') >= 0;
      });
      // 对返回结果做初步排序
      newFilePath.sort(function (a, b) {
        return a.type == "folder" || b.type == "folder"
      });
      ctx.helper.renderSuccess(ctx, {
        data: newFilePath
      });
    } catch (err) {
      ctx.helper.renderFail(ctx, {
        message: err
      });
    }
  }

api.auth().then(() => Promise.all([api.getSites(), api.getUser()]))
  // Parse the dataz and set the things
  .then(results => {
   // Get our site and email
   const site = _.head(_.filter(results[0], site => site.name === options['pantheon-site']));
   const user = results[1];

   // Error if site doesn't exist
   if (_.isEmpty(site)) throw Error(`${site} does not appear to be a Pantheon site!`);

   // This is a good token, lets update our cache
   const cache = {token: options['pantheon-auth'], email: user.email, date: _.toInteger(_.now() / 1000)};

   // Update lando's store of pantheon machine tokens
   const tokens = lando.cache.get(pantheonTokenCache) || [];
   lando.cache.set(pantheonTokenCache, utils.sortTokens(tokens, [cache]), {persist: true});
   // Update app metdata
   const metaData = lando.cache.get(`${options.name}.meta.cache`);
   lando.cache.set(`${options.name}.meta.cache`, _.merge({}, metaData, cache), {persist: true});

   // Add some stuff to our landofile
   return {config: {
    framework: _.get(site, 'framework', 'drupal'),
    site: _.get(site, 'name', options.name),
    id: _.get(site, 'id', 'lando'),
   }};
  })

.filter(container => container.kind === 'app')
})
.then(nets => _.filter(networks, network => !_.includes(nets, network.Name)))
.filter(network => _.isEmpty(network.Containers))

let parentTypeId = typeId ? typeId : (contentObj.categories)[0]._id;
let parentObj = _.filter(fullNav, (doc) => {
  return doc._id == parentTypeId;
});
  cates = _.filter(fullNav, (doc) => {
    return (doc.sortPath).indexOf(parentId) > 0
  });
  parents = _.filter(cates, (doc) => {
    return doc.parentId === '0'
  });

return this.listContainers(options)
.filter(_.identity)
.filter(data => data.Status !== 'Removal In Progress')
.filter(data => data.lando === true)
.filter(data => data.instance === this.id)
.filter(container => {
 if (!srcExists(container.src) && container.kind === 'app') {
  return this.remove(container.id, {force: true}).then(() => false);
 if (options.project) return _.filter(containers, c => c.app === options.project);
 else if (options.app) return _.filter(containers, c => c.app === utils.dockerComposify(options.app));
 return containers;
})
 if (!_.isEmpty(options.filter)) {
  return _.filter(containers, _.fromPairs(_.map(options.filter, filter => filter.split('='))));
 } else {
  return containers;

// Contributors by type
 api.get('/v1/events/:type', handler((req, res) => {
  return _.filter(utils.loadFile(eventsFile), {type: req.params.type});
 }));

// Get sponsors by type
 api.get('/v1/sponsors/:type', handler((req, res) => {
  return _.filter(utils.loadFile(sponsorsFile), {type: req.params.type});
 }));

// Contributors by type
 api.get('/v1/events/:type', handler((req, res) => {
  return _.filter(utils.loadFile(eventsFile), {type: req.params.type});
 }));