HolaMundo en varios lenguajes de programación

En este documento se indican los pasos que deberemos seguir para ejecutar código en distintos lenguajes de programación.

En el caso de lenguajes interpretados se indica también la forma de generar un script ejecutable.

El código fuente para distintos lenguajes de programación está disponible en:

• https://es.wikipedia.org/wiki/Anexo:Ejemplos_de_implementaci%C3%B3n_del_%C2%ABHola_mundo%C2%BB

Debemos instalar los siguientes paquetes:

apt  install  python  php  nodejs  gcc  g++  default-jdk  default-jre  nasm  ruby  golang  rustc  clisp

Plataforma usada: Ubuntu 16.04 LTS.

1. Ejecutamos el intérprete.
   Este paso no es necesario aquí, puesto que ya estamos en el terminal.

2. Escribimos las sentencias y luego pulsamos INTRO.

echo "Hola Mundo"

3. Para salir del intérprete pulsamos CTRL+D.
   No pulsar esta combinación si no queremos cerrar el terminal.

1. Editamos archivo hola.sh

#!/usr/bin/env bash

echo "Hola mundo"

2. Damos permisos de ejecución

chmod  +x  hola.sh

3. Ejecutamos

./hola.sh

1. Ejecutamos el intérprete.

python

2. Escribimos las sentencias y luego pulsamos INTRO.

print "Hola Mundo"

3. Para salir del intérprete pulsamos CTRL+D.

1. Editamos archivo hola.py

#!/usr/bin/env python

print "Hola mundo"

2. Damos permisos de ejecución

chmod  +x  hola.py

3. Ejecutamos

./hola.py

1. Ejecutamos el intérprete.

php

2. Escribimos las sentencias.

<?php 
  echo "Hola mundo\n" 
?>

3. Para salir del intérprete pulsamos CTRL+D. Después veremos el resultado de la ejecución.

1. Editamos archivo hola.php

#!/usr/bin/env php

<?php 
  echo "Hola mundo\n" 
?>

2. Damos permisos de ejecución

chmod  +x  hola.php

3. Ejecutamos

./hola.php

1. Ejecutamos el intérprete.

node

2. Escribimos las sentencias y luego pulsamos INTRO.

console.log('Hola mundo');

3. Para salir del intérprete pulsamos CTRL+D.

1. Editamos archivo hola.js

#!/usr/bin/env node

console.log('Hola mundo');

2. Damos permisos de ejecución

chmod  +x  hola.js

3. Ejecutamos

./hola.js

1. Editamos archivo hola.c

#include <stdio.h>

int main()
{
    printf("¡Hola, mundo!");
    return 0;
}

2. Compilamos y enlazamos

gcc  -o  hola  hola.c      # Compilamos y enlazamos

3. Ejecutamos

./hola                     # Ejecutamos

1. Editamos archivo hola.cpp

#include <iostream>

using namespace std;

int main()
{
   cout << "¡Hola, mundo!" << endl;
   return 0;
}

2. Compilamos y enlazamos

g++  -o  hola  hola.cpp    # Compilamos y enlazamos

3. Ejecutamos

./hola                     # Ejecutamos

1. Editamos archivo Hola.java

class Hola
{
    public static void main(String[] args)
    {
        System.out.println("Hola Mundo");
    }
}

2. Compilamos

javac  Hola.java      # Compilamos

3. Interpretamos y ejecutamos

java  Hola            # Interpretamos y ejecutamos

Realmente no es un script, sino bytecode empaquetado en JAR e interpretado por la JVM (Java Virtual Machine).

1. Empaquetamos

jar  cvfe  hola.jar  Hola  Hola.class  # Empaquetamos  

NOTA: Las opciones utilizadas en el comando jar son:

c: Create      (Crear archivo jar)
v: Verbose     (Mostrar información)
f: File        (Nombre de archivo jar, en este caso hola.jar)
e: Entry point (Punto de entrada, en este caso la clase Hola)
 
Como último parámetro indicamos el bytecode a incluir, en este caso Hola.class.

2. Damos permiso de ejecución

chmod  +x  hola.jar                    # Damos permiso de ejecución

3. Ejecutamos

./hola.jar                             # Ejecutamos

NOTA: La forma tradicional de ejecutar un archivo jar es invocando al intéprete java:

java  -jar   hola.jar

NOTA: Los pasos 2 y 3 no funcionan en todas las distribuiciones de Linux. Parece ser algo relacionado con la asociación de la aplicación al tipo de archivo. Si tienes problemas para ejecutar el archivo .jar de forma directa, quizás no tienes asociada ninguna aplicación a dicho tipo de archivo.

Comprueba que tienes el archivo /usr/share/applications/openjdk-8-java.desktop con el siguiente contenido:

[Desktop Entry]
Name=OpenJDK Java 8 Runtime
Name[fi]=OpenJDK Java 8 - ajonaikainen ympäristö
Comment=OpenJDK Java 8 Runtime
Comment[fi]=OpenJDK Java 8 - ajonaikainen ympäristö
Keywords=java;runtime
Exec=cautious-launcher %f /usr/bin/java -jar
Terminal=false
Type=Application
Icon=openjdk-8
MimeType=application/x-java-archive;application/java-archive;application/x-jar;
NoDisplay=true

Si tienes otra versión de Java, debes modificar el nombre del archivo y su contenido para reflejar tal situación.

1. Editamos archivo hola.asm

 section .data
 
 msg     db "¡Hola Mundo!", 0Ah
 len     equ     $ - msg  
 
 section .text
 
 global _start
 
 _start:
        mov     eax, 04h
        mov     ebx, 01h
        mov     ecx, msg
        mov     edx, len
        int     80h
        mov     eax, 01h
        mov     ebx, 00h
        int     80h

2. Ensamblamos y enlazamos

nasm  -f  elf64  hola.asm        # Ensamblado para ELF64
ld  hola.o  -o  hola             # Enlazado y generación de ejecutable

3. Ejecutamos

./hola                           # Ejecución

1. Ejecutamos el intérprete.

ruby

2. Escribimos las sentencias y luego pulsamos INTRO.

puts "Hola Mundo"

3. Para salir del intérprete pulsamos CTRL+D.

1. Editamos archivo hola.rb

#!/usr/bin/env ruby

puts "Hola Mundo"

2. Damos permisos de ejecución

chmod  +x  hola.rb

3. Ejecutamos

./hola.rb

1. Editamos archivo hola.go

package main

import "fmt"

func main() {
        fmt.Println("Hola mundo desde Go")
}

2. Compilamos y enlazamos

go  build  hola.go   # Compilamos y enlazamos

3. Ejecutamos

./ hola              # Ejecutamos

4. Si lo deseamos,en Go también es posible interpretar el código

go  run  hola.go     # Interpretamos y ejecutamos

1. Editamos archivo hola.rs

fn main() {
    println!("¡Hola, mundo! Desde RUST ");
}

2. Compilamos y enlazamos

rustc  hola.rs              # Compilamos y enlazamos

3. Ejecutamos

./hola                      # Ejecutamos

1. Ejecutamos el intérprete.

clisp

2. Escribimos las sentencias y luego pulsamos INTRO.

(format t "¡Hola, mundo!")

3. Para salir del intérprete pulsamos CTRL+D.

1. Editamos archivo hola.lisp

#!/usr/bin/env clisp

(format t "¡Hola, mundo!")

2. Damos permisos de ejecución

chmod  +x  hola.lisp

3. Ejecutamos

./hola.lisp

Otros lenguajes menos comunes, pero de interés por diversos motivos, se tratan en los siguientes enlaces:

• Groovy
• Scala
• Kotlin
• Haskell
• Prolog