Punto de entrada

En la mayoría de los lenguajes de programación y sistemas operativos populares de hoy en día, un programa informático suele tener un único punto de entrada .

En los programas C , C++ , D , Zig , Rust y Kotlin, esta es una función llamada main; en Java es un método estático llamado main(aunque la clase debe especificarse en el momento de la invocación), y en C# es un método estático llamado Main. ^{[ 5 ] [ 6 ]}

En muchos sistemas operativos importantes, el formato ejecutable estándar tiene un único punto de entrada. En el formato ejecutable y enlazable (ELF), utilizado en sistemas Unix y similares como Linux , el punto de entrada se especifica en el e_entrycampo del encabezado ELF. En la colección de compiladores GNU (gcc), el punto de entrada utilizado por el enlazador es el _startsímbolo. De manera similar, en el formato ejecutable portátil ( PEF ), utilizado en Microsoft Windows , el punto de entrada se especifica mediante el AddressOfEntryPointcampo, que se hereda de COFF . En los archivos COM , el punto de entrada se encuentra en el desplazamiento fijo de 0100h.

Una excepción al paradigma de punto de entrada único es Android . Las aplicaciones de Android no tienen un único punto de entrada ; no existe una función especial. En cambio, cuentan con componentes esenciales (actividades y servicios) que el sistema puede cargar y ejecutar según sea necesario. ^{[ 7 ]} main

Una técnica que se usa ocasionalmente es el binario "fat" , que consiste en varios ejecutables para diferentes destinos empaquetados en un solo archivo. Generalmente, esto se implementa mediante un único punto de entrada general, compatible con todos los destinos, que se ramifica hacia el punto de entrada específico de cada destino. Otras técnicas incluyen almacenar los ejecutables por separado en bifurcaciones independientes , cada una con su propio punto de entrada, que luego es seleccionado por el sistema operativo.

Históricamente, y en algunos sistemas heredados contemporáneos , como VMS y OS/400 , los programas informáticos tienen multitud de puntos de entrada , cada uno correspondiente a las diferentes funcionalidades del programa. La forma habitual de indicar los puntos de entrada, tal como se utiliza en todo el sistema en VMS y en los programas PL/I y MACRO , es añadirlos al final del nombre de la imagen ejecutable , delimitados por un signo de dólar ($), por ejemplo directory.exe$make.

El ordenador Apple I también utilizaba esta función en cierta medida. Por ejemplo, un punto de entrada alternativo en BASIC del Apple I permitía que el programa siguiera funcionando si se pulsaba accidentalmente el botón de reinicio.

En APL , cuando se carga un espacio de trabajo, el contenido de la variable "quad LX" (expresión latente) se interpreta como una expresión APL y se ejecuta.

En C y C++ , el prototipo de la función principal debe ser equivalente a uno de los siguientes:

int main (); int main ( int argc , char * argv []);

Tenga en cuenta que puede expresarse de forma equivalente como y puede expresarse de forma equivalente como ; dentro de los parámetros de la función, estas firmas son idénticas para el compilador.intmain();intmain(void);intmain(intargc,char*argv[]);intmain(intargc,char**argv);

Antes de C89, C definía todas las funciones sin un tipo de retorno explícito como devueltas int; algunas funciones principales podían ser simplemente . Además, es una firma que se acepta en algunos compiladores, pero no forma parte oficialmente del lenguaje; en tales casos, el valor devuelto al entorno del host no está especificado. ^{[ 8 ]}main(){/* ... */}voidmain();

La función principal es servir de punto de entrada para programas de aplicación escritos en C o C++ estándar ISO. La programación de sistemas de bajo nivel (como la de un sistema embebido bare-metal ) podría especificar un punto de entrada diferente (por ejemplo, mediante un vector de interrupción de reinicio ) utilizando funcionalidades no definidas por el estándar del lenguaje.

Con tipos de retorno finales , main()también se puede expresar de forma equivalente como:

auto main () -> int ; auto main ( int argc , char * argv []) -> int ;

Si la firma es (sin y ) y se proporcionan argumentos de línea de comandos, el programa simplemente los ignorará.intmain()argcargv

Los parámetrosargc (para el número de argumentos ) y argv(para el vector de argumentos ) ^{[ 9 ]} dan respectivamente el número y los valores de los argumentos de la línea de comandos del programa . Los nombres de argcy argvpueden ser cualquier identificador válido, pero es convención común usar estos nombres. Los estándares C y C++ también permiten otros formatos dependientes de la plataforma, excepto que en C++ el tipo de retorno siempre debe ser int; ^{[ 10 ]} por ejemplo, Unix (aunque no POSIX.1 ) y Windows tienen un tercer argumento que da el entorno del programa , accesible de otra manera a través getenv()de en <stdlib.h>:

int main ( int argc , char * argv [], char * envp []);

Los sistemas operativos basados ​​en Darwin , como macOS , tienen un cuarto parámetro que contiene información arbitraria proporcionada por el sistema operativo, como la ruta al binario en ejecución: ^{[ 11 ]}

int main ( int argc , char * argv [], char * envp [], char * apple []);

El valor devuelto por la función principal se convierte en el estado de salida del proceso, aunque el estándar C solo atribuye un significado específico a dos valores: EXIT_SUCCESS(tradicionalmente 0) y EXIT_FAILURE. El significado de otros posibles valores de retorno depende de la implementación. Si el programador no define un valor de retorno, el compilador inserta un implícito al final de la función; este comportamiento es requerido por el estándar C++.return0;main()

Se garantiza que argces no negativo y que argv[argc]es un puntero nulo . Por convención, los argumentos de la línea de comandos especificados por argcy argvincluyen el nombre del programa como primer elemento si argces mayor que 0; si un usuario escribe un comando de " rm file", el shell inicializará el rmproceso con y . Como es el nombre con el que aparecen los procesos en , etc., algunos programas, como demonios o aquellos que se ejecutan dentro de un intérprete o máquina virtual (donde sería el nombre del ejecutable del host), pueden optar por modificar su para dar un más descriptivo , generalmente mediante la llamada al sistema.argc=2argv={"rm","file",NULL}argv[0]pstopargv[0]argvargv[0]exec

En GCC y Clang , es posible llamar (o incluso seleccionar una función diferente como punto de entrada) pasando el indicador del compilador y luego definiendo la función . Los argumentos de la línea de comandos se pueden recuperar usando ensamblador en línea .main()–nostartfiles_start()main()

#include <stdio.h> #include <stdlib.h>void _start () { int exitCode = Main (); exit ( exitCode ); }// tenga en cuenta que el nombre es Main(), no main() int Main () { printf ( "No hay función main() en este programa." ); return 0 ; }

Esta función es especial; normalmente, cada programa en C y C++ debe definirla exactamente una vez.main()

Si se declara, debe declararse como si tuviera un enlace externo; no puede declararse o .main()staticinline

En C++, debe estar en el espacio de nombres global (es decir, ), y no puede sobrecargarse. En C++ (a diferencia de C), no se puede llamar recursivamente ni se puede obtener su dirección. Si no está definido en el espacio de nombres global (por ejemplo, si solo está definido como una función miembro de una clase), el compilador no lo detectará. El nombre no está reservado de otra manera y puede usarse para funciones miembro, clases, enumeraciones o funciones que no son miembros en otros espacios de nombres.main()::mainmain()main()main()

importar std ;using std :: span ; using std :: string_view ; using std :: vector ;clase Main { public : static void main ( span <string_view> args ) { std :: println ( " Función main() al estilo Java con {} argumentos:" , args.size ( ) );for ( string_view arg : args ) { std :: println ( " {}" ); } } };int main ( int argc , char * argv []) { vector < string_view > args ( argv , argv + argc ); Main :: main ( args ); return 0 ; }

En 2017, se propuso una firma modernizada para , más similar a Java y C# (que en lugar de , estos lenguajes tienen , que acepta un array de cadenas). La firma sugerida era (ya que en ese momento, aún no formaba parte del lenguaje), sin embargo, esta propuesta fue rechazada. ^{[ 12 ]}main()main(int,char*[])main(String[])intmain(initializer_list<string_view>args)span<T>

main()puede que no sea una corrutina . ^{[ 13 ]}

A partir de C++26 , la función puede tener enlace; esto permite que las unidades de implementación del módulo prueben entidades internas. ^{[ 14 ]}main()extern"C++"

módulo wikipedia.ejemplos ;​​extern "C++" int main () { // ... }

Al ejecutar un programa escrito en C# , el CLR busca un método estático marcado con la .entrypointdirectiva IL, que no toma argumentos o toma un único argumento de tipo string[], y tiene un tipo de retorno de voido int, y lo ejecuta. ^{[ 15 ]}

static void Main (); static void Main ( string [] args ); static int Main (); static int Main ( string [] args );

Los argumentos de la línea de comandos se pasan de forma argssimilar a como se hace en Java. Para las versiones que Main()devuelven un entero, al igual que en C y C++, este se devuelve al entorno como el estado de salida del proceso.

Al igual que en Java, el punto de entrada de un programa normalmente reside en una clase con nombre, como por ejemplo:

espacio de nombres Wikipedia.Ejemplos ;usando el sistema ;public class HelloWorld { static void Main ( string [] args ) { Console . WriteLine ( "Hola, mundo!" ); } }

Desde C#7.1 existen cuatro firmas posibles más del punto de entrada, que permiten la ejecución asíncrona en el Main()método; estas utilizan la System.Threading.Tasks.Taskclase. ^{[ 16 ] [ 17 ]}

static async Task Main (); static async Task Main ( string [] args ); static async Task < int > Main (); static async Task < int > Main ( string [] args );

Los tipos Tasky Task<int>son los equivalentes asíncronos de voidy int(tenga en cuenta que Task<void>no es válido). asynces necesario para permitir el uso de llamadas asíncronas (la awaitpalabra clave) dentro del método.

espacio de nombres Wikipedia.Ejemplos ;using System ; using System.Threading.Tasks ;public class HelloWorld { static async Task < int > Main ( string [] args ) { Console . WriteLine ( "Hola..." ); await Task . Delay ( 1000 ); Console . WriteLine ( "...mundo!" ); return 0 ; } }

Clean es un lenguaje de programación funcional basado en la reescritura de grafos. El nodo inicial se nombra Starty es de tipo *World -> *Worldsi cambia el mundo o de algún tipo fijo si el programa solo imprime el resultado después de reducirloStart .

Inicio :: * Mundo -> * Mundo Inicio mundo = startIO ...

O incluso más sencillo.

Inicio :: Cadena Inicio = "¡Hola, mundo!"

Se le indica al compilador qué opción debe usar para generar el archivo ejecutable.

ANSI Common Lisp no define una función principal; en su lugar, el código se lee y evalúa de arriba abajo en un archivo fuente. Sin embargo, el siguiente código emulará una función principal.

( defun hello-main () ( format t "Hola Mundo!~%" ))( hola-principal )

En D , el prototipo de la función principal tiene una de las siguientes formas:

void main (); void main ( string [] args ); int main (); int main ( string [] args );

Los argumentos de la línea de comandos se pasan de forma argssimilar a como se hace en C# o Java. Para las versiones que main()devuelven un entero, al igual que en C y C++, este se devuelve al entorno como el estado de salida del proceso.

Dart es un lenguaje de programación de propósito general que se usa frecuentemente para crear aplicaciones web y móviles. Al igual que muchos otros lenguajes de programación, Dart tiene un punto de entrada que sirve como punto de partida para un programa Dart. El punto de entrada es la primera función que se ejecuta al iniciar un programa. En Dart, el punto de entrada suele ser una función llamada ` main.`. Cuando se ejecuta un programa Dart, el entorno de ejecución de Dart busca una función llamada ` main.` y la ejecuta. Cualquier código Dart que deba ejecutarse al iniciar el programa debe incluirse en la mainfunción `.`. Aquí hay un ejemplo de una función simple mainen Dart:

void main () { print ( "Hola, mundo!" ); }

En este ejemplo, la mainfunción simplemente imprime el texto Hello, world!en la consola cuando se ejecuta el programa. Este código se ejecutará automáticamente al iniciar el programa Dart.

Si bien la mainfunción es el punto de entrada predeterminado para un programa Dart, es posible especificar un punto de entrada diferente si es necesario. Esto se puede hacer mediante la @pragma("vm:entry-point")anotación en Dart. Sin embargo, en la mayoría de los casos, la mainfunción es el punto de entrada que se debe usar para los programas Dart.

FORTRAN no tiene una subrutina o función principal. En su lugar, PROGRAMse puede usar una instrucción como primera línea para especificar que una unidad de programa es un programa principal, como se muestra a continuación. Esta PROGRAMinstrucción no se puede usar para llamadas recursivas. ^{[ 18 ]}

PROGRAMA HOLA IMPRIMIR * , "¡Cint!" FIN DEL PROGRAMA HOLA

Algunas versiones de Fortran, como las del IBM System/360 y sus sucesores, no admiten la instrucción PROGRAM. Muchos compiladores de otros fabricantes de software permiten compilar un programa Fortran sin la instrucción PROGRAM. En estos casos, cualquier módulo que contenga una instrucción que no sea un comentario, donde no aparezca ninguna instrucción SUBROUTINE, FUNCTION o BLOCK DATA, se considera el programa principal.

Utilizando GNAT , el programador no necesita escribir una función con nombre main; un archivo fuente que contenga un único subprograma puede compilarse a un ejecutable. Sin embargo, el enlazador creará un paquete ada_mainque contendrá y exportará una función principal de estilo C.

En el lenguaje de programación Go , la ejecución del programa comienza con la mainfunción depackage main

paquete principalimportar "fmt"func main () { fmt.Println ( " ¡ Hola, mundo! " ) }

En Go, no hay forma de acceder a los argumentos o al código de retorno fuera de la biblioteca estándar. Se puede acceder a ellos mediante os.Argsy os.Exitrespectivamente, ambos incluidos en el "os"paquete.

Un programa Haskellmain debe contener un nombre vinculado a un valor de tipo IO t, para algún tipo t; ^{[ 19 ]} que suele ser IO (). IOes una mónada , que organiza los efectos secundarios en términos de código puramente funcional . ^{[ 20 ]} El mainvalor representa el cálculo con efectos secundarios realizado por el programa. El resultado del cálculo representado por mainse descarta; por eso mainsuele tener el tipo IO (), que indica que el tipo del resultado del cálculo es (), el tipo de unidad , que no contiene información.

main :: IO () main = putStrLn "¡Hola, mundo!"

Los argumentos de la línea de comandos no se proporcionan a main; deben obtenerse mediante otra acción de E/S, como System.Environment.getArgs.

Los programas Java comienzan a ejecutarse en el método principal de una clase, ^{[ 21 ] [ 22 ] [ 23 ] [ 24 ]} que tiene uno de los siguientes encabezados de método :

// clase con nombre public static void main (); public static void main ( String [] args ); public static void main ( String ... args );// clase sin nombre void main (); void main ( String [] args ); void main ( String ... args );

Tenga en cuenta que en Java, y son declaraciones idénticas; además, la forma variádica es idéntica ya que las variádicas se compilan a un tipo de matriz (la única diferencia es que está marcado como variádico en los metadatos de la clase ).voidmain(String[]args);voidmain(Stringargs[]);voidmain(String...args);voidmain(String...args)

Los argumentos de la línea de comandos se pasan en args. Al igual que en C y C++, el nombre " main()" es especial. Los métodos principales de Java no devuelven un valor directamente, pero se puede devolver un código de retorno directamente al sistema operativo llamando al System.exit()método, que finaliza el programa prematuramente (pero este código de retorno no proviene de main()).

A diferencia de C, el nombre del programa no se incluye en args, ya que es el nombre de la clase que contiene el método main, por lo que ya se conoce. Además, a diferencia de C, no es necesario incluir el número de argumentos, puesto que los arrays en Java tienen un campo que lleva la cuenta de cuántos elementos hay.

La función principal debe estar incluida dentro de una clase. Esto se debe a que en Java todo debe estar contenido dentro de una clase. Por ejemplo, un programa "hola mundo" en Java podría verse así:

paquete org.wikipedia.examples ;public class HelloWorld { public static void main ( String [] args ) { System . out . println ( "Hola, mundo!" ); } }

Para ejecutar este programa, debe llamarse java HelloWorlddesde el directorio donde se encuentra el archivo de clase compilado HelloWorld.class . Alternativamente, los archivos JAR ejecutables utilizan un archivo de manifiesto para especificar el punto de entrada de forma independiente del sistema de archivos desde la perspectiva del usuario.

Desde Java 25, es posible crear un "archivo fuente compacto" que declara implícitamente una finalclase en el paquete sin nombre. Esta clase extiende java.lang.Objecty no implementa ninguna interfaz, solo tiene un constructor predeterminado y tiene los campos y métodos declarados en el archivo fuente compacto. ^{[ 25 ]} Además, Java 25 mueve la clase java.io.IO(introducida por primera vez en Java 23) al paquete java.lang(importándola implícitamente en todos los archivos fuente), basándose en System.outy System.inen lugar de java.io.Console. Esto permite un programa "Hola Mundo" simplificado, quizás más similar a C y C++ donde mainreside en el espacio de nombres global:

void main () { IO.println ( " ¡ Hola, mundo!" ) ; }

En JavaScript y TypeScript , no existe una función "main", ya que el código se ejecuta tan pronto como se encuentra. Sin embargo, se puede emular de la siguiente manera:

// Versión no asíncrona: function main () : void { console . log ( "Hola mundo" ); }// Versión asíncrona: async function main () : Promise < void > { console . log ( "Hola mundo" ); }// En este patrón, solo una llamada a main() es de nivel superior. // Una buena idea puede ser llamar a main() y capturar cualquier error, // y luego registrarlos limpiamente de la siguiente manera: main ( ). catch (( err ) => { console.error ( err ) ; process.exit ( 1 ) ; });

Si se utiliza Node.js , es posible emular el patrón de estilo Python de :if__name__=="__main__":

función main ( ) : void { console.log ( " Ejecutándose como módulo principal" ); }if ( require.main === module ) { main ( ) ; }

En Julia, el punto de entrada (al menos para los scripts, véase más abajo para los programas compilados) es el propio archivo del programa que ejecutas, es decir, desde la primera línea, por lo que simplemente puedes hacer (o empezar con):

println ( "¡Hola, mundo! Llamado desde $PROGRAM_FILE con los siguientes argumentos:" ); for x in ARGS ; println ( x ); end

Desde la versión 1.11 de Julia también existe la posibilidad de definir una mainfunción que se llamará como punto de entrada, y puede tener, por ejemplo, este aspecto si se utiliza la @mainmacro asociada:

( @main )( ARGS ) = println ( "¡Hola mundo! Llamado desde main." )

Para garantizar la compatibilidad con versiones anteriores de Julia, como Julia 1.10 ( LTS ), la línea anterior puede funcionar con una línea adicional de la documentación, y el uso de este método puede ser útil ya que la nueva "característica está destinada a facilitar la unificación de los flujos de trabajo compilados e interactivos". ^{[ 26 ]} Otros métodos documentados en otros lugares ^{[ 27 ]} ya no son necesarios.

El método printlnanterior que muestra la forma antigua de un punto de entrada sin definir una mainfunción sigue siendo perfectamente válido para scripts (y ARGS está disponible en ambos casos, directamente desde una variable global; y PROGRAM_FILE en ambos casos). Tenga en cuenta que si hace ambos, los scripts seguirán ejecutando la primera línea como de costumbre, y a partir de ahí en adelante, por lo que esto también llamaría maine imprimiría dos veces. Pero ninguno es necesariamente el primer código que se ejecuta a menos que invoque Julia con --startup-file=noya que el archivo de inicio predeterminado de Julia se ejecuta antes que cualquier otra cosa (está vacío después de la instalación, pero se puede olvidar fácilmente, por ejemplo, al realizar pruebas de rendimiento, si lo ha agregado).

El estado de salida es 0 por defecto (si tiene éxito, lanzar un error lo cambia), y exit(my_exit_code)sale del programa con un estado distinto al predeterminado.

En Kotlin , la función principal suele estar en el nivel superior, como por ejemplo:

fun main () { println ( "Sin argumentos" ) }// Con argumentos: fun main ( args : Array < String > ) { println ( "Primer argumento: ${ args [ 0 ] } " ) }// estilo conciso: fun main ( args : Array < String > ) = println ( args . joinToString ())

En la máquina virtual Java , el código de bytes de la JVM lo representará como un staticmétodo de una clase, ya que la JVM no admite funciones de nivel superior. Por ejemplo, si el archivo se llama Main.kt :

public final class MainKt { public static void main ( String [] args ) { System . out . println ( "Primer argumento: " + args [ 0 ] ); } }

En FMSLogo , los procedimientos al cargarse no se ejecutan. Para que se ejecuten, es necesario usar este código:

al nombre del proceso ... ; Comandos de inicio (como imprimir [Bienvenido]) fin

hacer "startup [procname]

La variable startupse usa para la lista de acciones iniciales, pero por convención, esto llama a un procedimiento que ejecuta dichas acciones. Ese procedimiento puede tener cualquier nombre.

OCaml no tiene mainfunciones. Los programas se evalúan de arriba a abajo.

Los argumentos de la línea de comandos están disponibles en una matriz denominada Sys.argvy el estado de salida es 0 por defecto.

Ejemplo:

print_endline "Hola Mundo"

En Pascal , el procedimiento principal es el único bloque sin nombre en el programa. Debido a que los programas Pascal definen los procedimientos y funciones en un orden ascendente más riguroso que los programas C, C++ o Java, el procedimiento principal suele ser el último bloque del programa. Pascal no tiene un significado especial para el nombre " main" ni ningún nombre similar.

programa Hola ( Salida ) ; inicio escribir ( '¡Hola, mundo!' ) ; fin .

Los argumentos de la línea de comandos se cuentan ParamCounty se acceden como cadenas mediante ParamStr(n), con n entre 0 y ParamCount.

Las versiones de Pascal que admiten unidades o módulos también pueden contener un bloque sin nombre en cada uno, que se utiliza para inicializar el módulo. Estos bloques se ejecutan antes de que se llame al punto de entrada del programa principal.

En Perl , no existe una función principal. Las instrucciones se ejecutan de arriba abajo, aunque las instrucciones dentro de un BEGINbloque se ejecutan antes que las instrucciones normales.

Los argumentos de la línea de comandos están disponibles en la matriz especial @ARGV. A diferencia de C, @ARGVno contiene el nombre del programa, que es $0.

PHP no tiene una función "main". A partir de la primera línea de un script PHP, cualquier código que no esté encapsulado por una cabecera de función se ejecuta en cuanto se encuentra.

En Pike la sintaxis es similar a la de C y C++. La ejecución comienza en main. La argcvariable " " mantiene el número de argumentos pasados ​​al programa. La argvvariable " " contiene el valor asociado con los argumentos pasados ​​al programa.

Ejemplo:

int main ( int argc , array ( string ) argv )

Los programas de Python se evalúan de arriba abajo, como es habitual en los lenguajes de scripting: el punto de entrada es el inicio del código fuente. Dado que las definiciones deben preceder al uso, los programas suelen estructurarse con las definiciones al principio y el código a ejecutar al final (sin sangría), de forma similar al código de un compilador de una sola pasada , como en Pascal.

Alternativamente, un programa puede estructurarse con una mainfunción explícita que contenga el código que se ejecutará cuando se ejecute directamente, pero que también puede invocarse importando el programa como un módulo y llamando a la función. Esto se puede hacer mediante el siguiente modismo, que se basa en que la variable interna __name__se establezca __main__cuando se ejecuta un programa, pero no cuando se importa como un módulo (en cuyo caso se establece con el nombre del módulo); existen muchas variantes de esta estructura: ^{[ 28 ] [ 29 ] [ 30 ]}

importar sysdef main ( argv : list [ str ]) -> int : argc : int = len ( argv ) # obtener la longitud de argv n : int = int ( argv [ 1 ]) print ( n + 1 ) return 0if __name__ == "__main__" : sys . exit ( main ( sys . argv ))

En este estilo, la llamada al punto de entrada especificado maines explícita, y la interacción con el sistema operativo (recepción de argumentos, llamada a la función de salida del sistema) se realiza explícitamente mediante llamadas a la biblioteca, que en última instancia son gestionadas por el entorno de ejecución de Python. Esto contrasta con C, donde estas interacciones se realizan implícitamente por el entorno de ejecución, según una convención.

El lenguaje QB64 no tiene función principal; el código que no está dentro de una función o subrutina se ejecuta primero, de arriba a abajo:

print "Hola Mundo! a =" ; a = getInteger ( 1.8 d ): print a

función getInteger ( n como doble ) getInteger = int ( n ) fin de la función

Los argumentos de la línea de comandos (si los hay) se pueden leer utilizando la función COMMAND$ :

dim shared commandline as string commandline = COMMAND$

'Se pueden leer varios argumentos de línea de comandos separados por espacios usando COMMAND$(n) commandline1 = COMMAND$ ( 2 )

En Ruby , no existe una función principal distinta. En cambio, el código escrito fuera de cualquier class .. endámbito module .. endse ejecuta en el contexto de un objeto especial " main". Se puede acceder a este objeto usando self:

irb(main):001:0> self => main

Tiene las siguientes propiedades:

irb(main):002:0> self . class => Object irb(main):003:0> self . class . ancestors => [Object, Kernel, BasicObject]

Los métodos definidos fuera de un classámbito modulese definen como métodos privados del mainobjeto " ". Dado que la clase de " main" es Object, dichos métodos se convierten en métodos privados de casi todos los objetos:

irb(main):004:0> def foo irb(main):005:1> 42 irb(main):006:1> end => nil irb(main):007:0> foo => 42 irb(main):008:0> []. foo NoMethodError: método privado `foo' llamado para []:Array  desde (irb):8  desde /usr/bin/irb:12:in `<main>' irb(main):009:0> false . foo NoMethodError: método privado `foo' llamado para false:FalseClass  desde (irb):9  desde /usr/bin/irb:12:in `<main>'

El número y los valores de los argumentos de la línea de comandos se pueden determinar utilizando la ARGVmatriz constante:

$ irb /dev/tty foo bar tty(main):001:0> ARGV ARGV => ["foo", "bar"] tty(main):002:0> ARGV.size ARGV.size => 2

El primer elemento de ARGV, ARGV[0], contiene el primer argumento de la línea de comandos, no el nombre del programa ejecutado, como en C. El nombre del programa está disponible usando $0o $PROGRAM_NAME. ^{[ 31 ]}

De forma similar a Python, se podría usar:

if __FILE__ == $PROGRAM_NAME # Coloca aquí el código "main" end

ejecutar cierto código solo si su archivo fue especificado en la rubyinvocación.

En Rust, el punto de entrada de un programa es una función llamada main. Por convención, esta función se encuentra en un archivo llamado main.rs.

// En main.rs fn main () { println! ( "Hola, mundo!" ); }

main()puede devolver cualquier tipo que implemente el rasgo std::process::Termination. ^{[ 32 ]} Internamente en el entorno de ejecución de Rust, estos devolverán libc::EXIT_SUCCESSen caso de ejecución exitosa y libc::EXIT_FAILUREen caso de fallo.

usar std :: io ;fn main () -> Result < (), io :: Error > { println! ( "Hola, mundo!" );Ok (()) // Devuelve un resultado de tipo Ok con el contenido (), el tipo de unidad. }

En la biblioteca estándar de Rust, los siguientes tipos tienen implementaciones para std::process::Termination:

• !(el tipo nunca )
• ()(el tipo de unidad )
• std::convert::Infalliable
• std::process::ExitCode(con constantes SUCCESSy FAIL)
• std::result::Result<T, E>

Rust no tiene parámetros en la main()función como C++ y Java u otros lenguajes de estilo C. En cambio, accede a los argumentos de la línea de comandos usando std::env::args(), que devuelve std::env::Argsy luego se puede convertir a Vec<String>usando collect().

use std :: env ::{ self , Args }; use std :: io ;fn main () -> Result < (), io :: Error > { let args : Args = env :: args (); // obtener los argumentos de la línea de comandos let args_vec : Vec < String > = args . collect (); // recopilar los argumentos en un Vec<String>for arg in args_vec { println! ( "{}" , arg ); }De acuerdo (()) }

Cuando se ejecuta en un Xcode Playground, ^{[ 33 ]} Swift se comporta como un lenguaje de scripting, ejecutando instrucciones de arriba a abajo; se permite el código de nivel superior.

// HelloWorld.playgroundlet hola = "hola" let mundo = "mundo"let helloWorld = hello + " " + worldimprimir ( holaMundo ) // hola mundo

Las aplicaciones basadas en Cocoa y Cocoa Touch escritas en Swift se inicializan normalmente con los atributos @NSApplicationMainy @UIApplicationMain, respectivamente. Estos atributos son equivalentes en su propósito al main.marchivo en proyectos Objective-C : declaran implícitamente la mainfunción que llama a UIApplicationMain(_:_:_:_:)^{[ 34 ]} que crea una instancia de UIApplication. ^{[ 35 ]}

El siguiente código es la forma predeterminada de inicializar una aplicación iOS basada en Cocoa Touch y declarar su delegado de aplicación.

// AppDelegate.swiftimportar UIKit@UIApplicationMain class AppDelegate : UIResponder , UIApplicationDelegate { var window : UIWindow ? func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ]?) -> Bool { return true } }

En Visual Basic , cuando un proyecto no contiene formularios, el objeto de inicio puede ser el Main()procedimiento. La Command$función se puede usar opcionalmente para acceder a la parte de los argumentos de la línea de comandos utilizada para ejecutar el programa:

Sub Main () Debug . Print "Hola Mundo!" MsgBox "Argumentos, si los hay: " & Command $ End Sub

En Xojo , existen dos tipos de proyectos distintos, cada uno con un punto de entrada principal diferente. Las aplicaciones de escritorio (GUI) se inician con el App.Openevento del Applicationobjeto del proyecto. Las aplicaciones de consola se inician con el App.Runevento del ConsoleApplicationobjeto del proyecto. En ambos casos, la función principal se genera automáticamente y no se puede eliminar del proyecto.