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.
A Bearbeiten
ABAP Bearbeiten
REPORT Z_HALLO_WELT. WRITE 'Hallo Welt!'.
ActionScript Bearbeiten
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!" ); } } }
Ada Bearbeiten
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 60 Bearbeiten
'BEGIN' OUTSTRING(2,'('HALLO WELT')'); 'END'
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 68 Bearbeiten
( print("Hallo Welt!") )
AMOS BASIC Bearbeiten
? "Hallo Welt!"
APL Bearbeiten
'Hallo Welt!'
AppleScript Bearbeiten
display dialog "Hallo Welt!"
ASP (Active Server Pages) Bearbeiten
<% Response.Write("Hallo Welt!") %>
oder verkürzt
<%="Hallo Welt!"%>
AutoHotkey Bearbeiten
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{!}
AutoIt Bearbeiten
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)
AutoLISP Bearbeiten
(princ "Hallo Welt!")
awk Bearbeiten
BEGIN { print "Hallo Welt!" }
B Bearbeiten
B Bearbeiten
main() { printf("Hallo Welt!"); }
BASIC Bearbeiten
Traditionelles, unstrukturiertes BASIC:
10 PRINT "Hallo Welt!"
bzw. im Direktmodus:
?"Hallo Welt!"
Batch Bearbeiten
Die Kommandozeilenbefehlssprache von MS-DOS, PC DOS, DR-DOS und Windows NT.
@echo Hallo Welt!
BeanShell Bearbeiten
print("Hallo Welt!");
Blitz Basic Bearbeiten
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
BlitzMax Bearbeiten
Framework BRL.StandardIO Print("Hallo Welt!")
Boo Bearbeiten
print "Hallo Welt!"
C Bearbeiten
C Bearbeiten
#include <stdio.h> int main() { puts("Hallo Welt!"); return 0; }
C unter Benutzung der POSIX-API Bearbeiten
#include <unistd.h> const char HALLOWELT[] = "Hallo Welt!\n"; int main(void) { write(STDOUT_FILENO, HALLOWELT, sizeof HALLOWELT - 1); return 0; }
C mit GTK Bearbeiten
#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 API Bearbeiten
#include <windows.h> VOID WINAPI WinMainCRTStartup(VOID) { MessageBox(HWND_DESKTOP, "Hallo Welt!", "Mein erstes Programm", MB_OK); ExitProcess(0); }
C++ Bearbeiten
#include <iostream> int main() { std::cout << "Hallo Welt!" << std::endl; }
C++/CLI Bearbeiten
int main() { System::Console::WriteLine("Hallo Welt!"); }
C++/CX Bearbeiten
#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 gtkmm Bearbeiten
#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 Qt Bearbeiten
#include <QLabel> #include <QApplication> int main(int argc, char* argv[]) { QApplication app(argc, argv); QLabel label("Hallo Welt!"); label.show(); app.exec(); }
C# Bearbeiten
Ausgabe in der Konsole:
static class Program { static void Main() { System.Console.WriteLine("Hallo Welt!"); } }
…ab C# 9 werden Anweisungen auf oberster Ebene unterstützt. Es wird keine Hauptklasse und keine Hauptmethode benötigt:
System.Console.WriteLine("Hallo Welt!");
Ausgabe in einer Messagebox:
static class Program { static void Main() { System.Windows.Forms.MessageBox.Show("Hallo Welt"); } }
C/AL Bearbeiten
MESSAGE('Hallo Welt')
Ceylon Bearbeiten
// In der Datei module.ceylon module hello "1.0.0" {} // In der Datei hallo.ceylon shared void run() { print("Hallo Welt!"); }
CIL Bearbeiten
.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 }
CLIST Bearbeiten
WRITE HALLO WELT
Clojure Bearbeiten
(println "Hallo Welt!")
COBOL Bearbeiten
000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. HELLOWORLD. 000900 PROCEDURE DIVISION. 001000 MAIN. 001100 DISPLAY "Hallo Welt!". 001200 STOP RUN.
COLDFUSION Bearbeiten
<cfset beispiel = "Hallo Welt!" > <cfoutput>#beispiel#</cfoutput>
COMAL Bearbeiten
10 PRINT "Hallo Welt!"
Common Lisp Bearbeiten
(write-line "Hallo Welt!")
Component Pascal Bearbeiten
MODULE HalloWelt; IMPORT Out; PROCEDURE Output*; BEGIN Out.String ("Hallo Welt!"); Out.Ln; END Output; END HalloWelt.
D Bearbeiten
D Bearbeiten
import std.stdio; void main() { writeln("Hallo Welt!"); }
DarkBASIC Bearbeiten
print "Hallo Welt!" wait key
dBASE, FoxPro und Clipper Bearbeiten
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!"
Dylan Bearbeiten
define method hallo-welt() format-out("Hallo Welt!\n"); end method hallo-welt; hallo-welt();
E Bearbeiten
Eiffel Bearbeiten
class HALLO_WELT create make feature make is do io.put_string("Hallo Welt!%N") end end
ELAN Bearbeiten
putline ("Hallo Welt!");
Elixir Bearbeiten
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.
Erlang Bearbeiten
-module(hallo). -export([hallo_welt/0]). hallo_welt() -> io:fwrite("Hallo Welt!\n").
F Bearbeiten
F# Bearbeiten
printfn "Hallo Welt"
Forth Bearbeiten
Als Wort:
: hallo-welt ." Hallo, Welt!" cr ;
bzw. im Direktmodus:
.( Hallo, Welt!) cr
Fortran Bearbeiten
program hallo print *, "Hallo Welt!" end program hallo
Fortress Bearbeiten
component HalloWelt export Executable run(args:String) = print "Hallo Welt!" end
FreeBASIC Bearbeiten
print "Hallo Welt!" sleep
G Bearbeiten
GML Bearbeiten
show_message("Hallo Welt!");
oder:
draw_text(x,y,"Hallo Welt!");
Gambas Bearbeiten
PUBLIC SUB Form_Enter() PRINT "Hallo Welt!" END
Go Bearbeiten
package main import "fmt" func main() { fmt.Println("Hallo Welt!") }
Groovy Bearbeiten
println "Hallo Welt!"
H Bearbeiten
Haskell Bearbeiten
main :: IO () main = putStrLn "Hallo Welt!"
Haxe Bearbeiten
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>
I Bearbeiten
IDL (RSI) Bearbeiten
PRO hallo_welt PRINT, "Hallo Welt!" END
Io Bearbeiten
"Hallo Welt!" print
J Bearbeiten
J# Bearbeiten
public class HalloWelt { public static void main(String[] args) { System.Console.WriteLine("Hallo Welt!"); } }
JavaScript Bearbeiten
Im Browser Bearbeiten
document.write("Hallo Welt!");
Mit Node.js Bearbeiten
console.log("Hallo Welt!");
Java Bearbeiten
Ausgabe in der Konsole:
class Hallo { public static void main( String[] args ) { System.out.println("Hallo Welt!"); } }
Ausgabe in einer Messagebox mit dem GUI-Toolkit Swing:
import javax.swing.*; class Hallo { public static void main( String[] args ) { JOptionPane.showMessageDialog( null, "Hallo Welt!" ); } }
Java-Applet Bearbeiten
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>
Julia Bearbeiten
println("Hallo Welt!")
K Bearbeiten
KiXtart Bearbeiten
? "Hallo Welt!"
Kotlin Bearbeiten
fun main() { println("Hallo Welt!") }
L Bearbeiten
Lisp Bearbeiten
(print "Hallo Welt!")
oder
(princ "Hallo Welt!") (terpri)
Mit terpri erfolgt Zeilenumbruch.
Logo Bearbeiten
print [Hallo Welt!]
Lua Bearbeiten
print ("Hallo Welt!")
Hierbei können die Klammern um den String allerdings weggelassen werden:
print "Hallo Welt!"
M Bearbeiten
Matlab Bearbeiten
fprintf('Hallo Welt!');
oder
disp('Hallo Welt!');
oder
disp Hallo_Welt
oder
'Hallo Welt'
mIRC Script Bearbeiten
on 1:load:*: { echo Hallo Welt! }
MS-DOS Batch Bearbeiten
@echo off echo Hallo Welt!
O Bearbeiten
Oberon Bearbeiten
MODULE HalloWelt; IMPORT Write; BEGIN Write.Line("Hallo Welt!"); END HalloWelt.
Object Pascal Bearbeiten
CLI:
begin write('Hallo Welt!'); end.
GUI:
{$APPTYPE GUI} uses Dialogs; begin ShowMessage('Hallo Welt!'); end.
OCaml Bearbeiten
print_endline "Hallo Welt!";;
Objective-C Bearbeiten
#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 Cocoa Bearbeiten
#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
OpenLaszlo Bearbeiten
<canvas> <text>Hallo Welt!</text> </canvas>
Oz Bearbeiten
{Show 'Hallo Welt'}
P Bearbeiten
Pascal Bearbeiten
program Hallo_Welt(output); begin writeln('Hallo Welt!') end.
PEARL Bearbeiten
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 5 Bearbeiten
#### 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 Tk Bearbeiten
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 Wx Bearbeiten
use Wx; App->new->MainLoop; package App; use parent qw(Wx::App); sub OnInit { Wx::Frame->new( undef, -1, 'Hallo Welt!')->Show() }
Perl 6 Bearbeiten
#### 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
PHP Bearbeiten
<?php print "Hallo Welt!"; ?>
oder:
<?php echo "Hallo Welt!"; ?>
oder:
<?="Hallo Welt!"?>
oder alternativ bei CLI-Anwendungen:
<?php fwrite(STDOUT, "Hallo Welt!"); ?>
Pike Bearbeiten
int main() { write("Hallo Welt!\n"); return 0; }
PL/I Bearbeiten
Test: procedure options(main); put skip list("Hallo Welt!"); end Test;
PL/pgSQL prozedurale Spracherweiterung von PostgreSQL Bearbeiten
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 Oracle Bearbeiten
CREATE OR REPLACE PROCEDURE HelloWorld as BEGIN DBMS_OUTPUT.PUT_LINE('Hallo Welt!'); END; / set serveroutput on; exec HelloWorld;
PocketC Bearbeiten
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-Ray Bearbeiten
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 }
PowerShell Bearbeiten
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 4GL Bearbeiten
DISPLAY "Hallo Welt!".
oder:
MESSAGE "Hallo Welt!" VIEW-AS ALERT-BOX INFO BUTTONS OK.
Prolog Bearbeiten
?- write('Hallo Welt!'), nl.
PureBasic Bearbeiten
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
Python Bearbeiten
Bis einschließlich Version 2 (print
ist ein Schlüsselwort):
print 'Hallo Welt!'
Ab Version 3 (print
ist eine Funktion):
print('Hallo Welt!')
oder mit doppelten Anführungszeichen
print("Hallo Welt!")
Als Easter Egg:
import __hello__
Python mit Tkinter Bearbeiten
from tkinter import * #'Tkinter' anstatt 'tkinter' in Python 2.x root = Tk() Label(root, text="Hallo Welt!").pack() root.mainloop()
Q Bearbeiten
QBasic Bearbeiten
PRINT "Hallo Welt!"
R Bearbeiten
R Bearbeiten
print("Hallo Welt!")
mit der cat()-Funktion
cat("Hallo Welt!\n")
oder mit der writeLines()-Funktion
writeLines("Hallo Welt!")
Racket Bearbeiten
#lang racket/base "Hallo Welt!"
REXX Bearbeiten
say "Hallo Welt!"
Ruby Bearbeiten
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 Tk Bearbeiten
require "tk" TkRoot.new{ title "Hallo Welt!" } Tk.mainloop
Rust Bearbeiten
fn main() { println!("Hallo Welt"); }
S Bearbeiten
SAS Bearbeiten
data _null_; put "Hallo Welt!"; run;
oder (SAS Macro Language)
%put Hallo Welt!;
Scala Bearbeiten
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!") } }
Scheme Bearbeiten
(display "Hallo Welt!") (newline)
Seed7 Bearbeiten
$ include "seed7_05.s7i"; const proc: main is func begin writeln("Hallo Welt!"); end func;
Smalltalk Bearbeiten
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 ML Bearbeiten
print "Hallo Welt!\n"
SQL Bearbeiten
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 Basic Bearbeiten
sub main print "Hallo Welt!" end sub
oder:
sub HalloWeltAlternativ MsgBox "Hallo Welt!" end sub
Swift Bearbeiten
Swift 1.0:
println("Hallo Welt!")
Swift 2.0:
print("Hallo Welt!")
T Bearbeiten
Tcl Bearbeiten
puts "Hallo Welt!"
Tcl/Tk Bearbeiten
package require Tk label .l -text "Hallo Welt" pack .l
XOTcl Bearbeiten
proc hello { puts "Hallo Welt!" }
TI-Basic Bearbeiten
:Disp "HELLO, WORLD!"
Turing Bearbeiten
put "Hallo Welt!"
U Bearbeiten
Unix-Shell Bearbeiten
echo 'Hallo Welt!'
V Bearbeiten
Verilog Bearbeiten
module hallo_welt; initial begin $display ("Hallo Welt!"); #10 $finish; end endmodule
VHDL Bearbeiten
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, Visual Basic Script und Visual Basic for Applications Bearbeiten
MsgBox "Hallo Welt!"
…alternativ über den Windows Script Host:
WScript.Echo "Hallo Welt!"
Visual Basic .NET Bearbeiten
Ausgabe in der Konsole:
Module Module1 Sub Main() Console.WriteLine("Hallo Welt!") End Sub End Module
Ausgabe in einer Messagebox:
Class Hallo Sub HalloWelt MsgBox("Hallo Welt!") End Sub End Class
Siehe auch Bearbeiten
Weblinks Bearbeiten
- The Hello World Collection – enthält Hello World-Programme in 500 Programmiersprachen
- Index of Hello World! programs and beyond (englisch)
- dev.mysql.com
Einzelnachweise Bearbeiten
- Bill Wagner et al.: What’s new in C# 9.0. Top-level statements. In: learn.microsoft.com. Microsoft, 21. Februar 2023, abgerufen am 4. Juli 2023 (englisch).