How to use

sortBy

function

in

lodash

sortBy(res.data, network => network.Name.toLowerCase()).map(network => ({
    id: network.Id.substr(0, 12),
    id_full: network.Id,
    name: network.Name,
    driver: network.Driver,
    scope: network.Scope,
   }))

const sortData = (data, direction, key) => {
    if (direction === 'asc') {
     return sortBy(data, key);
    } else if (direction === 'desc') {
     return sortBy(data, key).reverse();
    } else {
     return data;
    }
   }

sortBy(types, ['kind', 'name'])
 .filter(x => !x.name.startsWith('__'))
 .filter(x => !x.name.startsWith('Root'))
 .filter(x => x.kind !== 'SCALAR')
 .map(x => generateTypeExport(x, namespace))
 .join('\n')

sort(list) {
  if (
   !this.sortData ||
   !this.sortData.prop ||
   !this.sortData.order
  ) {
   return list;
  }

  if (this.sortData.order === 'descending') {
   return sortBy(list, [this.sortData.prop]).reverse();
  }

  return sortBy(list, [this.sortData.prop]);
 }

function* runActions(app, actionList, options) {
 actionList = sortBy(actionList, o => {
  const order = o.options.order;
  return typeof order === 'number' ? order : 3;
 });

 for (const action of actionList) {
  const fn = action.fn;
  lang.isGeneratorFunction(fn) ?
   yield* fn(app, options) : fn(app, options);
 }
}

sortBy(types, ['kind', 'name'])
 .filter(x => !x.name.startsWith('__'))
 .filter(x => !x.name.startsWith('Root'))
 .filter(x => x.kind !== 'SCALAR')
 .map(x => generateTypeExport(x, namespace))
 .filter(Boolean)
 .join('\n')

const buildIndexProvince = stats => {
  const data = stats
    .map(stat => stat.data.filter(x => x.type === 'provinsi'))
    .reduce((p, c) => p.concat(c));

  storage.write('index.json', JSON.stringify(sortBy(data, 'code'), null, '\t'));
}

/**
 * Generate dropdown filter values from frontmatter values.
 */
function generateFilters (projects) {
 const types = sortBy(uniq(map(projects, 'type')))
 const generators = sortBy(uniq(flatten(map(projects, 'generators'))))

 return { types, generators }
}

const printCoins = async () =>
  flow(map(trim), sortBy(toLower), map(print))(
    await CryptoCompareAPI.fetchCoinList())

sortBy(
   models.filter(obj => !!this.props.schema.layout[obj.name]),
   ['name'],
  )

sortBy(res.data, volume => volume.Name.toLowerCase()).map(volume => ({
    driver: volume.Driver,
    name: volume.Name,
   }))

/**
 * Sorts an array of properties by their 'required' property first and 'name'
 * property second.
 *
 * @param {array} props
 * @return {array} Sorted properties
 */
function sortProps(props) {
  const requiredPropNames = sortBy(props.filter(prop => prop.required), 'name');
  const optionalPropNames = sortBy(props.filter(prop => !prop.required), 'name');
  const sortedProps = requiredPropNames.concat(optionalPropNames);
  return sortedProps;
}

sortBy(sections, (o) => o.name)

sortBy(Object.keys(colleaguesMap).map(name => ({
    name,
    type: colleaguesMap[name],
   })), 'type')

function* runActions(app, actionList, options) {
 actionList = sortBy(actionList, o => {
  const order = o.options.order;
  return typeof order === 'number' ? order : 3;
 });

 for (const action of actionList) {
  const fn = action.fn;
  lang.isGeneratorFunction(fn) ?
   yield* fn(app, options) : fn(app, options);
 }
}