How to use the underscore.pluck function in underscore

github.getIssue(nameInfo[0], nameInfo[1], issue.number).events(function(err, data) {
                if (err) {
                  console.log(err, data);
                  throw new Error(': ' + err.message);
                }

                var commitEvents = _.compact(_.filter(data, function(data) { return data.commit_id; }));
                if (commitEvents.length) {
                  if (listHasSha(commits, _.last(commitEvents).commit_id)) {
                    // Treat "Fixes" issues as pull requests
                    commitEvents = _.pluck(commitEvents, 'commit_id');
                    commits = _.filter(commits, function(commit) {
                      return !listHasSha(commitEvents, commit.sha);
                    });

                    pulls[issue.index] = _.defaults({
                      user: commitEvents[0].actor,

                      // Provide the info needed to do pingbacks
                      base: {
                        user: {
                          login: nameInfo[0]
                        },
                        repo: {
                          name: nameInfo[1]
                        }
                      }

(ctx, meeting, memberChangeInfo, opts, callback) => {
    const oldLastModified = meeting.lastModified;

    const addedMemberIds = _.pluck(memberChangeInfo.members.added, 'id');
    const updatedMemberIds = _.pluck(memberChangeInfo.members.updated, 'id');
    const removedMemberIds = _.pluck(memberChangeInfo.members.removed, 'id');

    // Remove the meeting item from the removed members libraries
    _removeFromLibrary(removedMemberIds, meeting, err => {
      if (err) {
        log().warn(
          {
            err,
            principalIds: removedMemberIds,
            meetingId: meeting.id
          },
          'Error removing meeting from principal libraries. Ignoring.'
        );
      }

      if (_.isEmpty(updatedMemberIds) && _.isEmpty(addedMemberIds)) {
        return callback();

async function getAssets(thisFun, superFun, where, pageIndex, pageSize) {
  let result; // 最后返回的值
  // (1)查询到asset的数据列表
  result = await superFun.queryAsset(where, null, null, pageIndex, pageSize, 76);
  // (2)查询到issuer的数据列表
  let issuerData = await superFun.queryAsset({
    $in: _.pluck(result, 'issuer_name'),
  }, null, null, 1, 1000, 75);
  issuerData = _.indexBy(issuerData, 'name');
  result = _.map(result, (num) => {
    const num2 = num;
    num2.issuer_id = issuerData[num.issuer_name].issuer_id;
    return num2;
  });
  // (3)查询到交易的相关数据
  let trData = await thisFun.dao.findList('tr', {
    id: {
      $in: _.pluck(result, 'transaction_id'),
    },
  }, 1000, null, null, ['id', 'block_id'], null);
  trData = _.indexBy(trData, 'id');
  result = _.map(result, (num) => {
    const num2 = num;

// Normally facet values are sorted by selected first, then inactive, then excluded values.
      // For hierarchical, we want selected first, then those that have childs selected, then normal sorting.
      sortArray = sortArray.sort((first, second) => {
        if (first.hierarchy.selected === second.hierarchy.selected) {
          let firstFromHierarchy = this.facet.getValueFromHierarchy(first.hierarchy);
          let secondFromHierarchy = this.facet.getValueFromHierarchy(second.hierarchy);
          if (firstFromHierarchy.hasChildSelected === secondFromHierarchy.hasChildSelected) {
            return first.idx - second.idx;
          } else {
            return firstFromHierarchy.hasChildSelected ? -1 : 1;
          }
        } else {
          return first.hierarchy.selected ? -1 : 1;
        }
      });
      return _.pluck(sortArray, 'hierarchy');
    }
    return hierarchyFacetValues;
  }

}

            try {
                body = JSON.parse(body);
            } catch (parseError) {
                callback(parseError, null);
                return;
            }

            // keys in body, as defined in bamboo's API documentation
            var resultsKey = "searchResults",
                entityKey = "searchEntity";

            var searchResults = body[resultsKey]; // as defined in API documentation

            callback(null, _.pluck(searchResults, entityKey));
        });
    };

AuthzAPI.getAuthzMembers(meetingId, start, limit, (err, memberRoles, nextToken) => {
      if (err) {
        return callback(err);
      }

      // Get the basic profiles for all of these principals
      const memberIds = _.pluck(memberRoles, 'id');
      PrincipalsUtil.getPrincipals(ctx, memberIds, (err, memberProfiles) => {
        if (err) {
          return callback(err);
        }

        // Merge the member profiles and roles into a single object
        const memberList = _.map(memberRoles, memberRole => {
          return {
            profile: memberProfiles[memberRole.id],
            role: memberRole.role
          };
        });

        return callback(null, memberList, nextToken);
      });
    });

it('should import sub-subtopics correctly', function () {
            var scienceTopic = _.findWhere(hierarchy, { name: 'Science' });
            var chemistrySubtopic = _.findWhere(scienceTopic.subtopics, { name: 'Chemistry' });
            var chemistrySubtopics = _.pluck(chemistrySubtopic.subtopics, 'name');
            expect(chemistrySubtopics).to.eql([ 'Organic Chemistry' ]);
        });

group: ['reports', function(next, results) {
      var reports = results.reports;
      var report = results.report;

      var dates = _.pluck(reports, 'ts');

      var group = {
        report: reports[0],
        data: util.buckets(req.query.bucket, req.query.startDate, req.query.endDate, dates),
        count: reports.length,
        name: report.name,
        firstSeen: dates[0],
        lastSeen: dates[dates.length-1]
      };

      next(null, group);
    }]
  }, function(err, results) {

var duplicates = [];
	var groupedByCount = _.countBy(sourceArray, function (item) {
		return item[prop];
	});

	for (var name in groupedByCount) {
		if (groupedByCount[name] > 1) {
			var whereClause = [];
			whereClause[prop] = name;
			_.where(sourceArray, whereClause).map(function (item) {
				duplicates.push(item);
			});
		}
	}

	return _.uniq(_.pluck(duplicates, prop));
};

function cleanResultSet(results) {
        var lookup = _.pluck(results, 'place'),
            redundants = findRedundants(lookup),
            clean_results = [];

    function sorter(a, b) {
        if (a.ycount > b.ycount)
           return -1;
        if (a.ycount < b.ycount)
          return 1;
        return 0;
    }

    function findRedundants(lookup) {
        var _redundants = [];
        _.each(lookup, function(key) {
          var r;
          r = _.filter(lookup, function(x){if (x === key){return x}});