Kaip perduoti komandų eilutės argumentus „Node.js“?

Turiu žiniatinklio serverį, parašytą „ Node.js“ , ir norėčiau jį paleisti su tam tikru aplanku. Nesu tikras, kaip pasiekti argumentus javascript'e. Paleidžiu mazgus taip:

 $ node server.js folder 

čia server.js yra mano serverio kodas. „Node.js“ padeda sakyti, kad tai įmanoma:

 $ node -h Usage: node [options] script.js [arguments] 

Kaip pasiekti šiuos argumentus javascript'e? Kažkaip negalėjau rasti šios informacijos internete.

1989 m
04 дек. pieno pertekliaus rinkinys 04 d. 2010-12-04 04:56 '10, 4:56, 2010-12-04 04:56
@ 29 atsakymai

Standartinis metodas (be bibliotekos)

Argumentai yra saugomi process.argv

Toliau pateikiami mazgo dokumentai, kai tvarkomi komandų eilutės komandos:

process.argv yra masyvas, kuriame yra komandų eilutės argumentai. Pirmasis elementas bus „mazgas“, antrasis elementas bus „JavaScript“ failo pavadinimas. Šie elementai bus papildomi komandų eilutės argumentai.

 // print process.argv process.argv.forEach(function (val, index, array) { console.log(index + ': ' + val); }); 

Tai sukurs:

 $ node process-2.js one two=three four 0: node 1: /Users/mjr/work/node/process-2.js 2: one 3: two=three 4: four 
2612
04 дек. Atsakymas duotas MooGoo 04 Dec. 2010-12-04 05:05 '10, 5:05 2010-12-04 05:05

Norint normalizuoti argumentus, pvz., Įprastą „JavaScript“ funkciją, ją gausiu „node.js“ apvalkalo scenarijuose:

 var args = process.argv.slice(2); 

Atkreipkite dėmesį, kad pirmasis argumentas paprastai yra kelias į „nodejs“, o antrasis „arg“ - vykdomo scenarijaus vieta.

538
24 апр. Mauvis Ledford atsakymas, pateiktas balandžio 24 d 2011-04-24 02:13 '11 at 2:13 2011-04-24 02:13

Paskutinis teisingas atsakymas yra naudoti minimistų biblioteką. Mes naudojomės „ node-optimist“ , bet nuo to laiko jis yra pasenęs.

Čia pateikiamas pavyzdys, kaip jį naudoti tiesiogiai iš minimistinės dokumentacijos:

 var argv = require('minimist')(process.argv.slice(2)); console.dir(argv); 

-

 $ node example/parse.js -a beep -b boop { _: [], a: 'beep', b: 'boop' } 

-

 $ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz { _: [ 'foo', 'bar', 'baz' ], x: 3, y: 4, n: 5, a: true, b: true, c: true, beep: 'boop' } 
280
08 июля '14 в 20:26 2014-07-08 20:26 atsakymas pateikiamas real_ate liepos 8 d. 14 d. 20:26 2014-07-08 20:26

2018 atsakymas, remiantis dabartinėmis laukinės gamtos tendencijomis:


„Vanilla javascript“ argumentų analizė:

 const args = process.argv; console.log(args); 

Tai grąžina:

 $ node server.js one two=three four ['node', '/home/server.js', 'one', 'two=three', 'four'] 

Oficialūs dokumentai


Dažniausiai naudojami NPM paketai, skirti analizuoti argumentus:

Minimistas : už minimalią argumento analizę.

Commander.js : populiariausias modulis argumentų analizavimui.

Miau : lengvesnė alternatyva Commander.js

Jargs : sudėtingesnė argumentų analizė (sunki).

Vorpal.js : brandžios / interaktyvios komandinės eilutės programos su argumentų argumentais.

247
14 янв. atsakymas pateikiamas dthree Jan 14 2016-01-14 08:26 '16 at 8:26 2016-01-14 08:26

Optimistas (mazgas optimistas)

Patikrinkite optimistų biblioteką , tai yra daug geriau nei rankiniu būdu analizuojant komandų eilutės parametrus.

Atnaujinti

Optimistas yra pasenęs. Išbandykite yargovą, kuris yra aktyvus šakutė.

114
04 июля '11 в 7:02 2011-07-04 07:02 atsakymas pateikiamas liepos 4 d., 11 d., 07:02 2011-07-04 07:02

Kai kurie puikūs atsakymai čia, bet viskas atrodo labai sudėtinga. Tai labai panaši į tai, kaip scenarijai suteikia prieigą prie argumentų reikšmių, ir jau pateikė standartą su node.js, kaip nurodė MooGoo. (Tiesiog suprantama, kad kažkas naujo node.js)

Pavyzdys:

 $ node yourscript.js banana monkey var program_name = process.argv[0]; //value will be "node" var script_path = process.argv[1]; //value will be "yourscript.js" var first_value = process.argv[2]; //value will be "banana" var second_value = process.argv[3]; //value will be "monkey" 
82
12 дек. Atsakymas pateikiamas Kalemanzi 12 d. 2013-12-12 08:19 '13, 8:19, 2013-12-12 08:19

Commander.js

Puikiai apibrėžti savo galimybes, veiksmus ir argumentus. Jis taip pat sukuria jums pagalbos puslapius.

Nedelsiant

Jis puikiai tinka norint gauti informaciją iš naudotojo, jei jums patinka atgalinio ryšio metodas.

Bendra užklausa

Jis puikiai tinka norint gauti informaciją iš vartotojo, jei jums patinka požiūris į generatorių.

70
20 сент. Atsakymas pateikiamas balupton 20 sep . 2011-09-20 13:20 '11, 13:20, 2011-09-20 13:20

Stdio biblioteka

Lengviausias būdas analizuoti komandų eilutės argumentus „NodeJS“ yra naudoti stdio modulį. Įkvėptas UNIX getopt naudingumo, tai taip pat yra nereikšminga:

 var stdio = require('stdio'); var ops = stdio.getopt({ 'check': {key: 'c', args: 2, description: 'What this option means'}, 'map': {key: 'm', description: 'Another description'}, 'kaka': {args: 1, mandatory: true}, 'ooo': {key: 'o'} }); 

Jei paleisite ankstesnį kodą su šia komanda:

 node <your_script.js> -c 23 45 --map -k 23 file1 file2 

Tada ops objektas atrodys taip:

 { check: [ '23', '45' ], args: [ 'file1', 'file2' ], map: true, kaka: '23' } 

Taigi galite jį naudoti taip, kaip norite. Pavyzdžiui:

 if (ops.kaka  ops.check) { console.log(ops.kaka + ops.check[0]); } 

Grupės parametrai taip pat palaikomi, todėl jūs galite rašyti -om vietoj -o -m .

Be to, stdio gali automatiškai generuoti pagalbos / naudojimo išėjimą. Jei skambinate ops.printHelp() , gausite:

 USAGE: node something.js [--check <ARG1> <ARG2>] [--kaka] [--ooo] [--map] -c, --check <ARG1> <ARG2> What this option means (mandatory) -k, --kaka (mandatory) --map Another description -o, --ooo 

Ankstesnis pranešimas taip pat rodomas, jei nenurodoma reikalinga parinktis (prieš klaidos pranešimą) arba jei ji neteisinga (pvz., Jei nurodote vieną argumentą pasirinkimui ir jam reikia 2).

Galite įdiegti „ NPM stdio“ modulį:

 npm install stdio 
41
13 авг. atsakymas pateikiamas sgmonda 13 rug . 2013-08-13 13:30 '13, 13:30, 2013-08-13 13:30

Jei jūsų scenarijus vadinamas myScript.js ir norite perduoti pirmąjį ir pavardę, „Sean Worthington“, kaip argumentus, kaip parodyta žemiau:

 node myScript.js Sean Worthington 

Tada jūsų scenarijuje rašote:

 var firstName = process.argv[2]; // Will be set to 'Sean' var lastName = process.argv[3]; // Will be set to 'Worthington' 
36
17 июня '13 в 3:04 2013-06-17 03:04 atsakė Seanui H. Worthingtonui birželio 17 d. 13:04 2013-06-17 03:04

Komandinės eilutės argumentai, kuriuos verta pamatyti!

Galite nustatyti parametrus naudodami pagrindinius pavadinimo standartus ( daugiau sužinoti ). Visos šios komandos yra lygiavertės, nustatant tas pačias reikšmes:

 $ example --verbose --timeout=1000 --src one.js --src two.js $ example --verbose --timeout 1000 --src one.js two.js $ example -vt 1000 --src one.js two.js $ example -vt 1000 one.js two.js 

Jei norite pasiekti vertes, pirmiausia sukurkite parametrų apibrėžčių, apibūdinančių jūsų taikomuosius parametrus, sąrašą. type ypatybė yra diegimo funkcija (perduota vertė perduodama per ją), kuri suteikia jums pilną kontrolę gautai vertei.

 const optionDefinitions = [ { name: 'verbose', alias: 'v', type: Boolean }, { name: 'src', type: String, multiple: true, defaultOption: true }, { name: 'timeout', alias: 't', type: Number } ] 

Tada analizuokite parametrus naudodami komandąLineArgs () :

 const commandLineArgs = require('command-line-args') const options = commandLineArgs(optionDefinitions) 

options dabar atrodo taip:

 { src: [ 'one.js', 'two.js' ], verbose: true, timeout: 1000 } 

Išplėstinis naudojimas

Be aukščiau aprašyto tipinio naudojimo, galite pritaikyti komandų eilutės argumentus, kad galėtumėte atlikti sudėtingesnę sintaksę.

Komandos pagrindu sukurta sintaksė (git stilius) tokia forma:

 $ executable <command> [options] 

Pavyzdžiui.

 $ git commit --squash -m "This is my commit message" 

Komandų ir pogrupių sintaksė („Docker“ stilius) yra tokia:

 $ executable <command> [options] <sub-command> [options] 

Pavyzdžiui.

 $ docker run --detached --image centos bash -c yum install -y httpd 

Naudojimo vadovas

Naudojimo komandą (paprastai atspausdintą, kai įdiegta pagalba) galima sukurti naudojant komandinę eilutę . Žr. Toliau pateikiamus pavyzdžius ir perskaitykite dokumentaciją, kad gautumėte instrukcijas, kaip jas sukurti.

Tipiškas naudojimo vadovo pavyzdys.

Polymer-Cli“ programos vadovas yra geras gyvenimo pavyzdys.

Tolesnis skaitymas

Yra daug daugiau mokytis, žr . Wiki pavyzdžius ir dokumentus.

23
15 нояб. atsakymas pateikiamas Lloyd 15 lapkričio. 2015-11-15 19:00 „15 val. 7 val. 2015-11-15 19:00

Tai yra paraiška. Na, modulis. Na, daugiau nei vienas, gal šimtai.

Yargs yra vienas iš juokingiausių, jo dokumentai yra kieti skaityti.

Čia pateikiamas github / npm puslapio pavyzdys:

 #!/usr/bin/env node var argv = require('yargs').argv; console.log('(%d,%d)', argv.x, argv.y); console.log(argv._); 

Išėjimas yra čia (jis skaito parinktis su brūkšneliais ir tt, Trumpas ir ilgas, skaitmeninis ir tt).

 $ ./nonopt.js -x 6.82 -y 3.35 rum (6.82,3.35) [ 'rum' ] $ ./nonopt.js "me hearties" -x 0.54 yo -y 1.12 ho (0.54,1.12) [ 'me hearties', 'yo', 'ho' ] 
20
14 марта '15 в 3:45 2015-03-14 03:45 Zlatko atsakymą pateikė kovo 15 d., 15 val., 03:45 2015-03-14 03:45

Tikriausiai gera idėja valdyti konfigūraciją centralizuotai, naudojant kažką panašaus į „ nconf“ https://github.com/flatiron/nconf

Jis padeda jums dirbti su konfigūracijos failais, aplinkos kintamaisiais, komandų eilutės argumentais.

10
26 мая '12 в 3:10 2012-05-26 03:10 atsakymas duotas 250R gegužės 26 d. 12 val. 3:10 2012-05-26 03:10

be librairies: naudokite Array.prototype.reduce ()

 const args = process.argv.slice(2).reduce((acc, arg) => { let [k, v = true] = arg.split('=') acc[k] = v return acc }, {}) 

šiai komandai node index.js count=2 print debug=false msg=hi

 console.log(args) // { count: '2', print: true, debug: 'false', msg: 'hi' } 

ir

mes galime pakeisti

  let [k, v = true] = arg.split('=') acc[k] = v 

(daug ilgiau)

  let [k, v] = arg.split('=') acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v 

automatinei Būlio ir skaičiaus analizei

 console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' } 
9
13 окт. Joseph Merdrignac atsakymas, pateiktas spalio 13 d 2017-10-13 15:36 '17 15:36 2017-10-13 15:36

Čia yra mano 0-dep sprendimas minėtiems argumentams:

 const args = process.argv .slice(2) .map(arg => arg.split('=')) .reduce((args, [value, key]) => { args[value] = key; return args; }, {}); console.log(args.foo) console.log(args.fizz) 

Pavyzdys:

 $ node test.js foo=bar fizz=buzz bar buzz 

Pastaba Žinoma, tai nepavyks, jei argumente yra = . Tai tik labai paprasta naudoti.

9
30 июля '18 в 15:24 2018-07-30 15:24 atsakymą pateikė grebenyuksv liepos 30 d., 18 val. 15:24 2018-07-30 15:24

Perduodami argumentus yra paprastas procesas. Mazgas suteikia jums proceso.argv nuosavybę, kuri yra eilutės, kurios yra argumentai, kurie buvo naudojami skambinant „Node“. Pirmasis masyvo įrašas yra įvykdomas mazgas, o antrasis įrašas yra jūsų scenarijaus pavadinimas.

Jei paleisite scenarijų naudodami žemiau pateiktą informaciją

 $ node args.js arg1 arg2 

Failas: args.js

 console.log(process.argv) 

Jūs gausite panašų masyvą

  ['node','args.js','arg1','arg2'] 
9
11 янв. Atsakymą pateikė Piyush Sagar sausio 11 d. 2016-01-11 17:54 '16 at 17:54 2016-01-11 17:54
 npm install ps-grab 

Jei norite paleisti kažką panašaus:

 node greeting.js --user Abdennour --website http://abdennoor.com 

-

 var grab=require('ps-grab'); grab('--username') // return 'Abdennour' grab('--action') // return 'http://abdennoor.com' 

Arba kažką panašaus į:

 node vbox.js -OS redhat -VM template-12332 ; 

-

 var grab=require('ps-grab'); grab('-OS') // return 'redhat' grab('-VM') // return 'template-12332' 
7
15 июля '16 в 5:48 2016-07-15 05:48 atsakymą pateikė „ Abdennour TOUMI“ liepos 15 d. 16 val. 5:48 2016-07-15 05:48

Nr bibliotekos su vėliavomis suformatuotos kaip paprastas objektas.

 function getArgs () { const args = {} process.argv .slice(2, process.argv.length) .forEach( arg => { // long arg if (arg.slice(0,2) === '--') { const longArg = arg.split('=') args[longArg[0].slice(2,longArg[0].length)] = longArg[1] } // flags else if (arg[0] === '-') { const flags = arg.slice(1,arg.length).split('') flags.forEach(flag => { args[flag] = true }) } }) return args } const args = getArgs() console.log(args) 

Pavyzdžiai

tiesiog

įėjimas

 node test.js -D --name=Hello 

išėjimas

 { D: true, name: 'Hello' } 

Realaus pasaulio

įėjimas

 node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev 

išėjimas

 { l: true, H: true, R: true, s: true, ip: '127.0.0.1', port: '8080', env: 'dev' } 
7
08 янв. Atsakymą pateikė Michael Warner , sausio 8 d 2019-01-08 22:43 '19 , 10:43 val. 2019-01-08 22:43

Galite analizuoti visus argumentus ir patikrinti, ar jie yra.

failas: parse-cli-argument.js:

 module.exports = function(requiredArguments){ var arguments = {}; for (var index = 0; index < process.argv.length; index++) { var re = new RegExp('--([A-Za-z0-9_]+)=([A/-Za-z0-9_]+)'), matches = re.exec(process.argv[index]); if(matches !== null) { arguments[matches[1]] = matches[2]; } } for (var index = 0; index < requiredArguments.length; index++) { if (arguments[requiredArguments[index]] === undefined) { throw(requiredArguments[index] + ' not defined. Please add the argument with --' + requiredArguments[index]); } } return arguments; } 

Kas yra paprasta:

 var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']); 
6
10 дек. Atsakymas pateiktas Amadu Bah 10 d. 2013-12-10 17:41 '13, 17:41, 2013-12-10 17:41

Galite naudoti komandų eilutės argumentus naudodami system.args . Ir aš naudoju žemiau pateiktą sprendimą, norint analizuoti objekto argumentus, todėl galiu gauti tą, kurį noriu pagal pavadinimą.

 var system = require('system'); var args = {}; system.args.map(function(x){return x.split("=")}) .map(function(y){args[y[0]]=y[1]}); 

dabar jums nereikia žinoti argumento indekso. naudoti jį kaip args.whatever

Pastaba: norėdami naudoti šį sprendimą, turite naudoti nurodytus argumentus, pvz., file.js x=1 y=2 .

6
10 авг. Evren Kutar atsakymas 10 rug . 2016-08-10 16:38 '16, 16:38 pm 2016-08-10 16:38

proj.js

 for(var i=0;i<process.argv.length;i++){ console.log(process.argv[i]); } 

Terminalas:

 nodemon app.js "arg1" "arg2" "arg3" 

Rezultatas:

 0 'C:\\Program Files\\nodejs\\node.exe' 1 'C:\\Users\\Nouman\\Desktop\\Node\\camer nodejs\\proj.js' 2 'arg1' your first argument you passed. 3 'arg2' your second argument you passed. 4 'arg3' your third argument you passed. 

Paaiškinimas:

0 : node.exe katalogas jūsų apdorojime (C: Programos failai nodejs node.exe)

1 : jūsų projekto failo katalogas. (proj.js)

2 : Jūsų pirmasis argumentas dėl mazgo (arg1)

3 : Jūsų antrasis argumentas, skirtas mazgiui (arg2)

4 : Jūsų trečiasis argumentas dėl mazgo (arg3)

Jūsų faktiniai argumentai prasideda 2nd argv masyvo indeksu, t.y. process.argv[2] .

5
02 июля '18 в 16:40 2018-07-02 16:40 Atsakymą įteikė Nouman Dilshad liepos 18 d. 18 val. 16.40 2018-07-02 16:40

Paprasčiausias būdas gauti argumentus „Node.js“ yra procesas.argv masyvas. Tai yra pasaulinis objektas, kurį galite naudoti be jokių papildomų bibliotekų. Jums tereikia perduoti argumentus „Node.js“ programai, kaip parodėme anksčiau, ir šie argumentai gali būti pasiekiami programoje per process.argv masyvą.

Pirmasis proceso.argv masyvo elementas visada bus failų sistemos kelias, nukreiptas į mazgo vykdomąjį failą. Antrasis elementas yra vykdomo javascript failo pavadinimas. Trečiasis elementas yra pirmasis argumentas, kurį vartotojas iš tikrųjų perdavė.

 'use strict'; for (let j = 0; j < process.argv.length; j++) { console.log(j + ' -> ' + (process.argv[j])); } 

Viskas, ką šis scenarijus daro, yra ciklo per procesą .argv masyvas ir spausdinti indeksus kartu su šiuose indeksuose saugomais elementais. Tai labai naudinga derinant, jei kada nors abejojate, kokiais argumentais jūs gaunate ir kokia tvarka.

Taip pat galite naudoti bibliotekas, pvz., „Yargs“, kad dirbtumėte su commnadline argumentais.

3
22 мая '18 в 14:36 2018-05-22 14:36 atsakymą Rubinas bhandaris pateikė gegužės 22 d. 18 val. 2:36 val. 2018-05-22 14:36

Be bibliotekų

Jei norite tai padaryti vanilėje JS / ES6, galite naudoti šį sprendimą.

dirbo tik „ NodeJS“> 6

 const args = process.argv .slice(2) .map((val, i)=>{ let object = {}; let [regexForProp, regexForVal] = (() => [new RegExp('^(.+?)='), new RegExp('\=(.*)')] )(); let [prop, value] = (() => [regexForProp.exec(val), regexForVal.exec(val)] )(); if(!prop){ object[val] = true; return object; } else { object[prop[1]] = value[1] ; return object } }) .reduce((obj, item) => { let prop = Object.keys(item)[0]; obj[prop] = item[prop]; return obj; }, {}); 

Ir ši komanda

 node index.js host=http://google.com port=8080 production 

sukels tokį rezultatą:

 console.log(args);//{ host:'http://google.com',port:'8080',production:true } console.log(args.host);//http://google.com console.log(args.port);//8080 console.log(args.production);//true 

ps Ištaisykite kortelės kodą ir sumažinkite funkciją, jei radote elegantiškesnį sprendimą;

3
03 окт. Atsakyti Cassidy 03 oct. 2017-10-03 23:05 '17, 11:05 pm 2017-10-03 23:05

Nors aukščiau pateikti atsakymai yra tobuli, ir kažkas jau pasiūlė „yargs“, paketo naudojimas yra labai paprastas. Tai geras paketas, kuris leidžia lengvai perduoti argumentus komandų eilutei.

 npm i yargs const yargs = require("yargs"); const argv = yargs.argv; console.log(argv); 

Daugiau informacijos rasite apsilankę https://yargs.js.org/ .

1
12 дек. Atsakymą pateikė Akshay Rajput, gruodžio 12 d. 2018-12-12 11:20 '18, 11:20 ; 2018-12-12 11:20

Dauguma žmonių davė gerų atsakymų. Taip pat norėčiau čia ką nors prisidėti. lodash atsakymą, naudodamas „ lodash biblioteką, kad lodash visus komandų eilutės argumentus, kuriuos perduodame, kai programa pradedama:

 // Lodash library const _ = require('lodash'); // Function that goes through each CommandLine Arguments and prints it to the console. const runApp = () => { _.map(process.argv, (arg) => { console.log(arg); }); }; // Calling the function. runApp(); 

Jei norite paleisti pirmiau nurodytą kodą, tiesiog paleiskite šias komandas:

 npm install node index.js xyz abc 123 456 

Rezultatas bus:

 xyz abc 123 456 
0
25 апр. atsakymas pateikiamas S.Mishra 25 d. 2018-04-25 19:56 '18, 07:56 pm 2018-04-25 19:56

process.argv yra jūsų draugas, komandų eilutės argumentų surinkimas iš pradžių yra palaikomas „Node JS“. Žr. Toliau pateiktą pavyzdį:

 process.argv.forEach((val, index) => { console.log('${index}: ${val}'); }) 
0
08 июня '18 в 13:29 2018-06-08 13:29 atsakymas pateikiamas birželio 8–18 d. 13:29 val. 2018-06-08 13:29

kaip nurodyta dokumento dokumente. „Process.argv“ ypatybė grąžina masyvą, kuriame yra komandų eilutės argumentai, perduoti proceso „Node.js“ pradžioje.

Pvz., Tarkime, kad šis procesas-args.js scenarijus:

 // print process.argv process.argv.forEach((val, index) => { console.log('${index}: ${val}'); }); 

Pradėti „Node.js“ procesą kaip:

  $ node process-args.js one two=three four 

Bus sukurta išvestis:

 0: /usr/local/bin/node 1: /Users/mjr/work/node/process-args.js 2: one 3: two=three 4: four 
0
24 апр. Atsakymas, kurį pateikė Adeojo Emmanuel IMM 2018-04-24 03:14 '18 at 3:14 2018-04-24 03:14

Geriausias būdas perduoti komandų eilutės argumentus „Node.js“ yra komandinės eilutės sąsajos (CLI) naudojimas.

Yra puikus npm modulis, vadinamas nodejs-cli , kurį galite naudoti.

Jei norite ją sukurti be jokių priklausomybių, aš ją turiu savo „Github“, jei norite jį patikrinti, iš tikrųjų tai gana paprasta ir paprasta naudoti, spustelėkite čia .

0
25 янв. atsakymas pateikiamas madhur acharya 25 sausio. 2019-01-25 19:40 '19 , 7:40 pm 2019-01-25 19:40

Taip pat galite naudoti paketą „yargs“, tai labai palengvins užduotį! tai viskas :) Yarga

-1
27 апр. atsakymas pateikiamas Rajakumar 27 balandžio. 2018-04-27 06:50 '18, 6:50 2018-04-27 06:50

Paprastas fragmentas, jei reikia:

 var fs = require('fs'), objMod = {}; process.argv.slice(2).map(function(y, i) { y = y.split('='); if (y[0]  y[1]) objMod[y[0]] = y[1]; else console.log('Error in argument number ' + (i+1)); }); 
-4
08 июня '17 в 1:01 2017-06-08 01:01 atsakymą pateikė Casy birželio 8 d. 17 d. 1:01 2017-06-08 01:01