How to use which - 10 common examples

launchEmulator = (name: string) => {
    // On Linux, you must run the emulator from the directory it's in because
    // reasons ...
    which('emulator')
      .then(emulatorPath => {
        if (emulatorPath) {
          const child = spawn(emulatorPath, [`@${name}`], {
            detached: true,
            cwd: dirname(emulatorPath),
          });
          child.stderr.on('data', data => {
            console.error(`Android emulator error: ${data}`);
          });
          child.on('error', console.error);
        } else {
          throw new Error('Could not get emulator path');
        }
      })
      .catch(console.error);
    this.props.preferDevice(name);

launchEmulator = (name: string) => {
    // On Linux, you must run the emulator from the directory it's in because
    // reasons ...
    which('emulator')
      .then(emulatorPath => {
        if (emulatorPath) {
          const child = spawn(emulatorPath, [`@${name}`], {
            detached: true,
            cwd: dirname(emulatorPath),
          });
          child.stderr.on('data', data => {
            console.error(`Android emulator error: ${data}`);
          });
          child.on('error', console.error);
        } else {
          throw new Error('Could not get emulator path');
        }
      })
      .catch(console.error);
    this.props.preferDevice(name);

function resolveBin (modName, {executable = modName, cwd = process.cwd()} = {}) {
  let pathFromWhich
  try {
    pathFromWhich = fs.realpathSync(which.sync(executable))
  } catch (_error) {
    // ignore _error
  }
  try {
    const modPkgPath = require.resolve(`${modName}/package.json`)
    const modPkgDir = path.dirname(modPkgPath)
    const { bin } = require(modPkgPath)
    const binPath = typeof bin === 'string' ? bin : bin[executable]
    const fullPathToBin = path.join(modPkgDir, binPath)
    if (fullPathToBin === pathFromWhich) {
      return executable
    }
    return fullPathToBin.replace(cwd, '.')
  } catch (error) {
    if (pathFromWhich) {
      return executable

function shouldPrependCurrentNodeDirToPATH (opts) {
  const cfgsetting = opts.scriptsPrependNodePath
  if (cfgsetting === false) return false
  if (cfgsetting === true) return true

  var isDifferentNodeInPath

  var foundExecPath
  try {
    foundExecPath = which.sync(path.basename(process.execPath), { pathExt: isWindows ? ';' : ':' })
    // Apply `fs.realpath()` here to avoid false positives when `node` is a symlinked executable.
    isDifferentNodeInPath = fs.realpathSync(process.execPath).toUpperCase() !==
        fs.realpathSync(foundExecPath).toUpperCase()
  } catch (e) {
    isDifferentNodeInPath = true
  }

  if (cfgsetting === 'warn-only') {
    if (isDifferentNodeInPath && !shouldPrependCurrentNodeDirToPATH.hasWarned) {
      if (foundExecPath) {
        opts.log.warn('lifecycle', 'The node binary used for scripts is', foundExecPath, 'but npm is using', process.execPath, 'itself. Use the `--scripts-prepend-node-path` option to include the path for the node binary npm was executed with.')
      } else {
        opts.log.warn('lifecycle', 'npm is using', process.execPath, 'but there is no node binary in the current PATH. Use the `--scripts-prepend-node-path` option to include the path for the node binary npm was executed with.')
      }
      shouldPrependCurrentNodeDirToPATH.hasWarned = true
    }

const state = store.getState();

	ansiHTML.setColors({
		'reset': ['fff', 'transparent'],
		'black': 'transparent',
	});

	window.keyHandler = new Keys();
	window.keyHandler.listen( store );

	// Fix the process.env path, which isn't inherited by the shell on macOS.
	fixPath();

	if ( ! state.installer.installed.chassis ) {
		// Search for installed applications.
		which( 'vagrant', err => {
			store.dispatch( actions.install.setStatus( 'vagrant', !err ) );
		});
		which( 'VirtualBox', err => {
			store.dispatch( actions.install.setStatus( 'virtualbox', !err ) );
		});
	} else {
		// Refresh machine state constantly.
		store.dispatch(actions.updateGlobalStatus());
		window.setInterval(() => store.dispatch(actions.updateGlobalStatus()), REFRESH_INTERVAL);

		// Refresh configuration.
		store.dispatch(loadAllConfig());
	}
};

path.resolve(
              (await pkgDir(__dirname)) || __dirname,
              'node_modules'
            ),
            path.resolve(this.context.paths.root, 'node_modules')
          ]
        })
      );
      if (!pkgPath) throw new Error(`package '${pkg}' not found`);
      command = path.resolve(
        pkgPath,
        // eslint-disable-next-line import/no-dynamic-require,global-require
        require(path.resolve(pkgPath, 'package.json')).bin[bin]
      );
    } else if (process.platform !== 'win32') {
      command = await which(command);
    }
    return new Promise((resolve, reject) => {
      const ps = crossSpawn(command, args, options);
      processes[ps.pid] = ps;
      let result: string | ChildProcess = ps;
      if (ps.stdout && ps.stderr) {
        result = '';
        ps.stdout.on('data', data => (result += data.toString()));
        ps.stderr.on('data', data => (result += data.toString()));
      }
      ps.on('close', () => resolve(result));
      ps.on('error', (err: Error) => reject(err));
    });
  }

/*
 * @copyright Copyright (c) Sematext Group, Inc. - All Rights Reserved
 *
 * @licence SPM for NodeJS is free-to-use, proprietary software.
 * THIS IS PROPRIETARY SOURCE CODE OF Sematext Group, Inc. (Sematext)
 * This source code may not be copied, reverse engineered, or altered for any purpose.
 * This source code is to be used exclusively by users and customers of Sematext.
 * Please see the full license (found in LICENSE in this distribution) for details on its license and the licenses of its dependencies.
 */
var which = require('which')
var vmstatCommand = which.sync('vmstat')
var exec = require('child_process').exec
var diskfree = require('node-df')

function vmstatS (callback) {
  exec(vmstatCommand + ' -s', function (err, stout, sterr) {
    if (err) {
      callback(err)
      return
    }
    try {
      var lines = stout.split('\n')
      lines = lines.map(function (line) { return line.trim()})
      if (lines.length >= 21) {
        var swapMapping = {
          swapUsed: 8,
          swapIn: 20,

return tslib_1.__awaiter(this, void 0, void 0, function* () {
            let { command } = this.config;
            if (command === 'gocode') {
                try {
                    which.sync('gocode');
                }
                catch (e) {
                    yield util_1.echoWarning(this.nvim, 'Could not find gocode in $PATH');
                    this.disabled = true;
                    return;
                }
            }
        });
    }

function getCordovaOrPhonegapCLI() {
    var cordovaCLI = 'cordova';
    try {
        which.sync(cordovaCLI);
        return cordovaCLI;
    }
    catch (e) {
        cordovaCLI = 'phonegap';
        which.sync(cordovaCLI);
        return cordovaCLI;
    }
}
exports.getCordovaOrPhonegapCLI = getCordovaOrPhonegapCLI;

fontforge: {},
      ttf2eot: {}
    };

    if (isLinux) {
        check.ttf2svg = {};
    } else {
        check['batik-ttf2svg'] = {};
    }

    var missing = [];

    for (var cmd in check) {
        if (check.hasOwnProperty(cmd)) {
            try {
                commands[cmd] = which(cmd);
            } catch(e) {
                missing.push(cmd);
            }
        }
    }

    if (missing.length) {
        if (isLinux) {
            var errNPM = [], errAPT = [];
            missing.forEach(function(cmd){
                if (cmd.indexOf("ttf2") != -1) {
                    errNPM.push(cmd);
                } else{
                    errAPT.push(cmd);
                }
            });