Liste von Hallo-Welt-Programmen/Höhere Programmiersprachen

Wikimedia-Liste

Dies ist eine Liste von Hallo-Welt-Programmen für gebräuchliche höhere Programmiersprachen. Für jede Sprache wird vorgeführt, wie man in ihr die einfache Aufgabe löst, den Text „Hallo Welt!“ auf den Bildschirm auszugeben. Weitere Beispiele für grafische Benutzeroberflächen, Web-Technologien, exotische Programmiersprachen und Textauszeichnungssprachen sind unter Liste von Hallo-Welt-Programmen/Sonstige aufgeführt; Beispiele in Assembler für verschiedene Plattformen finden sich unter Liste von Hallo-Welt-Programmen/Assembler. Das kürzeste Hallo-Welt-Programm liefert die Programmiersprache APL, das zweitkürzeste Forth. Beide kommen dabei ohne Funktions- oder Schlüsselwort aus.

ABAPBearbeiten

REPORT Z_HALLO_WELT.
WRITE 'Hallo Welt!'.

ActionScriptBearbeiten

trace('Hallo Welt');

ActionScript 3.0 und unter Benutzung der DocumentClass:

package {
    import flash.display.Sprite;

    public class Main extends Sprite {
        public function Main() {
            trace( "Hallo Welt!" );
        }
    }
}

AdaBearbeiten

with Ada.Text_IO;
procedure Hallo is
begin
    Ada.Text_IO.Put_Line ("Hallo Welt!");
end Hallo;

Für eine Erklärung des Programms siehe Ada Programming/Basic in den englischsprachigen Wikibooks.

Algol 60Bearbeiten

 'BEGIN'
     OUTSTRING(2,'('HALLO WELT')');
 'END'

Anmerkung: Bei der Sprachdefinition von ALGOL 60 wurden die Ein-/Ausgabeanweisungen ausdrücklich von der Standardisierung ausgenommen, so dass deren Implementierungen stark zwischen den Compilern variieren. So wird dieser Text bei der Electrologica X1 (nach vorheriger Wahl des Ausgabekanals mit SELECTOUTPUT(2); ) mit WRITETEXT('('HALLO WELT')'); statt mit dem OUTSTRING-Befehl ausgegeben.

Algol 68Bearbeiten

 ( print("Hallo Welt!") )

AMOS BASICBearbeiten

? "Hallo Welt!"

APLBearbeiten

'Hallo Welt!'

AppleScriptBearbeiten

display dialog "Hallo Welt!"

ASP (Active Server Pages)Bearbeiten

<%
  Response.Write("Hallo Welt!")
%>

oder verkürzt

<%="Hallo Welt!"%>

AutoHotkeyBearbeiten

Variante 1: eine klassische MessageBox

MsgBox Hallo Welt!

Variante 2: Startet das Programm Notepad und tippt dort „Hallo Welt“ ein

Run, "notepad.exe"
WinWaitActive, ahk_class Notepad
Send, Hallo Welt{!}

AutoItBearbeiten

Variante 1: Startet eine normale Messagebox ohne Titel

MsgBox(0, "", "Hallo Welt!")

Variante 2: Startet den Editor, wartet bis dieser aktiv ist, hält das Fenster während der Ausführung des Send-Befehls aktiv und schreibt Hallo Welt! hinein.

Run("notepad.exe")
WinWaitActive("[CLASS:Notepad]")
SendKeepActive("[CLASS:Notepad]")
Send("Hallo Welt!",1)

AutoLISPBearbeiten

(princ "Hallo Welt!")

awkBearbeiten

BEGIN { print "Hallo Welt!" }

BBearbeiten

main() {
    printf("Hallo Welt!");
}

BASICBearbeiten

Traditionelles, unstrukturiertes BASIC:

10 PRINT "Hallo Welt!"

bzw. im Direktmodus:

?"Hallo Welt!"

BatchBearbeiten

Die Kommandozeilenbefehlssprache von MS-DOS, PC DOS, DR-DOS und Windows NT.

@echo Hallo Welt!

BeanShellBearbeiten

print("Hallo Welt!");

Blitz BasicBearbeiten

Ohne GUI:

Print "Hallo Welt"
WaitKey
End

Mit GUI (BlitzPlus)

window = CreateWindow("Hallo Welt! Fenster", 0, 0, 100, 80, 0, 1)
label = CreateLabel("Hallo Welt!", 5, 5, 80, 20, window)
Repeat
Until WaitEvent() = $803

BlitzMaxBearbeiten

Framework BRL.StandardIO
Print("Hallo Welt!")

BooBearbeiten

print "Hallo Welt!"

CBearbeiten

#include <stdio.h>

int main() {
    puts("Hallo Welt!");
    return 0;
}

C unter Benutzung der POSIX-APIBearbeiten

#include <unistd.h>

const char HALLOWELT[] = "Hallo Welt!\n";

int main(void)
{
    write(STDOUT_FILENO, HALLOWELT, sizeof HALLOWELT - 1);
    return 0;
}

C mit GTKBearbeiten

#include <gtk/gtk.h>

gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    return FALSE;
}

void destroy(GtkWidget *widget, gpointer data)
{
    gtk_main_quit();
}

void clicked(GtkWidget *widget, gpointer data)
{
    g_print("Hallo Welt!\n");
}

int main (int argc, char *argv[])
{
    gtk_init(&argc, &argv);
    GtkWidget *window;
    GtkWidget *button;
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width(GTK_CONTAINER(window), 10);
    g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_event), NULL);
    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
    button = gtk_button_new_with_label("Hallo Welt!");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clicked), NULL);
    gtk_widget_show(button);
    gtk_container_add(GTK_CONTAINER(window), button);
    gtk_widget_show(window);
    gtk_main();
}

C mit Windows APIBearbeiten

#include <windows.h>

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MessageBox(0, "Hallo Welt!", "Mein erstes Programm", MB_OK);
    return 0;
}

C++Bearbeiten

#include <iostream>

int main()
{
    std::cout << "Hallo Welt!" << std::endl;
}

C++/CLIBearbeiten

int main()
{
    System::Console::WriteLine("Hallo Welt!");
}

C++/CXBearbeiten

#include "stdafx.h"
#using <Platform.winmd>
using namespace Platform;

[MTAThread]
int main(Array<String^>^ args)
{
    String^ message("Hallo Welt!");
    Details::Console::WriteLine(message);
}

C++ mit gtkmmBearbeiten

#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>

int main (int argc, char* argv[])
{
    Gtk::Main m_main(argc, argv);
    Gtk::Window m_window;
    Gtk::Button m_button("Hallo Welt!");
    m_window.add(m_button);
    m_button.show();
    Gtk::Main::run(m_window);
}

C++ mit QtBearbeiten

#include <QLabel>
#include <QApplication>

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QLabel label("Hallo Welt!");
    label.show();
    app.exec();
}

C#Bearbeiten

class MainClass
{
    public static void Main()
    {
        System.Console.WriteLine("Hallo Welt!");
    }
}

oder als Nachrichtenbox

static class Program
{
    static void Main()
    {
        System.Windows.Forms.MessageBox.Show("Hallo Welt");
    }
}

vereinfachte Schreibweise ab C# 9:

System.Console.Write("Hallo, Welt!");

C/ALBearbeiten

MESSAGE('Hallo Welt')

CeylonBearbeiten

// In der Datei module.ceylon
module hello "1.0.0" {}

// In der Datei hallo.ceylon
shared void run() {
    print("Hallo Welt!");
}

CILBearbeiten

.assembly HalloWelt { }
.assembly extern mscorlib { }
.method public static void Main() cil managed
{
    .entrypoint
    .maxstack 1
    ldstr "Hallo Welt!"
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}

CLISTBearbeiten

WRITE HALLO WELT

ClojureBearbeiten

(println "Hallo Welt!")

CLPBearbeiten

PGM
SNDPGMMSG MSG('Hallo Welt!') MSGTYPE(*COMP)
ENDPGM

COBOLBearbeiten

000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID. HELLOWORLD.
000900 PROCEDURE DIVISION.
001000 MAIN.
001100 DISPLAY "Hallo Welt!".
001200 STOP RUN.

COLDFUSIONBearbeiten

<cfset beispiel = "Hallo Welt!" >
<cfoutput>#beispiel#</cfoutput>

COMALBearbeiten

10 PRINT "Hallo Welt!"

Common LispBearbeiten

(write-line "Hallo Welt!")

Component PascalBearbeiten

MODULE HalloWelt;
IMPORT Out;
PROCEDURE Output*;
BEGIN
   Out.String ("Hallo Welt!");
   Out.Ln;
END Output;
END HalloWelt.

DBearbeiten

import std.stdio;
void main() {
    writeln("Hallo Welt!");
}

DarkBASICBearbeiten

print "Hallo Welt!"
wait key

dBASE/Foxpro//ClipperBearbeiten

Ausgabe in der nächsten freien Zeile:

? "Hallo Welt!"

Zeilen- und spaltengenaue Ausgabe:

@1,1 say "Hallo Welt!"

Ausgabe in einem Fenster:

wait window "Hallo Welt!"

DylanBearbeiten

define method hallo-welt()
     format-out("Hallo Welt!\n");
end method hallo-welt;

hallo-welt();

EiffelBearbeiten

class HALLO_WELT
create
    make
feature
    make is
    do
        io.put_string("Hallo Welt!%N")
    end
end

ELANBearbeiten

putline ("Hallo Welt!");

ElixirBearbeiten

IO.puts "Hello World"

oder:

defmodule HelloWorld do
    def hello() do
        IO.puts "Hello World!"
    end
end

Emacs Lisp (Elisp)Bearbeiten

(print "Hallo Welt!")

;; Ausgabe auf verschiedenen Wegen:
(print "Hallo Welt!" t)      ; Ausgabe im Minibuffer (Meldungsbereich), Voreinstellung
                             ; (also das gleiche wie der erste Aufruf)
(message "Hallo, Welt!")     ; auch das gleiche wie der erste Aufruf


(print "Hallo Welt!" BUFFER) ; Einfügen in BUFFER bei "point" (= aktuelle Cursorposition)
                             ; Ein "buffer" ist normalerweise eine zum Bearbeiten geöffnete
                             ; (oft noch nicht gespeicherte) Datei.
(print "Hallo Welt!"         ; Einfügen in ...
    (current-buffer))        ; ... den aktuellen "buffer", bei "point"
(insert "Hallo Welt!")       ; das gleiche


(print "Hallo Welt!" MARKER) ; Einfügen in den aktuellen "buffer" bei MARKER
                             ; (ein Marker ist eine vom Benutzer gespeicherte Position)

(print ...) akzeptiert noch exotischere Möglichkeiten als BUFFER oder MARKER, die aber zu weit weg von einer simplen Ausgabe führen und deshalb hier nicht aufgeführt werden.

Keine der oben aufgeführten Möglichkeiten schreibt auf STDOUT oder STDERR, weil Elisp innerhalb von Emacs ausgeführt wird, der im typischen Einsatz kein befehlszeilenorientiertes Programm, sondern nach innen orientiert ist. Die am Anfang aufgeführten Varianten, die normalerweise in den Minibuffer schreiben, schreiben aber stattdessen auf STDERR, wenn man Emacs nicht-interaktiv (Option --batch) auf der Befehlszeile startet:

> emacs -Q --batch --eval='(print "Hallo, Welt!")'
Hallo, Welt!
> emacs -Q --batch --eval='(print "Hallo, Welt!" t)'
Hallo, Welt!
> emacs -Q --batch --eval='(message "Hallo, Welt!")'
Hallo, Welt!

Die Möglichkeit, auf STDOUT auszugeben, gibt es wohl nicht.

ErlangBearbeiten

-module(hallo).
-export([hallo_welt/0]).

hallo_welt() -> io:fwrite("Hallo Welt!\n").

F#Bearbeiten

printfn "Hallo Welt"

ForthBearbeiten

Als Wort:

: hallo-welt
." Hallo, Welt!" cr
;

bzw. im Direktmodus:

.( Hallo, Welt!) cr

FortranBearbeiten

program hallo
write(*,*) "Hallo Welt!"
end program hallo

FortressBearbeiten

component HalloWelt
  export Executable
  run(args:String) = print "Hallo Welt!"
end

FreeBASICBearbeiten

print "Hallo Welt!"
sleep

GMLBearbeiten

show_message("Hallo Welt!");

oder:

draw_text(x,y,"Hallo Welt!");

GambasBearbeiten

    PUBLIC SUB Form_Enter()
    PRINT "Hallo Welt!"
    END

GoBearbeiten

package main

import "fmt"

func main() {
	fmt.Println("Hallo Welt!")
}

GroovyBearbeiten

println "Hallo Welt!"

HaskellBearbeiten

main :: IO ()
main = putStrLn "Hallo Welt!"

HaxeBearbeiten

class Test {
    static function main() {
        trace("Hallo Welt!");
    }
}

Die daraus kompilierten SWF- oder Neko-Bytecodes sind allein lauffähig. Zur Verwendung von kompiliertem JavaScript zusätzlich nötig:

<html><body>
<div id=“haxe:trace“></div>
<script type=“text/javascript“ src=“hallo_welt_haxe.js“></script>
</body></html>

IDL (RSI)Bearbeiten

PRO hallo_welt
    PRINT, "Hallo Welt!"
END

IoBearbeiten

"Hallo Welt!" print

J#Bearbeiten

public class HalloWelt
{
    public static void main(String[] args)
    {
        System.Console.WriteLine("Hallo Welt!");
    }
}

JavaScriptBearbeiten

Im BrowserBearbeiten

document.write("Hallo Welt!");

Mit Node.jsBearbeiten

console.log("Hallo Welt!");

JavaBearbeiten

class Hallo {
  public static void main( String[] args ) {
    System.out.print("Hallo Welt!");
  }
}

oder als Dialogfenster:

import javax.swing.*;
class Hallo {
  public static void main( String[] args ) {
    JOptionPane.showMessageDialog( null, "Hallo Welt!" );
  }
}

Java-AppletBearbeiten

Java-Applets funktionieren in Verbindung mit HTML.

Die Java-Datei:

import java.applet.*;
import java.awt.*;

public class HalloWelt extends Applet {
  public void paint(Graphics g) {
    g.drawString("Hallo Welt!", 100, 50);
  }
}

Nachfolgend der Code zum Einbau in eine HTML-Seite. Vom W3C empfohlen:

<object classid="java:HalloWelt.class"
        codetype="application/java-vm"
        width="600" height="100">
</object>

Für Kompatibilität zu sehr alten Browsern (nicht empfohlen):

<applet code="HalloWelt.class"
        width="600" height="100">
</applet>

Java-JDBCBearbeiten

JDBC Programme arbeiten in Verbindung mit einer Datenbank, für die der Hersteller einen geeigneten Datenbanktreiber bereitstellen muss.

Die Java-Datei:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Main
{
	private static final String URL = "jdbc:mysql://localhost/TEST?useSSL=false";
	private static final String USER = "root";
	private static final String PASSWORD = "password";
		//
	private static final String SQL = "SELECT 'Hello, World!' ";

	public static void main( String[] args ) throws SQLException {
		Connection conn = DriverManager.getConnection( URL, USER, PASSWORD );
		Statement st = conn.createStatement();
		ResultSet rs = st.executeQuery( SQL );

		while ( rs.next() ) {
			System.out.println( rs.getString( 1 ) );
		}
	}
}

Das Beispiel benutzt eine MySQL Datenbank namens TEST auf dem aktuellen Rechner (localhost). Es muss ein Benutzer namens "root" mit dem Passwort "password" angelegt sein. Es wird ein Datenbanktreiber namens com.mysql.jdbc.Driver verwendet, der in dem Archiv mysql-connector-java-5.1.38-bin.jar vorhanden ist. Das Archiv kann von dev.mysql.com heruntergeladen werden. Bei der Ausführung des Programmes gibt man die Archivdatei im Classpath an.

JuliaBearbeiten

println("Hallo Welt!")

KiXtartBearbeiten

? "Hallo Welt!"

KotlinBearbeiten

fun main() {
    println("Hallo Welt!")
}

LispBearbeiten

(print "Hallo Welt!")

oder

(princ "Hallo Welt!")
(terpri)

Mit terpri erfolgt Zeilenumbruch.

Bearbeiten

print [Hallo Welt!]

LuaBearbeiten

print ("Hallo Welt!")

Hierbei können die Klammern um den String allerdings weggelassen werden:

print "Hallo Welt!"

MatlabBearbeiten

fprintf('Hallo Welt!');

oder

disp('Hallo Welt!');

oder

disp Hallo_Welt

oder

'Hallo Welt'

mIRC ScriptBearbeiten

on 1:load:*: { echo Hallo Welt! }

MS-DOS BatchBearbeiten

echo Hallo Welt!

OberonBearbeiten

MODULE HalloWelt;
IMPORT Write;
BEGIN
    Write.Line("Hallo Welt!");
END HalloWelt.

Object PascalBearbeiten

CLI:

begin
  write('Hallo Welt!');
end.

GUI:

    {$APPTYPE GUI}
    uses Dialogs;
     begin
      ShowMessage('Hallo Welt!');
    end.

OCamlBearbeiten

print_endline "Hallo Welt!";;

Objective-CBearbeiten

#import <stdio.h>
int main()
{
  puts("Hallo Welt!");
  return 0;
}

Oder mit Hilfe des Foundation-Frameworks (und in neuer typischer Schreibweise):

#import <Foundation/Foundation.h>
int main() {
 NSLog(@"Hallo Welt!");
 return 0;
}

Objective-C mit CocoaBearbeiten

#import <Cocoa/Cocoa.h>
@interface Controller : NSObject
{
 NSWindow *window;
 NSTextField *textField;
}
@end
int main(int argc, const char *argv[])
{
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 NSApp = [NSApplication sharedApplication];
 Controller *controller = [[Controller alloc] init];
 [NSApp run];
 [controller release];
 [NSApp release];
 [pool release];
 return EXIT_SUCCESS;
}
@implementation Controller
- (id)init
{
 if ((self = [super init]) != nil) {
                textField = [[NSTextField alloc] initWithFrame:NSMakeRect(10.0, 10.0, 85.0, 20.0)];
                [textField setEditable:NO];
                [textField setStringValue:@"Hallo Welt!"];

                window = [[NSWindow alloc] initWithContentRect:NSMakeRect(100.0, 350.0, 200.0, 40.0)
                                                                                         styleMask:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask
                                                                                           backing:NSBackingStoreBuffered
                                                                                                 defer:YES];
                [window setDelegate:self];
                [window setTitle:@"Hallo Welt!"];
                [[window contentView] addSubview:textField];
                [window makeKeyAndOrderFront:nil];
 }

 return self;
}
- (void)windowWillClose:(NSNotification *)notification
{
 [NSApp terminate:self];
}

@end

OpenLaszloBearbeiten

<canvas>
   <text>Hallo Welt!</text>
</canvas>

OzBearbeiten

{Show 'Hallo Welt'}

P++Bearbeiten

Terminal terminal = new Terminal(1);
terminal.create();
terminal.output("Hallo Welt!").nextLine();

PascalBearbeiten

program Hallo_Welt(output);
begin
  writeln('Hallo Welt!')
end.

PAWNBearbeiten

main()
{
        printf("Hallo Welt!\n");
}

PEARLBearbeiten

MODULE (HALLOWELT);
    SYSTEM;
        TERMINAL:DIS<->SDVLS(2);

    PROBLEM;
        SPC TERMINAL DATION OUT ALPHIC DIM(,) TFU MAX FORWARD CONTROL (ALL);

    MAIN:TASK;
       OPEN TERMINAL;
       PUT 'Hallo Welt!' TO TERMINAL;
       CLOSE TERMINAL;
   END;

MODEND;

Perl 5Bearbeiten

#### Ausgabe auf STDOUT ####
print  "Hallo Welt!\n";        # " statt ', damit \n in Zeilenumbruch umgewandelt wird
printf 'Hallo Welt%s', "\n";   # flexibler, wie C's printf (wieder "\n", nicht '\n')

#### Ausgabe auf STDERR (Zeilenumbruch wird automatisch angehängt) ####
warn 'Aber hallo, Welt!';       # mit Fehlermeldung (Programmdatei und Zeile)
die  'Lebewohl, Welt!';         # mit Fehlermeldung und Programmbeendigung

oder

use feature qw(say);
say "Hallo Welt!";    # automatisch angehängter Zeilenumbruch

Perl 5 mit TkBearbeiten

use Tk;
$init_win = new MainWindow;
$label = $init_win -> Label(
                            -text => "Hallo Welt!"
                            ) -> pack(
                                      -side => top
                                      );
$button = $init_win -> Button(
                              -text    => "Ok",
                              -command => sub {exit}
                              ) -> pack(
                                        -side => top
                                        );

MainLoop;

Perl 5 mit WxBearbeiten

use Wx;

App->new->MainLoop;

package App;
use parent qw(Wx::App);

sub OnInit { Wx::Frame->new( undef, -1, 'Hallo Welt!')->Show() }

Perl 6Bearbeiten

#### Ausgabe auf STDOUT: ####

say    'Hallo Welt!';          # hängt Zeilenumbruch automatisch an
put    'Hallo Welt!';          # dito, bei einfachen Strings identisch zu say()
print  "Hallo Welt!\n";        # " statt ', damit \n in Zeilenumbruch umgewandelt wird
printf 'Hallo Welt%s', "\n";   # flexibler, wie C's printf (wieder "\n", nicht '\n')

## objektorientierter Aufruf (alles ist ein Objekt):
'Hallo Welt!'.say;
'Hallo Welt!'.put;
"Hallo Welt!\n".print;
'Hallo Welt!%s'.printf("\n");   # Zweites Argument bleibt ein Argument:
('Hallo Welt!%s', "\n").printf; # Das hier geht nicht!

#### Ausgabe auf STDERR (alle mit automatischem Zeilenumbruch): ####
note 'Aber hallo, Welt!';       # einfache Ausgabe
warn 'Aber hallo, Welt!';       # mit Fehlermeldung (Programmdatei und Zeile)
die  'Lebewohl, Welt!';         # mit Fehlermeldung und Programmbeendigung

## objektorientierter Aufruf analog zu oben

PHPBearbeiten

<?php
    print "Hallo Welt!";
?>

oder:

<?php
    echo "Hallo Welt!";
?>

oder:

<?="Hallo Welt!"?>

oder alternativ bei CLI-Anwendungen:

<?php
    fwrite(STDOUT, "Hallo Welt!");
?>

PikeBearbeiten

int main() {
    write("Hallo Welt!\n");
    return 0;
}

PL/IBearbeiten

Test: procedure options(main);
    put skip list("Hallo Welt!");
end Test;

PL/pgSQL prozedurale Spracherweiterung von PostgreSQLBearbeiten

BEGIN; -- Eine Transaktion beginnen.
  -- Eine Funktion namens hallo wird angelegt.
  -- "void" bedeutet, dass nichts zurückgegeben wird.
  CREATE OR REPLACE FUNCTION  hallo() RETURNS void AS
  -- Der Funktionskörper wird in $$-Stringliteralen gekapselt.
  -- Hier steht $body$ zwischen den $-Zeichen.
  -- Der Text zwischen den $-Zeichen muss eine Länge von mindestens 0 Zeichen aufweisen.
  $body$
    BEGIN
       RAISE NOTICE  'Hallo Welt'; -- Eine Notiz wird aufgerufen.
    END;
  $body$ -- Ende des Funktionskörpers.
  LANGUAGE plpgsql; -- Die Sprache des Funktionskörpers muss angegeben werden.

SELECT hallo();
   -- Die Funktion wird mit einem SELECT aufgerufen.
   -- Die Ausgabe der Notiz erfolgt in der Konsole.
ROLLBACK; -- alles rückgängig machen durch Zurückrollen der Transaktion.

PL/SQL prozedurale Spracherweiterung von OracleBearbeiten

CREATE OR REPLACE PROCEDURE HelloWorld as
BEGIN
   DBMS_OUTPUT.PUT_LINE('Hallo Welt!');
END;
/
set serveroutput on;
exec HelloWorld;

PocketCBearbeiten

Konsole:

main() {
  puts("Hallo Welt!");
}

Dialogfenster:

main() {
  alert("Hallo Welt!");
}

In einer Textbox:

main() {
  box=createctl("EDIT","Test",ES_MULTILINE,0x000,30,30,100,30,3000);
  editset(box,"Hallo Welt!");
}

POV-RayBearbeiten

camera {
 location <0, 0, -5>
 look_at  <0, 0, 0>
}
light_source {
 <10, 20, -10>
 color rgb 1
}
light_source {
 <-10, 20, -10>
 color rgb 1
}
background {
 color rgb 1
}
text {
 ttf "someFont.ttf"
 "Hallo Welt!", 0.015, 0
 pigment {
   color rgb <0, 0, 1>
 }
 translate -3*x
}

PowerShellBearbeiten

Kommandozeile:

"Hallo Welt!"

alternativ:

Write-Host "Hallo Welt!"

oder:

echo "Hallo Welt!"

oder:

[System.Console]::WriteLine("Hallo Welt!")

Dialogfenster:

[void][System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
[System.Windows.Forms.MessageBox]::Show("Hallo Welt!")

Progress 4GLBearbeiten

 DISPLAY "Hallo Welt!".

oder:

 MESSAGE "Hallo Welt!"
   VIEW-AS ALERT-BOX INFO BUTTONS OK.

PrologBearbeiten

 ?- write('Hallo Welt!'), nl.

PureBasicBearbeiten

In der Konsole:

 OpenConsole()
   Print("Hallo Welt!")
   Input() ;Beendet das Programm beim naechsten Tastendruck
 CloseConsole()

Im Dialogfenster:

 MessageRequester("Nachricht","Hallo Welt!")

Im Fenster:

 If OpenWindow(1,0,0,300,50,"Hallo Welt!",#PB_Window_ScreenCentered|#PB_Window_SystemMenu) ; Oeffnet ein zentriertes Fenster
  TextGadget(1,10,10,280,20,"Hallo Welt!",#PB_Text_Border)                                 ; Erstellt ein Textfeld "Hallo Welt!"
   Repeat
    event.i = WaitWindowEvent()                                                            ; Arbeitet die Windowsevents ab
   Until event = #PB_Event_CloseWindow                                                     ; solange, bis Schliessen geklickt wird
 EndIf

PythonBearbeiten

Bis einschließlich Version 2 (print ist ein Schlüsselwort):

print 'Hallo Welt!'

Ab Version 3 (print ist eine Funktion):

print('Hallo Welt!')

Als Easter Egg:

import __hello__

Python 2 mit TkinterBearbeiten

import Tkinter as tk # `import tkinter as tk' in Python 3

fenster = tk.Tk()
tk.Label(fenster, text="Hallo Welt!").pack()
fenster.mainloop()

QBASICBearbeiten

PRINT "Hallo Welt!"

RBearbeiten

print ("Hallo Welt!")

oder

cat ("Hallo Welt!\n")

REXXBearbeiten

say "Hallo Welt!"

RubyBearbeiten

puts "Hallo Welt!"

Ruby mit GTK+Bearbeiten

require "gtk2"
Gtk::Window.new("Hallo Welt!").show_all.signal_connect(:delete_event){Gtk.main_quit}
Gtk.main

Ruby mit TkBearbeiten

require "tk"
TkRoot.new{ title "Hallo Welt!" }
Tk.mainloop

RustBearbeiten

fn main() {
  println!("Hallo Welt");
}

SAC (Single Assignment C)Bearbeiten

use StdIO: all;
int main()
{
  printf("Hello World!\n");
  return(0);
}

SASBearbeiten

data _null_;
   put "Hallo Welt!";
run;

oder (SAS Macro Language)

%put Hallo Welt!;

ScalaBearbeiten

Als interpretierbares Skript:

println("Hallo Welt!")

Unter Ausnutzung des Traits App als übersetzbare Datei:

object HalloWelt extends App {
  println("Hallo Welt!")
}

oder Java-ähnlich als übersetzbare Datei:

object HalloWelt {
  def main(args: Array[String]) {
    println("Hallo Welt!")
  }
}

SchemeBearbeiten

(display "Hallo Welt!")
(newline)

Seed7Bearbeiten

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln("Hallo Welt!");
  end func;

SmalltalkBearbeiten

Mit Enfin Smalltalk:

'Hallo Welt!' out.

Mit VisualWorks:

Transcript show: 'Hallo Welt!'.

Spec#Bearbeiten

 using System;
 public class Programm
 {
    public static void Main(string![]! args)
    requires forall{int i in (0:args.Length); args[i] != null};
    {
        Console.WriteLine("Hallo Welt!");
    }
 }

Standard MLBearbeiten

print "Hallo Welt!\n"

SPLBearbeiten

debug "Hallo Welt!";

SQLBearbeiten

SELECT 'Hallo Welt!' AS message;

Für Oracle-Datenbanken, MySQL

SELECT 'Hallo Welt!' FROM dual;

Für IBM-DB2

SELECT 'Hallo Welt!' FROM sysibm.sysdummy1;

Für MySQL, PostgreSQL, SQLite und MSSQL

SELECT 'Hallo Welt!';

StarOffice BasicBearbeiten

 sub main
 print "Hallo Welt!"
 end sub

oder:

 sub HalloWeltAlternativ
     MsgBox "Hallo Welt!"
 end sub

SwiftBearbeiten

println("Hallo Welt!")
(Swift 1.0)
print("Hallo Welt!")
(ab Swift 2.0)

TclBearbeiten

puts "Hallo Welt!"

Tcl/TkBearbeiten

package require Tk
label .l -text "Hallo Welt"
pack .l

XOTclBearbeiten

proc hello {
puts "Hallo Welt!"
}

TuringBearbeiten

put "Hallo Welt!"

Unix-ShellBearbeiten

echo 'Hallo Welt!'

VerilogBearbeiten

module hallo_welt;
initial begin
 $display ("Hallo Welt!");
 #10 $finish;
end
endmodule

VHDLBearbeiten

entity HelloWorld is
end entity HelloWorld;
architecture Bhv of HelloWorld is
begin
  HelloWorldProc: process is
  begin
    report "Hallo Welt!";
    wait;
  end process HelloWorldProc;
end architecture Bhv;

Visual Basic ScriptBearbeiten

    MsgBox "Hallo Welt!"

Visual Basic .NETBearbeiten

Ausgabe in der Konsole:

Module Module1
    Sub Main()
        Console.WriteLine("Hallo Welt!")
    End Sub
End Module

Ausgabe in eine Messagebox:

Class Hallo
    Sub HalloWelt
       MsgBox("Hallo Welt!")
    End Sub
End Class

Siehe auchBearbeiten

WeblinksBearbeiten

Wikibooks: Auflistung von “Hello-World”-Programmen – Lern- und Lehrmaterialien (englisch)
Commons: Screenshots und Grafiken zu Hello World – Sammlung von Bildern, Videos und Audiodateien