How to use underscore - 10 common examples

it('should parse the specified keys to CSV', function (done) {
                // Create a copy so we don't modify the actual options object
                var opts = _.extend(JSON.parse(JSON.stringify(options)), {KEYS: ['info.name', 'year']});
                converter.json2csv(json_arrayValue, function (err, csv) {
                    csv.should.equal(csv_arrayValue_specificKeys);
                    csv.split(options.EOL).length.should.equal(5);
                    done();
                }, opts);
            });

tiles: tiles
                });
                assert.equal(job.size, size, 'size');

                job.cleanupForQue();
                assert.deepEqual(job._encodedTiles, expected, 'encoded');

                let encjob = newJob({
                    zoom: zoom,
                    _encodedTiles: job._encodedTiles
                });

                assert.equal(encjob.size, size, 'size2');
                let expectedDecoded = _.reject(tiles, v => Array.isArray(v) && v[0] === v[1]);
                // Remove empty ranges
                expectedDecoded = _.map(expectedDecoded, v => Array.isArray(v) && v[0] === v[1] + 1 ? v[0] : v);
                assert.deepEqual(encjob.tiles, expectedDecoded, 'roundtrip');
            } catch(err) {
                err.message = msg + ': ' + err.message;
                throw err;
            }
        };

_.isEqual(1);


/**
 * _.range
 */
_.range(0, 10)[4] == 4
// $ExpectError string. This type is incompatible with number
_.range(0, 'a');
// $ExpectError string cannot be compared to number
_.range(0, 10)[4] == 'a';

/**
 * _.bind
 */
_.bind(function(a,b){return this.x+a+b;}, {x: 1}, 2, 3);
// $ExpectError number. This type is incompatible with the expected param type of function type
_.bind(123)

/**
 * _.bindAll
 */
_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, 'greet');
_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, 'greet', 'toString');
_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, ['greet'], 'toString');




/**
 * _.extend
 */

us.each(form.evidence_profiles, function(prof){

			    // Mine out class expressions..
			    var cln_ce_str = [];
			    var cln_ce = [];
			    us.each(prof.class_expressions, function(ce){
				cln_ce.push(ce.class_id());
				cln_ce_str.push(ce.to_string_plus());
				//console.log(ce);
				ce_cache[ce.class_id()] = true;
			    });

			    // Mine out source and with.
			    var cln_src = [];
			    var cln_with = [];
			    //console.log(prof.annotations.length);
			    us.each(prof.annotations, function(ann){
				if( ann.key() === 'with' ){
				    cln_with.push(ann.value());
				}
				if( ann.key() === 'source' ){
				    cln_src.push(ann.value());

var bindEdgeCollections = function(self, edgeCollections) {
  _.each(edgeCollections, function(key) {
    var obj = db._collection(key);
    var wrap = wrapCollection(obj);
    // save
    var old_save = wrap.save;
    wrap.save = function(from, to, data) {
      //check, if edge is allowed
      self.__edgeDefinitions.forEach(
        function(edgeDefinition) {
          if (edgeDefinition.collection === key) {
            var fromCollection = from.split("/")[0];
            var toCollection = to.split("/")[0];
            if (! _.contains(edgeDefinition.from, fromCollection)
              || ! _.contains(edgeDefinition.to, toCollection)) {
              throw "Edge is not allowed between " + from + " and " + to + ".";
            }
          }

doFullBackup: function() {
        chatHandler.announceRoom('mods', "Backing up server...", "blue");

        var deploySh = spawn('sh', [ 'serverbackup.sh' ], {
          //cwd: process.env.HOME + '/myProject',
          cwd: '/root',
          env:_.extend(process.env, {
            PATH: process.env.PATH + ':/usr/local/bin'
          })
        });

        deploySh.stderr.on('data', function (data) {
          chatHandler.announceRoom('mods', data, "red");
          //console.log('stderr: ' + data);
        });

        // handle error so server doesn't crash...
        deploySh.on('error', function(err) {
            log('Error doing full backup!', err);
        });

        deploySh.on('exit', function (code) {
            chatHandler.announceRoom('mods', "Backup complete!", "blue");

// Check arguments
	if (arguments.length != 4) {
		var error			= new Error('Please call svg-sprite.createSprite() with exactly 4 arguments');
		error.errno			= 1391852448;
		return error;
	}
	
	// Keep the intermediate files
	options				= _.extend({}, defaultOptions, options || {});
	options.verbose		= Math.max(0, Math.min(3, parseInt(options.verbose, 10) || 0));
	
	// Temporarily alter the configuration options to keep intermediate files and suppress all output rendering
	options._keep		= options.keep;
	options.keep		= 1;
	options._render		= _.extend({css: true}, options.render);
	options.render		= {css: false};
	
	// Create the SVG sprite
	var sprite			= SVGSprite.createSprite(inputDir, outputDir, options, function(error, results) {
		
		// Restore configuration options
		results.options	= restoreOptions(results.options);
		
		// If an error occured while creating the SVG sprite: Abort
		if (error) {
			callback(error, results);
			
		// Else: Create icon kit
		} else {
			new Iconizr(results).createIconKit(callback);
		}

if (!options) options = {};

  if (options.configPath) {
    if (fs.existsSync(options.configPath)) {
      config = require(options.configPath);
    } else {
      // self.log isn't setup until after config is loaded
      console.warn('');
      console.warn('The config file you passed does not exist: %s'.yellow, options.configPath);
      console.warn('');
    }
  } else if (fs.existsSync(defaults.configPath)) {
    config = require(path.resolve(defaults.configPath));
  }

  return _.extend(defaults, config, options);
}

}
                        else {
                            this.$set(this.items[i], 'selected', false);
                        }
                    }
                }
            }
            // 配置用户自定义的value
            if (item.value && typeof item.value === 'function') {
                let value = item.value();
                if (u.isDate(value)) {
                    if (['date', 'datetime'].indexOf(this.type) > -1) {
                        this.$emit('set-date-handler', value, '');
                    }
                }
                if (u.isArray(value) && value.length === 2 && u.isDate(value[0]) && u.isDate(value[1])) {
                    if (['daterange', 'daterangetime'].indexOf(this.type) > -1) {
                        this.$emit('set-date-handler', value[0], value[1]);
                    }
                }
            }
            // 调用用户自定义的点击事件函数
            if (item.onClick && typeof item.onClick === 'function') {
                item.onClick(item);
            }
            // 如果配置了快捷面板点击自动关闭
            if (this.autoClose && !this.confirm) {
                this.$emit('auto-close-picker');
            }
            // 暴露对外点击接口
            this.$emit('on-shortcut-click', item);
            this.$emit('on-date-change');

return this._change("@error", evtargs) ;
      }
    }
    
    // Event not found, try higher level of event (e.g. readFile.done becomes readFile)
    splitevt = evtname.split('.') ;
    splitevt.pop() ;
    if (splitevt.length) {
      evtname = splitevt.join('.') ;
      evtlevel += 1 ;
      evtRightMatch = _calcRightMatch(evtRightMatch, evtname) ;
    } else {
      if (this.parent) {
        // Bubble event up to parent
        
        if (_.isArray(inevent)) {
          inevent[0] = fullevtname ;
        } else {
          inevent = fullevtname ;
        }
        
        this.parent._inject(this, inevent, argshift) ;
      } else {
        if (this.debugEmitter) {
          this.debugEmitter.emit('warn', this, this.stateName, evtname, "Unexpected event '"+fullevtname+"'.") ;
        }
        if (this.jsmFactory.options.strict) {
          evtargs.unshift(new Error("Event ["+evtname+"] received in ["+this.stateName+"].")) ;
          return this._change("@error") ;
        }
        
        // Otherwise ignore