Análisis de argumentos de línea de comandos

AWK también lo utiliza ARGV.

INICIO { para ( i = 0 ; i < ARGC ; i ++ ) { imprimir ARGV [ i ] } }

C se utiliza argvpara procesar argumentos de línea de comandos. ^{[ 4 ] [ 5 ]}

Un ejemplo de análisis de argumentos en C sería:

#include <stdio.h>int main ( int argc , char * argv []) { for ( int i = 0 ; i < argc ; ++ i ) { printf ( "%s \n " , argv [ count ]); } }

La biblioteca C POSIX también tiene funciones llamadas getopt()y getopt_long().

C++ accede a los argumentos de la misma manera que C.

importar std ;using std :: string ; using std :: vector ;int main ( int argc , char * argv []) { vector <string> args ( argv , argv + argc ) ; for ( const string & s : args ) { std :: println ( "{}" , s ) ; } }

Las bibliotecas POCO C++ ofrecen una clase Poco::Util::OptionProcessorpara analizar argumentos de línea de comandos. ^{[ 6 ]} Boost proporciona una clase boost::program_options::command_line_parser. ^{[ 7 ]} Mientras tanto, Google tiene una biblioteca llamada gflags. También hay una argparsebiblioteca para C++17 + que ofrece una API similar para el análisis de argumentos a Python argparse. ^{[ 8 ]}

Un ejemplo de análisis de argumentos en C# sería:

clase ReadArgs { static void Main ( string [] args ) { foreach ( string arg in args ) { Console . WriteLine ( arg ); } } }

C# proporciona el System.CommandLineespacio de nombres para el análisis avanzado de argumentos de línea de comandos. ^{[ 9 ]}

El lenguaje de programación Dstd.getopt proporciona un módulo .

Go proporciona el flagpaquete para el análisis de argumentos.

Haskell proporciona la biblioteca System.Console.GetOpt.

Un ejemplo de análisis de argumentos en Java sería:

public class ReadArgs { public static void main ( String [] args ) { for ( String s : args ) { System . out . println ( s ); } } }

La biblioteca Apache Commonsorg.apache.commons.cli proporciona capacidades de análisis de argumentos de línea de comandos. ^{[ 10 ]} También existe la gnu.getoptbiblioteca, portada desde GNU getopt.

Aquí hay algunas formas posibles de imprimir argumentos en Kotlin : ^{[ 11 ]}

fun main ( args : Array < String > ) = println ( args . joinToString ())

fun main ( args : Array < String > ) = println ( args . contentToString ())

fun main ( args : Array < String > ) { for ( arg in args ) { println ( arg ) } }

Perl utiliza @ARGV.

foreach $arg ( @ARGV ) { print $arg ; }

o

foreach $argnum ( 0 .. $#ARGV ) { print $ARGV [ $argnum ]; }

También existe Getopt::Longy Getopt::Stdpara el análisis de argumentos.

PHP utiliza argccomo contador de argumentos y argvcomo matriz que contiene los valores de los argumentos. ^{[ 12 ] [ 13 ]} Para crear una matriz a partir de argumentos de línea de comandos en el -foo:barformato, se podría utilizar lo siguiente:

$args = parseArgs ( $argv ); echo getArg ( $args , "foo" );function parseArgs ( array $args ) : array { foreach ( $args as $arg ) { $tmp = explode ( ":" , $arg , 2 ); if ( $arg [ 0 ] === "-" ) { $args [ substr ( $tmp [ 0 ], 1 )] = $tmp [ 1 ]; } } return $args ; }function getArg ( array $args , string $arg ) : string | bool { if ( isset ( $args [ $arg ])) { return $args [ $arg ]; } return false ; }

PHP también puede usar getopt(). ^{[ 14 ]}

Python utiliza sys.argv, por ejemplo:

importar sysif __name__ == " __main__ " : for arg in sys.argv : print ( arg )

Python también tiene un módulo llamado argparseen la biblioteca estándar para analizar argumentos de línea de comandos. ^{[ 2 ]}

Racket utiliza un current-command-line-argumentsparámetro y proporciona una racket/cmdline^{[ 15 ]} biblioteca para analizar estos argumentos. Ejemplo:

#lang raqueta( requiere racket/cmdline )( definir sonrisa? ( make-parameter #t )) ( definir nariz? ( make-parameter #false )) ( definir ojos ( make-parameter ":" ))( línea de comandos #:programa "emoticono"#:once-any ; los dos siguientes son mutuamente excluyentes [( "-s" "--smile" ) "modo sonrisa" ( smile? #true )] [( "-f" "--frown" ) "modo ceño fruncido" ( smile? #false )]#:once-each [( "-n" "--nariz" ) "añadir una nariz" ( nariz? #true )] [( "-e" "--ojos" ) char "usar <char> para los ojos" ( ojos char )])( printf "~a~a~a \n " ( ojos ) ( si ( nariz? ) "-" "" ) ( si ( sonrisa? ) ")" "(" ))

La biblioteca analiza indicadores largos y cortos, maneja argumentos, permite combinar indicadores cortos y maneja -hautomáticamente --help:

$ racket /tmp/c -nfe 8 8-(

Rexx utiliza arg, por ejemplo:

hacer i = 1 a palabras ( arg ( 1 )) decir palabra ( arg ( 1 ), i ) fin

En lugar de formar parte de los parámetros de main()(como en otros lenguajes de estilo C), en Rust los argumentos están en std::env::args(), que devuelve un std::env::Argsy se convierte en un Vec<String>con .collect(). ^{[ 16 ]}

usar std :: env ;fn main () { let args : Vec < String > = env :: args (). collect ();let query : & String = & args [ 1 ]; let file_path : & String = & args [ 2 ];println! ( "Buscando {}" , query ); println! ( "En el archivo {}" , file_path ); }

Una biblioteca popular de Rust para el análisis de argumentos de línea de comandos es clap. ^{[ 17 ]}