Класс SimpleNamespace
может использоваться для создания новых атрибутов с помощью setattr
или подкласса SimpleNamespace
и создания вашей собственной функции для добавления новых имен атрибутов (переменных).
from types import SimpleNamespace
variables = {"b":"B","c":"C"}
a = SimpleNamespace(**v)
setattr(a,"g","G")
a.g = "G+"
something = a.a
const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
//do whatever here
})
Есть execa , класс охлаждения известен как A лучше child_process
Установить
npm install execa
Использование
const execa = require('execa');
(async () => {
const {stdout} = await execa('echo', ['This module is cool']);
console.log(stdout);
//=> 'This module is cool'
})();
@ hexacyanide почти завершен. В команде Windows prince
могут быть prince.exe
, prince.cmd
, prince.bat
или только prince
(я не знаю, как связаны драгоценные камни, но урны npm имеют сценарий sh и пакетный скрипт - npm
и npm.cmd
). Если вы хотите написать переносимый скрипт, который будет работать в Unix и Windows, вы должны создать правильный исполняемый файл.
Вот простая, но портативная функция появления:
function spawn(cmd, args, opt) {
var isWindows = /win/.test(process.platform);
if ( isWindows ) {
if ( !args ) args = [];
args.unshift(cmd);
args.unshift('/c');
cmd = process.env.comspec;
}
return child_process.spawn(cmd, args, opt);
}
var cmd = spawn("prince", ["-v", "builds/pdf/book.html", "-o", "builds/pdf/book.pdf"])
// Use these props to get execution results:
// cmd.stdin;
// cmd.stdout;
// cmd.stderr;
Для еще более новой версии Node.js (v8.1.4) события и вызовы аналогичны или идентичны старым версиям, но рекомендуется использовать стандартные новые возможности языка. Примеры:
Для буферизованного выходного файла без потока (вы получаете его все сразу) используйте child_process.exec
:
const { exec } = require('child_process');
exec('cat *.js bad_file | wc -l', (err, stdout, stderr) => {
if (err) {
// node couldn't execute the command
return;
}
// the *entire* stdout and stderr (buffered)
console.log(`stdout: ${stdout}`);
console.log(`stderr: ${stderr}`);
});
Вы можете также используйте его с обещаниями:
const util = require('util');
const exec = util.promisify(require('child_process').exec);
async function ls() {
const { stdout, stderr } = await exec('ls');
console.log('stdout:', stdout);
console.log('stderr:', stderr);
}
ls();
Если вы хотите получать данные постепенно в кусках (выводите как поток), используйте child_process.spawn
:
const { spawn } = require('child_process');
const child = spawn('ls', ['-lh', '/usr']);
// use child.stdout.setEncoding('utf8'); if you want text chunks
child.stdout.on('data', (chunk) => {
// data from standard output is here as buffers
});
// since these are streams, you can pipe them elsewhere
child.stderr.pipe(dest);
child.on('close', (code) => {
console.log(`child process exited with code ${code}`);
});
Обе эти функции имеют синхронный аналог. Пример для child_process.execSync
:
const { execSync } = require('child_process');
// stderr is sent to stdout of parent process
// you can set options.stdio if you want it to go elsewhere
let stdout = execSync('ls');
Также как child_process.spawnSync
:
const { spawnSync} = require('child_process');
const child = spawnSync('ls', ['-lh', '/usr']);
console.log('error', child.error);
console.log('stdout ', child.stdout);
console.log('stderr ', child.stderr);
Примечание. Следующий код по-прежнему функционирует, но в первую очередь предназначен для пользователей ES5 и ранее.
Модуль для нереста дочерних процессов с помощью Node.js хорошо документирован в документации (v5.0.0). Чтобы выполнить команду и получить ее полный вывод в качестве буфера, используйте child_process.exec
:
var exec = require('child_process').exec;
var cmd = 'prince -v builds/pdf/book.html -o builds/pdf/book.pdf';
exec(cmd, function(error, stdout, stderr) {
// command output is in stdout
});
Если вам нужно использовать операции ввода / вывода процесса с потоками, например когда вы ожидаете больших объемов вывода, используйте child_process.spawn
:
var spawn = require('child_process').spawn;
var child = spawn('prince', [
'-v', 'builds/pdf/book.html',
'-o', 'builds/pdf/book.pdf'
]);
child.stdout.on('data', function(chunk) {
// output will be here in chunks
});
// or if you want to send output elsewhere
child.stdout.pipe(dest);
Если вы выполняете файл, а не команду, вы можете использовать child_process.execFile
, параметры которого почти идентичны spawn
, но имеют четвертый параметр обратного вызова, например exec
для извлечения выходных буферов. Это может выглядеть примерно так:
var execFile = require('child_process').execFile;
execFile(file, args, options, function(error, stdout, stderr) {
// command output is in stdout
});
Начиная с v0.11.12 , узел теперь поддерживает синхронные spawn
и exec
. Все описанные выше методы являются асинхронными и имеют синхронный аналог. Документацию для них можно найти здесь здесь . Обратите внимание, что в отличие от методов, используемых для генерации дочерних процессов асинхронно, синхронные методы не возвращают экземпляр ChildProcess
.
child.pipe(dest)
(которого не существует) вы должны использовать child.stdout.pipe(dest)
и child.stderr.pipe(dest)
, например. child.stdout.pipe(process.stdout)
и child.stderr.pipe(process.stderr)
.
– ComFreek
28 August 2015 в 13:29
echo "hello"
и echo "world"
.
– Cameron
24 May 2017 в 15:24
Вы ищете child_process.exec
Вот пример:
const exec = require('child_process').exec;
const child = exec('cat *.js bad_file | wc -l',
(error, stdout, stderr) => {
console.log(`stdout: ${stdout}`);
console.log(`stderr: ${stderr}`);
if (error !== null) {
console.log(`exec error: ${error}`);
}
});
data
на stdout. Посмотрите в документах, но это должно быть что-то вроде childProc.stdout.on("data", fn)
.
– hgoebl
9 October 2015 в 12:32
'cmd', ['/c', 'dir']
. По крайней мере, я просто искал высокий и низкий, почему 'dir'
без аргументов не работает, прежде чем я вспомнил об этом ...;)
– AndyO
13 April 2018 в 21:31
Я просто написал помощник Cli, чтобы легко справляться с Unix / windows.
Javascript:
define(["require", "exports"], function (require, exports) {
/**
* Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments.
* Requires underscore or lodash as global through "_".
*/
var Cli = (function () {
function Cli() {}
/**
* Execute a CLI command.
* Manage Windows and Unix environment and try to execute the command on both env if fails.
* Order: Windows -> Unix.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success.
* @param callbackErrorWindows Failure on Windows env.
* @param callbackErrorUnix Failure on Unix env.
*/
Cli.execute = function (command, args, callback, callbackErrorWindows, callbackErrorUnix) {
if (typeof args === "undefined") {
args = [];
}
Cli.windows(command, args, callback, function () {
callbackErrorWindows();
try {
Cli.unix(command, args, callback, callbackErrorUnix);
} catch (e) {
console.log('------------- Failed to perform the command: "' + command + '" on all environments. -------------');
}
});
};
/**
* Execute a command on Windows environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success callback.
* @param callbackError Failure callback.
*/
Cli.windows = function (command, args, callback, callbackError) {
if (typeof args === "undefined") {
args = [];
}
try {
Cli._execute(process.env.comspec, _.union(['/c', command], args));
callback(command, args, 'Windows');
} catch (e) {
callbackError(command, args, 'Windows');
}
};
/**
* Execute a command on Unix environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success callback.
* @param callbackError Failure callback.
*/
Cli.unix = function (command, args, callback, callbackError) {
if (typeof args === "undefined") {
args = [];
}
try {
Cli._execute(command, args);
callback(command, args, 'Unix');
} catch (e) {
callbackError(command, args, 'Unix');
}
};
/**
* Execute a command no matters what's the environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @private
*/
Cli._execute = function (command, args) {
var spawn = require('child_process').spawn;
var childProcess = spawn(command, args);
childProcess.stdout.on("data", function (data) {
console.log(data.toString());
});
childProcess.stderr.on("data", function (data) {
console.error(data.toString());
});
};
return Cli;
})();
exports.Cli = Cli;
});
Оригинальный исходный файл исходных текстов:
/**
* Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments.
* Requires underscore or lodash as global through "_".
*/
export class Cli {
/**
* Execute a CLI command.
* Manage Windows and Unix environment and try to execute the command on both env if fails.
* Order: Windows -> Unix.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success.
* @param callbackErrorWindows Failure on Windows env.
* @param callbackErrorUnix Failure on Unix env.
*/
public static execute(command: string, args: string[] = [], callback ? : any, callbackErrorWindows ? : any, callbackErrorUnix ? : any) {
Cli.windows(command, args, callback, function () {
callbackErrorWindows();
try {
Cli.unix(command, args, callback, callbackErrorUnix);
} catch (e) {
console.log('------------- Failed to perform the command: "' + command + '" on all environments. -------------');
}
});
}
/**
* Execute a command on Windows environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success callback.
* @param callbackError Failure callback.
*/
public static windows(command: string, args: string[] = [], callback ? : any, callbackError ? : any) {
try {
Cli._execute(process.env.comspec, _.union(['/c', command], args));
callback(command, args, 'Windows');
} catch (e) {
callbackError(command, args, 'Windows');
}
}
/**
* Execute a command on Unix environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @param callback Success callback.
* @param callbackError Failure callback.
*/
public static unix(command: string, args: string[] = [], callback ? : any, callbackError ? : any) {
try {
Cli._execute(command, args);
callback(command, args, 'Unix');
} catch (e) {
callbackError(command, args, 'Unix');
}
}
/**
* Execute a command no matters what's the environment.
*
* @param command Command to execute. ('grunt')
* @param args Args of the command. ('watch')
* @private
*/
private static _execute(command, args) {
var spawn = require('child_process').spawn;
var childProcess = spawn(command, args);
childProcess.stdout.on("data", function (data) {
console.log(data.toString());
});
childProcess.stderr.on("data", function (data) {
console.error(data.toString());
});
}
}
Example of use:
Cli.execute(Grunt._command, args, function (command, args, env) {
console.log('Grunt has been automatically executed. (' + env + ')');
}, function (command, args, env) {
console.error('------------- Windows "' + command + '" command failed, trying Unix... ---------------');
}, function (command, args, env) {
console.error('------------- Unix "' + command + '" command failed too. ---------------');
});
Начиная с версии 4 ближайшей альтернативой является метод child_process.execSync
:
const execSync = require('child_process').execSync;
var cmd = execSync('prince -v builds/pdf/book.html -o builds/pdf/book.pdf');
Обратите внимание, что этот метод блокирует цикл событий.
child_process
при использовании execSync
? И удаляется ли он сразу после команды, не так ли? Так что нет утечек памяти?
– NiCk Newman
14 June 2016 в 10:02
Если вы хотите что-то, что близко напоминает верхний ответ , но также синхронно, это будет работать.
var execSync = require('child_process').execSync;
var cmd = "echo 'hello world'";
var options = {
encoding: 'utf8'
};
console.log(execSync(cmd, options));