Enviando argumentos da linha de comando para o script npm

A scriptsparte do meu package.jsonatualmente é assim:

"scripts": {
    "start": "node ./script.js server"
}

... o que significa que posso executar npm startpara iniciar o servidor. Por enquanto, tudo bem.

No entanto, eu gostaria de poder executar algo como npm start 8080e ter o argumento (s) passado script.js(por exemplo npm start 8080=> node ./script.js server 8080). Isso é possível?

Editar 2014.10.30: É possível passar argumentos para a npm runpartir do npm 2.0.0

A sintaxe é a seguinte:

npm run <command> [-- <args>]

Observe o necessário --. É necessário separar os parâmetros passados ​​para se npmcomandar e os parâmetros passados ​​para o seu script.

Então, se você tem package.json

"scripts": {
    "grunt": "grunt",
    "server": "node server.js"
}

Em seguida, os seguintes comandos seriam equivalentes:

grunt task:target => npm run grunt -- task:target

node server.js --port=1337 => npm run server -- --port=1337

Para obter o valor do parâmetro, consulte esta pergunta . Para ler parâmetros nomeados, provavelmente é melhor usar uma biblioteca de análise como yargs ou minimist ; O nodejs expõe process.argvglobalmente, contendo valores de parâmetros da linha de comandos, mas essa é uma API de baixo nível (matriz de cadeias separada por espaço em branco, conforme fornecido pelo sistema operacional ao executável do nó).

Editar 2013.10.03: atualmente não é possível diretamente. Mas há um problemanpm relacionado ao GitHub aberto para implementar o comportamento que você está solicitando. Parece que o consenso é que isso seja implementado, mas isso depende de outro problema que foi resolvido antes.

Resposta original: Como uma solução alternativa (embora não muito útil), você pode fazer o seguinte:

Diga o nome do seu pacote de package.jsonis myPackagee você também

"scripts": {
    "start": "node ./script.js server"
}

Em seguida, adicione package.json:

"config": {
    "myPort": "8080"
}

E no seu script.js:

// defaulting to 8080 in case if script invoked not via "npm run-script" but directly
var port = process.env.npm_package_config_myPort || 8080

Dessa forma, por padrão npm start, usará 8080. No entanto, você pode configurá-lo (o valor será armazenado npmem seu armazenamento interno):

npm config set myPackage:myPort 9090

Em seguida, ao chamar npm start, 9090 será usado (o padrão de package.jsonserá substituído).

Você pediu para poder executar algo parecido npm start 8080 . Isso é possível sem a necessidade de modificar script.jsou configurar os arquivos da seguinte maneira.

Por exemplo, no seu "scripts"valor JSON, inclua--

"start": "node ./script.js server $PORT"

E então a partir da linha de comando:

$ PORT=8080 npm start

Eu confirmei que isso funciona usando o bash e o npm 1.4.23. Observe que esta solução alternativa não exige que o problema npm 3494 do GitHub seja resolvido.

Você também pode fazer isso:

Em package.json:

"scripts": {
    "cool": "./cool.js"
}

Em cool.js:

 console.log({ myVar: process.env.npm_config_myVar });

Na CLI:

npm --myVar=something run-script cool

Saída deve:

{ myVar: 'something' }

Atualização: Usando o npm 3.10.3, parece que ele apresenta minúsculas as process.env.npm_config_variáveis? Também estou usando better-npm-run, por isso não tenho certeza se esse é o comportamento padrão da baunilha ou não, mas esta resposta está funcionando. Em vez de process.env.npm_config_myVar, tenteprocess.env.npm_config_myvar

A resposta de jakub.g está correta, no entanto, um exemplo usando o grunhido parece um pouco complexo.

Então, minha resposta mais simples:

- Enviando um argumento de linha de comando para um script npm

Sintaxe para enviar argumentos de linha de comando para um script npm:

npm run [command] [-- <args>]

Imagine que temos uma tarefa de inicialização do npm em nosso package.json para iniciar o servidor de desenvolvimento webpack:

"scripts": {
  "start": "webpack-dev-server --port 5000"
},

Executamos isso a partir da linha de comando com npm start

Agora, se queremos passar uma porta para o script npm:

"scripts": {
  "start": "webpack-dev-server --port process.env.port || 8080"
},

executando isso e passando a porta, por exemplo, 5000 via linha de comando, seria o seguinte:

npm start --port:5000

- Usando a configuração package.json:

Como mencionado no jakub.g , você pode definir parâmetros na configuração do seu package.json

"config": {
  "myPort": "5000"
}

"scripts": {
  "start": "webpack-dev-server --port process.env.npm_package_config_myPort || 8080"
},

npm start usará a porta especificada em sua configuração ou, em alternativa, você pode substituí-la

npm config set myPackage:myPort 3000

- Definindo um parâmetro no seu script npm

Um exemplo de leitura de uma variável definida no seu script npm. Neste exemploNODE_ENV

"scripts": {
  "start:prod": "NODE_ENV=prod node server.js",
  "start:dev": "NODE_ENV=dev node server.js"
},

leia NODE_ENV em server.js quer prod ou dev

var env = process.env.NODE_ENV || 'prod'

if(env === 'dev'){
    var app = require("./serverDev.js");
} else {
    var app = require("./serverProd.js");
}

npm 2.x cli args de suporte

Comando

npm run-script start -- --foo=3

Package.json

"start": "node ./index.js"

Index.js

console.log('process.argv', process.argv);

Use process.argvno seu código e forneça apenas uma $*entrada para o valor dos scripts.

Como exemplo, tente com um script simples que apenas registra os argumentos fornecidos para padronizar echoargs.js:

console.log('arguments: ' + process.argv.slice(2));

package.json:

"scripts": {
    "start": "node echoargs.js $*"
}

Exemplos:

> npm start 1 2 3
arguments: 1,2,3

process.argv[0]é o executável (nó), process.argv[1]é o seu script.

Testado com npm v5.3.0 e nó v8.4.0

Se você deseja passar argumentos para o meio de um script npm, em vez de apenas anexá-los ao final, as variáveis ​​de ambiente embutidas parecem funcionar bem:

"scripts": {
  "dev": "BABEL_ARGS=-w npm run build && cd lib/server && nodemon index.js",
  "start": "npm run build && node lib/server/index.js",
  "build": "mkdir -p lib && babel $BABEL_ARGS -s inline --stage 0 src -d lib",
},

Aqui, npm run devpassa a -wbandeira de observação para babel, mas npm run startapenas executa uma compilação regular uma vez.

Eu estava usando essa linha única no passado e, depois de um tempo longe do Node.js, tentei redescobri-la recentemente. Semelhante à solução mencionada por @francoisrv, utiliza as node_config_*variáveis.

Crie o seguinte package.jsonarquivo mínimo :

{
  "name": "argument",
  "version": "1.0.0",
  "scripts": {
    "argument": "echo \"The value of --foo is '${npm_config_foo}'\""
  }
}

Execute o seguinte comando:

npm run argument --foo=bar

Observe a seguinte saída:

O valor de --foo é 'bar'

Tudo isso está bem documentado na documentação oficial do npm:

• https://docs.npmjs.com/using-npm/config

Nota: O cabeçalho Variáveis ​​de ambiente explica que as variáveis ​​contidas nos scripts se comportam de maneira diferente do que está definido na documentação. Isso é verdade quando se trata de distinção entre maiúsculas e minúsculas e também se o argumento é definido com um sinal de espaço ou igual .

Nota: Se você estiver usando um argumento com hífens, eles serão substituídos por sublinhados na variável de ambiente correspondente. Por exemplo, npm run example --foo-bar=bazcorresponderia a ${npm_config_foo_bar}.

Nota: Para usuários não Windows do WSL, consulte os comentários do @Doctor Blue abaixo ... TL; DR substitua ${npm_config_foo}por %npm_config_foo%.

Isso realmente não responde à sua pergunta, mas você sempre pode usar variáveis ​​de ambiente:

"scripts": {
    "start": "PORT=3000 node server.js"
}

Em seguida, no seu arquivo server.js:

var port = process.env.PORT || 3000;

A maioria das respostas acima cobre apenas passar os argumentos para o script do NodeJS, chamado por npm. Minha solução é para uso geral.

Apenas envolva o script npm com uma shchamada de interpretador de shell (por exemplo ) e passe os argumentos como de costume. A única exceção é que o primeiro número do argumento é 0.

Por exemplo, você deseja adicionar o script npm someprogram --env=<argument_1>, onde someprogramapenas imprime o valor do envargumento:

package.json

"scripts": {
  "command": "sh -c 'someprogram --env=$0'"
}

Quando você o executa:

% npm run -s command my-environment
my-environment

Pelo que vejo, as pessoas usam scripts package.json quando desejam executar o script de maneira mais simples. Por exemplo, para usar nodemono instalado no node_modules local, não podemos chamar nodemondiretamente do cli, mas podemos chamá-lo usando ./node_modules/nodemon/nodemon.js. Então, para simplificar essa digitação longa, podemos colocar isso ...

    ...

    scripts: {
      'start': 'nodemon app.js'
    }

    ...

... então chame npm startpara usar 'nodemon', que tem app.js como o primeiro argumento.

O que estou tentando dizer, se você apenas deseja iniciar seu servidor com o nodecomando, acho que não precisa usá-lo scripts. Digitando npm startou node app.jstem o mesmo esforço.

Mas se você deseja usar nodemone deseja passar um argumento dinâmico, também não use script. Tente usar o link simbólico.

Por exemplo, usando a migração com sequelize. Eu crio um link simbólico ...

ln -s node_modules/sequelize/bin/sequelize sequelize

... E eu posso aprovar qualquer discussão quando eu chamo ...

./sequlize -h /* show help */

./sequelize -m /* upgrade migration */

./sequelize -m -u /* downgrade migration */

etc ...

Nesse ponto, usar o link simbólico é a melhor maneira de descobrir, mas realmente não acho que seja a melhor prática.

Também espero a sua opinião para a minha resposta.

Nota: Essa abordagem modifica o seu package.jsonem tempo real, use-o se você não tiver alternativa.

Eu tive que passar argumentos de linha de comando para meus scripts, que eram algo como:

"scripts": {
    "start": "npm run build && npm run watch",
    "watch": "concurrently  \"npm run watch-ts\" \"npm run watch-node\"",
    ...
}

Então, isso significa que inicio meu aplicativo npm run start.

Agora, se eu quiser passar alguns argumentos, começaria talvez:

npm run start -- --config=someConfig

O que isto faz é: npm run build && npm run watch -- --config=someConfig. O problema é que ele sempre anexa os argumentos ao final do script. Isso significa que todos os scripts encadeados não recebem esses argumentos (Args pode ou não ser exigido por todos, mas isso é uma história diferente). Além disso, quando os scripts vinculados são chamados, esses scripts não receberão os argumentos passados. ou seja, o watchscript não receberá os argumentos passados.

O uso de produção do meu aplicativo é como um .exe, portanto, passar os argumentos no exe funciona bem, mas se você quiser fazer isso durante o desenvolvimento, fica problemático.

Não consegui encontrar uma maneira adequada de conseguir isso, então é isso que tentei.

Criei um arquivo javascript: start-script.jsno nível pai do aplicativo, tenho um "default.package.json" e, em vez de manter "package.json", mantenho "default.package.json". O objetivo de start-script.jsoné ler default.package.json, extrair scriptse procurar npm run scriptnamee anexar os argumentos passados ​​a esses scripts. Depois disso, ele criará um novo package.jsone copiará os dados de default.package.json com scripts modificados e depois chamará npm run start.

const fs = require('fs');
const { spawn } = require('child_process');

// open default.package.json
const defaultPackage = fs.readFileSync('./default.package.json');
try {
    const packageOb = JSON.parse(defaultPackage);
    // loop over the scripts present in this object, edit them with flags
    if ('scripts' in packageOb && process.argv.length > 2) {

        const passedFlags = ` -- ${process.argv.slice(2).join(' ')}`;
        // assuming the script names have words, : or -, modify the regex if required.
        const regexPattern = /(npm run [\w:-]*)/g;
        const scriptsWithFlags = Object.entries(packageOb.scripts).reduce((acc, [key, value]) => {
            const patternMatches = value.match(regexPattern);
            // loop over all the matched strings and attach the desired flags.
            if (patternMatches) {
                for (let eachMatchedPattern of patternMatches) {
                    const startIndex = value.indexOf(eachMatchedPattern);
                    const endIndex = startIndex + eachMatchedPattern.length;
                    // save the string which doen't fall in this matched pattern range.
                    value = value.slice(0, startIndex) + eachMatchedPattern + passedFlags + value.slice(endIndex);
                }
            }
            acc[key] = value;
            return acc;
        }, {});
        packageOb.scripts = scriptsWithFlags;
    }

    const modifiedJSON = JSON.stringify(packageOb, null, 4);
    fs.writeFileSync('./package.json', modifiedJSON);

    // now run your npm start script
    let cmd = 'npm';
    // check if this works in your OS
    if (process.platform === 'win32') {
        cmd = 'npm.cmd';    // https://github.com/nodejs/node/issues/3675
    }
    spawn(cmd, ['run', 'start'], { stdio: 'inherit' });

} catch(e) {
    console.log('Error while parsing default.package.json', e);
}

Agora, em vez de fazer npm run start, eu façonode start-script.js --c=somethis --r=somethingElse

A execução inicial parece boa, mas não foi testada completamente. Use-o, se quiser, para o desenvolvimento de aplicativos.

Eu encontrei essa pergunta enquanto tentava resolver meu problema com o comando sequelize seed: generate cli:

node_modules/.bin/sequelize seed:generate --name=user

Deixe-me ir direto ao ponto. Eu queria ter um comando de script curto no meu arquivo package.json e fornecer o argumento --name ao mesmo tempo

A resposta veio após algumas experiências. Aqui está o meu comando no package.json

"scripts: {
  "seed:generate":"NODE_ENV=development node_modules/.bin/sequelize seed:generate"
}

... e aqui está um exemplo de executá-lo no terminal para gerar um arquivo inicial para um usuário

> yarn seed:generate --name=user

> npm run seed:generate -- --name=user

Para sua informação

yarn -v
1.6.0

npm -v
5.6.0

npm executa script_target - <argumento> Basicamente, esta é a maneira de passar os argumentos da linha de comando, mas funcionará apenas no caso em que o script tenha apenas um comando em execução, como eu estou executando um comando, ou seja, npm run start - 4200

"script":{
       "start" : "ng serve --port="
 }

Isso funcionará para passar parâmetros de linha de comando, mas e se executarmos mais de um comando juntos, como npm run build c: / workspace / file

"script":{
       "build" : "copy c:/file <arg> && ng build"
 } 

mas interpretará assim enquanto estiver executando cópia c: / file && ng build c: / espaço de trabalho / arquivo e espera-se que algo parecido com esta cópia c: / arquivo c: / espaço de trabalho / arquivo && ng build

Nota: - portanto, o parâmetro da linha de comando funciona apenas com o anúncio esperado no caso de apenas um comando em um script.

Eu li algumas respostas acima, nas quais alguns deles estão escrevendo que você pode acessar o parâmetro da linha de comando usando o símbolo $, mas isso não vai funcionar

Eu sei que já existe uma resposta aprovada, mas meio que gosto dessa abordagem JSON.

npm start '{"PROJECT_NAME_STR":"my amazing stuff", "CRAZY_ARR":[0,7,"hungry"], "MAGICAL_NUMBER_INT": 42, "THING_BOO":true}';

Normalmente, tenho 1 var de que preciso, como o nome de um projeto, então acho isso rápido e simples.

Também frequentemente tenho algo parecido com isto no meu package.json

"scripts": {
    "start": "NODE_ENV=development node local.js"
}

E sendo ganancioso, quero "tudo", NODE_ENV e a linha CMD arg.

Você simplesmente acessa essas coisas no seu arquivo (no meu caso, local.js)

console.log(process.env.NODE_ENV, starter_obj.CRAZY_ARR, starter_obj.PROJECT_NAME_STR, starter_obj.MAGICAL_NUMBER_INT, starter_obj.THING_BOO);

Você só precisa ter esse bit acima dele (estou executando a v10.16.0 btw)

var starter_obj = JSON.parse(JSON.parse(process.env.npm_config_argv).remain[0]);

Anyhoo, pergunta já respondida. Pensei em compartilhar, pois uso muito esse método.