Parsning av kommandoradsargument
Olika metoder för parsning av kommandoradsargument används av olika programmeringsspråk för att analysera kommandoradsargument .
Programmeringsspråk
C
C använder argv för att bearbeta kommandoradsargument.
Ett exempel på C- argumentanalys skulle vara:
0
#include <stdio.h> int main ( int argc , char * argv []) { int count ; for ( count = ; count < argc ; count ++ ) sätter ( argv [ count ]); }
C har också funktioner som kallas getopt och getopt_long.
C#
class TestClass { static void Main ( string [] args ) { // Visa antalet kommandoradsargument. Konsol . WriteLine ( args . Length ); } }
Java
Ett exempel på Java- argumentanalys skulle vara:
public class Echo { public static void main ( String [ ] args ) { for ( String s : args ) { System . ut . println ( s ); } } }
Kotlin
Här är några möjliga sätt att skriva ut argument i Kotlin :
fun main ( args : Array < String > ) = println ( args . joinToString ())
fun main ( args : Array < String > ) = println ( args . contentToString ())
fun main ( args : Array < String > ) { for ( arg i args ) println ( arg ) }
Perl
Perl använder @ARGV .
foreach $arg ( @ARGV ) GT { print $arg ; }
MED
eller
0
foreach $argnum ( .. $#ARGV ) ST { print $ARGV [ $argnum ]; }
AWK
AWK använder också ARGV .
0
BEGIN { for ( i = ; i < ARGC ; i ++ ) { print ARGV [ i ] } }
PHP
PHP använder argc som en räkning av argument och argv som en array som innehåller värdena för argumenten. För att skapa en array från kommandoradsargument i -foo:bar kan följande användas:
0
0
$args = parseArgs ( $argv ); echo getArg ( $args , 'foo' ); function parseArgs ( array $args ) { foreach ( $args as $arg ) { $tmp = explode ( ':' , $arg , 2 ); if ( $arg [ ] === '-' ) { $args [ substr ( $tmp [ ], 1 )] = $tmp [ 1 ]; } } returnera $args ; } funktion getArg ( array $args , sträng $arg ) { if ( isset ( $args [ $arg ])) { return $args [ $arg ]; } returnera falskt ; }
PHP kan också använda getopt() .
Pytonorm
Python använder sys.argv , t.ex.:
importera sys för arg i sys . argv : skriv ut arg
Python har också en modul som heter argparse i standardbiblioteket för att analysera kommandoradsargument.
Racket
Racket använder parametern current-command-line-arguments och tillhandahåller ett racket/cmdline- bibliotek för att analysera dessa argument. Exempel:
#lang racket ( kräver racket/cmdline ) ( definiera smile? ( make-parameter #t )) ( definiera näsa? ( make-parameter #false )) ( definiera ögon ( make-parameter ":" )) ( kommandorad # :program "emoticon" #:once-any ; följande två är ömsesidigt uteslutande [( "-s" "--smile" ) "smile mode" ( smile? #true )] [( "-f" "--frown " ) "rynka pannan" ( le? #false )] #:en gång varje [( "-n" "--näsa" ) "lägg till en näsa" ( näsa? #true )] [( "-e" "- -ögon" ) char "använd <char> för ögonen" ( ögon char )]) ( printf "~a~a~a \n " ( ögon ) ( if ( näsa? ) "-" "" ) ( if ( le? ) ")" "(" ))
Biblioteket analyserar långa och korta flaggor, hanterar argument, tillåter att korta flaggor kombineras och hanterar -h och --help automatiskt:
$ racket /tmp/c -nfe 8 8-(
Rexx
Rexx använder arg , t.ex.:
gör i = 1 till ord ( arg ( 1 )) säg ord ( arg ( 1 ), i ) slut
Rost
Argarna finns i env::args() .
använd std :: env ; fn main () { let args : Vec < String > = env :: args (). samla (); let query = & args [ 1 ]; let file_path = & args [ 2 ]; println! ( "Söker efter {}" , fråga ); println! ( "I fil {}" , filsökväg ); }
Node.js
JavaScript- program skrivna för Node.js använder den globala variabeln process.argv .
// argv.js konsol . log ( process . argv );
$ node argv.js en två tre fyra fem [ 'nod' , '/home/avian/argvdemo/argv.js' , 'en' , 'två' , 'tre' , 'fyra' , 'fem' ]
Node.js -program anropas genom att köra tolknodtolken med en given fil, så de två första argumenten kommer att vara nod och namnet på JavaScript-källfilen. Det är ofta användbart att extrahera resten av argumenten genom att dela upp en sub-array från process.argv .
// process-args.js konsol . log ( process . argv . skiva ( 2 ));
$ node process-args.js en två = tre fyra [ 'en' , 'två=tre' , 'fyra' ]