Liste der Hallo-Welt Programme / Höhere Programmiersprachen

Dies ist eine Liste der Hallo-Welt-Programme für das Programm . Für jede Sprache wird vorgetragen, wie man in ihrer einfachen Aufgabe aussieht, den Text „Hallo Welt!“ Auf dem Bildschirm auszugeben. Weitere Beispiele für Grafische Benutzeroberflächen, Web-Technologien, Exotische Programmerprachen und Textauszeichnungssprachen sind hier aufgelistet. Beispiele in Assembler für verschiedene Plattformen, die sich unter Liste-Welt-Programme / Assembler befinden . Das diesjährige Hallo-Welt-Programm ist ein Programm von APL , dem zweitkürzeste Forth . Beide Befehle können ohne Funktion oder Schlüsselwort aus.

ABAP

REPORT Z_HALLO_WELT .
Schreib 'Hallo Welt!' .

ActionScript

Spur ( 'Hallo Welt' );

ActionScript 3.0 und unter Verwendung der DocumentClass:

Paket {
 import flash.display.Sprite ;
 Öffentliche Klasse Main erweitert Sprite {
 öffentliche Funktion Main () {
trace ( "Hallo Welt!" ); } } }

Ada

mit ada.Text_IO ;
Verfahren Hallo ist
beginnen
Ada . Text_IO . Put_Line ( "Hallo Welt!" ); als hallo ;

Für eine Erklärung des Programmierers siehe Ada Programming / Basic im englischen Sprachbuch .

Algol 60

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

Anmerkung: Bei der Sprachdefinition von ALGOL 60 wurden Ein- / Ausgabeanweisungen aus der Standardisierung übernommen, so dass Implementierungen sterk zwischen den Compilern variieren können. So Werden of this Text bei der Electro Logica X1 (nach vorheriger Wahl des Ausgabekanals mit SELECTOUTPUT(2); ) mit WRITETEXT('('HALLO WELT')');leiht with the OutString-befehl ausgegeben.

Algol 68

 ( Druck ( "Hallo Welt!" ) )

AMOS BASIC

? "Hallo Welt!"

APL

"Hallo Welt!"

AppleScript

Display - Dialog "Hallo Welt!"

ASP (Aktive Serverseiten)

<%
Reaktion . Schreibe ( "Hallo Welt!" ) %>

oder verkurzt

<% = "Hallo Welt!" %>

AutoHotkey

Variante 1. Klassische MessageBox

MsgBox Hallo Welt !

Variante 2: Das Programm Notepad und dot dort „Hallo Welt“ ein

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

AutoIt

Variante 1: Habe deine normale Messagebox ohne Titel gestartet

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

Variante 2: Gestartet wurde der Redakteur Wartet bis jetzt, ist die Stunde der Sendung des Send-Befehls Aktiv und schreibt Hallo Welt! Tage zwischen.

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

AutoLISP

( Prinz "Hallo Welt!" )

awk

BEGIN { print "Hallo Welt!" }

B

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

BASIC

Traditionelles, unstruiertes BASIC:

10 DRUCKEN "Hallo Welt!"

BZW. Im Direktmodus:

? "Hallo Welt!"

Batch

MS-DOS- , PC DOS- , DR-DOS- und Windows NT- Befehle .

@echo Hallo Welt!

BeanShell

drucken ( "Hallo Welt!" );

Blitz Basic

Ohne GUI :

Grafik 800 , 600 SetBuffer BackBuffer () Text 10 , 10 , "Hallo Welt" Flip WaitKey Ende

Meine GUI (BlitzPlus)

Fenster = Create ( "Hallo Welt! Fenster", 0, 0, 100, 80, 0, 1)
 label = Etikett Kreieren ( "Hallo Welt", 5, 5, 80, 20, Fenster)
 Wiederholen Sie
warten , bis Wait () = $ 803

BlitzMax

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

Boo

print "Hallo Welt!"

C

#include <stdio.h>
int main ( void )
{
puts ( "Hallo Welt!" ); }

C unter benutzung wo POSIX APIs

#include <unistd.h>
const char hallo [] int Haupt ( ungültig ) { write ( STDOUT_FILENO , hallo , sizeof hallo - 1 ); zurückgeben 0 ; }= "Hallo Welt!\n";

C mit GTK

#include <gtk / gtk.h>
gboolean delete_event ( GtkWidget * Widget , GdkEvent * Ereignis , gpointer Daten )
{
 zurück FALSE ;
}
Void zerstören ( GtkWidget * Widget , gpointer Daten )
{
 gtk_main_quit ();
}
Void geklickt ( GtkWidget * Widget , gpointer Daten )
{
 g_print ( "Hallo Welt! \ N " );
}
Int Haupt ( int argc , char * argv [])
{
 gtk_init ( & argc , & argv );
 GtkWidget * -Fenster ;
 GtkWidget * -Taste ;
 window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
 gtk_container_set_border_width ( GTK_CONTAINER ( Fenster ), 10 );
 g_signal_connect ( G_OBJECT ( Fenster ), "Delete-event" , G_CALLBACK ( delete_event ), NULL );
 g_signal_connect ( G_OBJECT ( Fenster ), "zerstören" , G_CALLBACK ( zerstören ), null );
 button = gtk_button_new_with_label ( "Hallo Welt!" );
 g_signal_connect ( G_OBJECT ( Schaltfläche ), "geklickt" , G_CALLBACK ( geklickt ), NULL );
 gtk_widget_show ( Schaltfläche );
 gtk_container_add ( GTK_CONTAINER ( Fenster ), Schaltfläche );
 gtk_widget_show ( Fenster );
 gtk_main ();
}

C mit Windows API

#include <windows.h>
int WINAPI winmain ( hInstance hInst , hInstance hPrevInstance , LPSTR lpCmdLine , int nCmdShow )
{
MessageBoxA ( 0 , "Hallo Welt" , "Mein erstes Applications" , MB_OK ); zurückgeben 0 ; }

C ++

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

C ++ / CLI

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

C ++ / CX

# include "stdafx.h"
#benutze <Platform.winmd>
mit Namespace Platform ;
[ MTAThread ]
int main ( Array < String ^> ^ Argumente )
{
 String ^ Nachricht ( "Hallo Welt!" );
Details :: Konsole :: WriteLine ( Nachricht ); }

C ++ mit gtkmm

#include <gtkmm / main.h>
#include <gtkmm / button.h>
#include <gtkmm / window.h>
int main ( int argc , Zeichen * argv [])
{
 Gtk :: Main m_main ( argc , argv );
 Gtk :: Fenster m_window ;
 Gtk :: Button m_button ( "Hallo Welt!" );
 m_window . füge hinzu ( m_button );
 m_Button . show ();
 Gtk :: Main :: run ( m_window );
}

C ++ mit Qt

#include <QLabel>
#include <QApplication>
int main ( int argc , char * argv [])
{
 QApplikations- App ( argc , argv );
Q Label ( "Hallo Welt!" ); Etikett . show (); App . exec (); }

C #

Klasse Hauptklasse
{
 public static void Haupt ()
 {
System . Konsole . WriteLine ( "Hallo Welt!" ); } }

oder als Nachrichtenbox

statische Klasse Programm
{
 static void Main ()
 {
System . Windows . Formulare . MessageBoxA . Zeigen ( "Hallo Welt" ); } }

C / AL

NACHRICHT ( Hallo Welt )

Ceylon

// In der Datei module.ceylon
Modul hallo "1.0.0" {}
// In der Datei hallo.ceylon
geteilt Leere laufen () {
Druck ( "Hallo Welt!" ); }

CIL

.assembly HelloWelt {}
.assembly external mscorlib {}
.method public static void Haupt () cil verwaltet
{
 .entrypoint
 .maxstack 1
 ldstr "Hallo Welt!" Aufruf void [mscorlib] System.Console :: WriteLine (String)
 rechts
}

CLIST

SCHREIBEN HALLO WELT

Clojure

( println "Hallo Welt!" )

CLP

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

COBOL

000100 IDENTIFICATION DIVISION . 000.200 PROGRAM - ID . HELLOWORLD . 000 900 PROCEDURE DIVISION . 001000 MAIN . 001100 DISPLAY "Hallo Welt!" . 001200 STOPP RUN .

KALTE FUSION

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

COMAL

10 DRUCKEN "Hallo Welt!"

Gewöhnliches Lisp

( Schreiblinie "Hallo Welt!" )

Komponente Pascal

MODUL hallo ;
IMPORT OUT ;
VORGEHENSWEISE Ausgabe * ;
ANFANG
ANFANGEN . String ( "Hallo Welt!" ); Aus . Ln ; ENDE Ausgabe ; ENDE HelloWell .

D

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

DarkBASIC

print "Hallo Welt!"
Warte- Taste

dBASE / Foxpro

Ausgabe in der nächsten freien Zeile:

? "Hallo Welt!"

Zeilen- und spaltengenaue Ausgabe:

@ 1.1 sag "Hallo Welt!"

Ausgabe in einem Fenster:

warten Fenster "Hallo Welt!"

Dylan

definiere Methode hallo-welt ()
 format-out ( "Hallo Welt! \ n " );
End - Verfahren Hallo-welt ;
Hallo Welt ();

Eiffel

Klasse HALLO_WELT
schaffen
 machen
Features
 machen ist
 tun
io . put_string ( "Hallo Welt!% N" ) als Ende

ELAN

Putline ( "Hallo Welt!" );

Elixier

IO . setzt "Hallo Welt"

oder:

defmodule Hello World do
 def hallo () tun
 IO . setzt "Hallo Welt!"
 als
Ende

Emacs Lisp

( drucke "Hallo Welt!" )

Erlang

- Modul ( Hallo ).
- Export ([ Hallo_welt / 0 ]).
hallo_welt () -> io : fwrite ( "Hallo Welt! \ n " ).

F #

printfn "Hallo Welt"

Forth

Als Wort:

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

BZW. Im Direktmodus:

. (Hallo, Welt!) Cr

Fortran

Programm Hallo
schreib ( * , * ) "Hallo Welt!"
als das Programm Hallo

Festung

Component HelloWelt
 export Ausführbarer
 Lauf ( args: String ) = print "Hallo Welt!"
Ende

FreeBASIC

print "Hallo Welt!"
Schlaf

GML

show_message ( "Hallo Welt!" );

oder:

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

Gambas

 PUBLIC SUB Form_Enter () DRUCKEN "Hallo Welt!" ENDE

Gehe

verpacken Haupt
import „FMT“
func main() {
fmt.Println("Hallo Welt!")
}

Groovy

println "Hallo Welt!"

Haskell

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

Haxe

Klasse - Test {
static Funktion Haupt () { trace ( "Hallo Welt!" ); } }

Diejenigen, die SWF-Oder Neko-Bytecodes kompiliert haben, sind alleine lauffähig. Zur Verwendung von compiliertem Javascript wird benötigt:

< Html > < Körper >
< div id = "haxe: trace" > </ div >
< script Typ = "text / javascript" src = "hallo_welt_haxe.js" > </ script >
 </ Körper > </ html >

IDL (RSI)

PRO hallo_welt
 PRINT "Hallo Welt!"
ENDE

Io

"Hallo Welt!" print

J #

public class hallo
{
 public static Leeres Haupt ( String [] args )
 { -
System . Konsole . WriteLine ( "Hallo Welt!" ); } }

JavaScript

Im Browser

Dokument . schreibe ( "Hallo Welt!" );

Meine Node.js

Konsole . log ( "Hallo Welt!" );

Java

Klasse Hallo {
 public static void main { String [] verärgert ) {
System . aus . drucken ( "Hallo Welt!" ); } }

oder als Dialogkämpfer:

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

Java Applet

Java Applets Features in Verbindung mit HTML .

Die Java-Datei:

import java.applet. * ;
import java.awt. * ;
Öffentliche Klasse HalloWelt erweitert Applet {
 public void paint ( Grafik g ) {
g . Zeichenkette ( "Hallo Welt!" , 100 , 50 );
 }
}

Nachfolge der Code zum Einbau in Eine HTML-Seite. Vom W3C empfohlen:

< Object CLASSID = "java: HalloWelt.class"
 Code - Typ = "application / java-vm"
 Breite = "600" Höhe = "100" >
</ object >

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

< Applet - Code = "HalloWelt.class"
 Breite = "600" Höhe = "100" >
</ Applet >

Java-JDBC

JDBC- Programmarbeit in Verbindung mit einer Datenbank, für die Hersteller einen geeigneten Datenbankkäufer vorbereitet.

Die Java-Datei:

import java.sql.Verbindung ;
import java.sql.DriverManager ;
import java.sql.ResultSet ;
import java.sql.SQLException ;
import java.sql.Statement ;
Öffentliche Klasse Main { private statische endgültige Zeichenfolge URL = "jdbc: mysql: // localhost / TEST? usseSSL = false" ; private statische letzte Zeichenfolge USER = "root" ; private statische letzte Zeichenfolge PASSWORD = "password" ;
//
private statische letzte String SQL = "SELECT" Hallo, Welt! " " ;
public static Leere Haupt ( String [] args ) wirft SQLException {
Verbindung conn = Driver Manager . getConnection ( URL , BENUTZER , PASSWORT );
Aussage st = conn . createStatement ();
ResultSet rs = st . Ausführungsanfrage ( SQL );
while ( rs . next () ) {
System . aus . println ( rs . getString ( 1 ) );
}
}
}

Das Beispiel nutzt MySQL DATABANK im Auftrag von TEST im Auftrag von Rechner (localhost). Es muss ein Benutzer im Auftrag von „root“ mit dem Passwort „Passwort“ angemeldet sein. Es wird ein Datenbanktreiber im Auftrag von com.mysql.jdbc.Driververwendet, der im Archiv mysql-connector-java-5.1.38-bin.jarvorhanden ist. Dieses Archiv kann von dev.mysql.com heruntergeladen werden . Bei der Ausführung des Programms gibts die Archivdatei im Classpathan.

Julia

println ( "Hallo Welt!" )

KiXtart

? "Hallo Welt!"

Kotlin

Spaß main ( args : Array < String >) {
println ( "Hallo Welt!" ) }

Lisp

( drucke "Hallo Welt!" )

oder

( Prinz "Hallo Welt!" )
 ( Terpri )

Meine Terpri wird von Zeilenumbruch begleitet.

Logo

drucken [Hallo Welt !]

Lua

drucken ( "Hallo Welt!" )

Hier wurden sowohl die Klammern um den String als auch allierdings mitgeschleppt:

print "Hallo Welt!"

Matlab

fprintf ( 'Hallo Welt!' );

oder

disp ( 'Hallo Welt!' );

oder

disp hallo_well

oder

"Hallo Welt"

mIRC-Skript

auf 1: laden: *: {echo Hallo Welt! }

MS-DOS- Stapel

Echo Hallo Welt!

Oberon

MODUL hallo ;
IMPORT Schreiben ;
BEGIN
Schreiben . Linie ( "Hallo Welt!" ); ENDE HelloWell .

CLI:

Beginne zu
 schreiben ( 'Hallo Welt!' ) ;
Ende .

GUI:

 {$ APPTYPE GUI}
 verwendet Dialoge ;
 beginnen
 Anzeigen Nachricht ( 'Hallo Welt!' ) ;
Ende .

OCaml

print_endline "Hallo Welt!" ;;

Objective-C

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

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

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

Objective-C mit Kakao

#import <Cocoa / Cocoa.h>
@interface Controller : NSObject
{
 NSWindow * -Fenster ;
 NSTextField * textField ;
}
@ End
int Haupt ( int argc , const char * argv [])
{
 NSAutoreleasePool * Pool = [[ NSAutoreleasePool alloc ] init ];
 NSApp = [ NSApplication sharedApplication ];
 Controller * Controller = [[ Controller allocation ] init ];
 [ NSApp ausführen ];
 [ Controller - Release ];
 [ NSApp- Veröffentlichung ];
 [ Pool Release ];
 Zurückgeben von EXIT_SUCCESS ;
}
@implementation Controller
- ( id ) init
{
 if (( self = [ super init ]) = = null ) {
 textField = [[ NSTextField alloc ] initWithFrame : NSMakeRect ( 10.0 , 10.0 , 85.0 , 20.0 )];
 [ textField setEditable : NEIN ];
 [ textField setStringValue : @ "Hallo Welt!" ];
 Fenster = [[ NSWindow alloc ] initWithContentRect : NSMakeRect ( 100,0 , 350,0 , 200,0 , 40,0 )
 Stil Maske Rückkehr selbst ; }:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask
 backing:NSBackingStoreBuffered
 defer:YES];
 [window setDelegate:self];
 [window setTitle:@"Hallo Welt!"];
 [[window contentView] addSubview:textField];
 [window makeKeyAndOrderFront:nil];
 }
- ( void ) windowWillClose: ( NSNotification * ) Benachrichtigung
{
 [ NSApp terminate : self ];
}
@end

OpenLaszlo

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

Oz

{ Zeige 'Hallo Welt' }

P ++

Terminal- Terminal = neues Terminal ( 1 );
Terminal . create ();
Terminal . Ausgabe ( "Hallo Welt!" ). nextLine ();

Pascal

Programm hallo_welt ;
Beginne zu
schreiben ( 'Hallo Welt!' ) Ende .

Bauer

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

PEARL

MODUL ( HALLOWELT ) ;
 SYSTEM ;
 TERMINAL : DIS <-> SDVLS ( 2 ) ;
 PROBLEM ;
 SPC TERMINAL DIERUNG OUT ALPHIC DIM ( , ) TFU MAX FORWARD CONTROL - ( ALL ) ;
 MAIN : AUFGABE ;
 ÖFFNEN TERMINAL ;
 PUT 'Hallo Welt!' Am Terminal ;
 SCHLIESSEN TERMINAL ;
 ENDE ;
MODEND ;

Perl

print "Hallo Welt! \ n" ;

oder

Verwenden Sie die Funktion qw (say) ;
sag "Hallo Welt!" ;

Perl mit Tk

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

Perl mit Wx

benutze wx ;
App -> neu -> MainLoop ;
Paket- App ;
benutze Eltern qw (Wx :: App) ;
Unter OnInit { Wx :: Frame -> neu ( undef , - 1 , 'Hallo Welt!' ) -> Show () }

Perl 6

sag 'Hallo Welt!' ;

PHP

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

oder:

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

oder:

<? = "Hallo Welt!" ?>

oder:

Hallo Welt !

oder alternative CLI-Anwendungen :

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

Hecht

int main () {
write ( "Hallo Welt! \ n " ); zurückgeben 0 ; }

PL/I

Test: Prozeduroptionen (Haupt);
 Schiffsliste setzen ("Hallo Welt!");
Endtest;

PL / pgSQL prozedurale Spracherweiterung von PostgreSQL

ANFANG ; - Starten Sie eine Transaktion.
 - Eine Funktion im Auftrag von Hello Wird Angelegt.
 - "void" bedeutet, dass nichts zurückgegeben wird.
 CREATE OR REPLACE FUNCTION hallo () RETURNS Leere AS
 - Der Funktionskörper Wird in $$ - String Liter Alen gekapselt.
 - Hier ist $ body $ swiss the $ -Zeichen.
 - Der Text zwischen $ -Zeichen muss eine Länge von mindestens 0 Zeichen aufweisen.
 $ body $
 BEGINNEN
 RAISE NOTICE 'Hallo Welt'; - Eine Benachrichtigung wird ausgelöst.
 END;
 $ body $ - Ende der Funktion Skerper.
 SPRACHE plpgsql ; - Die Sprache des Funktionskörpers muss angegeben werden.
SELECT Hallo ();
 - Die Funktion wird mit einem SELECT ausgeführt.
 - Die Ausgabe von Notiz ist in der Konsole enthalten.
ROLLBACK ; - Alles rückgängig machen durch Zurückrollen der Transaktion.

PL / SQL prozedurale Spracherweiterung von Oracle

CREATE OR REPLACE PROCEDURE Hallo Welt als
BEGIN
 DBMS_OUTPUT . PUT_LINE ( 'Hallo Welt!' );
ENDE ;
/
set server output on ;
exec HelloWorld ;

PocketC

konsole:

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

Dialogfenster:

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

In einem Textfeld:

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

POV-Ray

Kamera {
 Ort < 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

Kommandozeile:

"Hallo Welt!"

Option:

Schreib-Host "Hallo Welt!"

oder:

echo "Hallo Welt!"

oder:

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

Dialogfenster:

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

Fortschritt 4GL

 ANZEIGE "Hallo Welt!" .

oder:

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

Prolog

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

PureBasic

In der Konsole:

OpenConsole ()
 Drucken ("Hallo Welt!")
 Input (); Beendet das Programm beim nächsten Tastendruck
 CloseConsole ()

Im Dialog fenster:

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

Im Fenster:

Wenn OpenWindow (1.0.0.300.50, "Hallo Welt!", # PB_Window_ScreenCentered | #PB_Window_SystemMenu); Oeffnet ein zenriertes Fenster
 TextGadget (1,10,10,280,20, "Hallo Welt!", # PB_Text_Border); Nur ein Textfeld "Hallo Welt!"
 Wiederholen Sie
 event.i = WaitWindowEvent (); Working Windowsevents ab
 Bis event = #PB_Event_CloseWindow; solange, bis Schliessen geklickt wird
 EndIf

Python

Bis schließlich Version 2 ( printist ein Schlüsselwort ):

print "Hallo Welt!"

Ab Version 3 ( printist eine Funktion ):

drucken ( "Hallo Welt!" )

Python 2 mit Tkinter

importiere Tkinter als tk # `import tkinter als tk 'in Python 3
fenster = tk . Tk ()
tk . Label ( Fenster , Text = "Hallo Welt!" ) . pack ()
 fenster . Hauptschleife ()

QBASIC

DRUCKEN "Hallo Welt!"

R

drucken ( "Hallo Welt!" )

oder

Katze ( "Hallo Welt! \ n" )

REXX

sag "Hallo Welt!"

Rubin

setzt "Hallo Welt!"

Rubin mit GTK +

require "gtk2"
Gtk :: Fenster . neu ( "Hallo Welt!" ) . show_all . signal_connect ( : delete_event ) { Gtk . main_quit }
 Gtk . Haupt-

Ruby mit Tk

require "tk"
TkRoot . neu { Titel "Hallo Welt!" }
 Tk . Hauptschleife

Rest

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

SAC (Einzelauftrag C)

benutze StdIO : alles ;
int main ()
{
printf ( "Hallo Welt! \ n " ); Rückkehr ( 0 ); }

SAS

Daten _null_;
 "Hallo Welt!"
laufen;

oder (SAS Makrosprache)

% Hallo Welt!

Scala

Als interpretierbare Skripte:

println ( "Hallo Welt!" )

Unter Ausnutzung des Traits App als übersetzbare Datei:

Objekt HelloWelt erweitert App {
println ( "Hallo Welt!" ) }

oder Java-ähnlich als übersetzbare Datei:

Objekt hallo {
 def Haupt ( args : Array [ String ]) {
println ( "Hallo Welt" ) } }

Schema

( Anzeige "Hallo Welt!" )
 ( Newline )

Seed7

$ include "seed7_05.s7i";
const proc: main ist func
 beginnen
 writeln ("Hallo Welt!");
 als func;

Smalltalk

Mein Enfin Smalltalk :

"Hallo Welt!" aus .

Mein VisualWorks :

Abschrift zeigen: "Hallo Welt!" .

Spec #

 Mit System ;
 public class Anwendungen
 {
 public static Leere Haupt ( String [] args )
 erfordert forall { int in in ( 0 : args . Länge ); args [ in ] ! = null };
 {
Console . WriteLine ( "Hallo Welt!" ); } }

Standard ML

print "Hallo Welt! \ n "

SPL

debuggen "Hallo Welt!" ;

SQL

WÄHLEN 'Hallo Welt!' AS Nachricht ;

Für Oracle-Datenbanken , MySQL

WÄHLEN 'Hallo Welt!' VON dual ;

Für IBM DB2

WÄHLEN 'Hallo Welt!' VON SYSIBM . sysdummy1 ;

Für MSSQL , MySQL , PostgreSQL

WÄHLEN 'Hallo Welt!' ;

StarOffice Basic

 Unterhauptdruck „Hallo Welt!“ als unter

oder:

 sub HelloWeltAlternativ MsgBox "Hallo Welt!" als unter

Swift

println ( "Hallo Welt!" )

(Schnelle 1.0)

drucken ( "Hallo Welt!" )

(ab Swift 2.0)

Tcl

setzt "Hallo Welt!"

Tcl / Tk

Paket benötigt Tk
 Label .l - Text "Hallo Welt"
 Pack .l

XOTcl

proc hallo {
setzt "Hallo Welt!"
}

Turing

setzen "Hallo Welt!"

Unix-Shell

echo Hallo Welt!

Verilog

Modul hallo_welt ;
initial start
$ display ( "Hallo Welt!" ); # 10 $ beenden ; als Endmodul

VHDL

Entität HelloWorld ist
End- Entity HelloWorld ;
Architektur BHV von Hallo Welt Eis
beginnen
 HelloWorldProc : Prozess ist
 beginnen
Bericht „Hallo Welt!“ ; warte ; End - Prozess HelloWorldProc ; als Architektur bhv ;

Visual Basic Script

 MsgBox "Hallo Welt!"

Visual Basic .NET

Ausgabe in der Konsole:

Modul Modul1
 Sub Main ()
Konsole . WriteLine ( "Hallo Welt!" ) End- Sub- End- Modul

Ausgabe in einer Messagebox:

Klasse Hallo
 Sub HelloWelt
MsgBox ( "Hallo Welt!" ) Ende Sub End Klasse