Hello World
 
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern

Das Buch TheCeeProgrammingLanguage enthält einen Abschnitt, der erklärt, wie man ein einfaches Programm compiliert und ausführt. Das verwendete Programmbeispiel erzeugte die Ausgabe des Strings "Hello World". Sobald der Leser das zum Laufen gebracht hatte, konnte er dieses Grundprogramm beliebig abändern und mit dem Programmieren beginnen.

Viele SoftwareEntwickler gehen bei einem Einstieg in eine neue Programmiersprache so vor: Zuerst das Entwicklungssystem mit einem Minimalbeispiel in Betrieb nehmen, dann durch Abändern dieses Programmes mit dem eigentlichen Lernen und Programmieren beginnen.

Was ist ein gutes HelloWorld Programm? Bei einem HelloWorld Programm kommt es nicht darauf an, eine raffinierte Ausgabe-Funktion zu verwenden oder aufzuzeigen das die Sprache auch mit Strings umgehen kann. Vielmehr soll gezeigt werden, wie man sein erstes Programm in der neuen Sprache zum Laufen bekommt. Das etwas ausgegeben wird dient nur dazu um dem Programmierer zu zeigen, dass sein Programm ausgeführt wurde. Genau so gut könnte man eine Sounddatei abspielen. Ein Beispiel wie

#include <stdio.h>

int main() {
  printf("Hello World\n"); 
  return 0;
}

ist also noch nicht ausreichend. Erst durch eine Erklährung wie

Auf einem UNIX-System muss der folgende Code als File "hello.c" eingeben werden. Mit dem Befehl "cc hello.c" wird das Programm zu einem ausführbaren File "a.out" compiliert. Die Ausführung des Programmes erfolgt durch den Befehl "./a.out" und erzeugt den Output "Hello World" (siehe auch [HelloWorldInCee]).

hat der "echte" Anfänger eine Chance. Aber selbst das erscheint mir in der heutigen Zeit nicht ausreichend. Ich sehe schon den Programmieranfänger auf seinen Windows-Desktop starren, darüber nachdenkend wo er denn cc hello.c eingeben kann. Wenn wir Glück haben, kennt er die Eingabeaufforderung, aber wie groß wird dann die Enttäuschung sein wenn nur

C:\>cc hello.c
Der Befehl "cc" ist entweder falsch geschrieben oder
konnte nicht gefunden werden.

auf dem Bildschirm erscheint.

Ein vollständiges HelloWorld sollte folgende Informationen enthalten:

Weniger ist gar nichts. --hz

Inhaltsverzeichnis dieser Seite
ABAP - Hello World   
Ada - Hello World   
Assembler (TASM-DOS) - Hello World   
BASIC - Hello World   
Brainfuck - Hello World   
C - Hello World   
C++ - Hello World   
C# - Hello World   
D - Hello World   
EASY - Hello World   
Eiffel - Hello World    
Emacslisp - Hello World   
Factor - Hello World   
Forth - Hello World   
FORTRAN-77 - Hello World   
Haskell - Hello World   
Java - Hello World   
JScript - Hello World   
JSP - Hello World   
Lisp - Hello World   
LPC - Hello World   
Modula-2 - Hello World   
Modula-3 - Hello World   
NATURAL - Hello World   
Pascal - Hello World   
PEARL - Hello World   
Perl - Hello World   
Perl/Tk - Hello World   
PHP - Hello World   
PHP-GTK - Hello World   
Pike - Hello World   
Prolog - Hello World   
Python - Hello World   
RTA - RT-Assembler   
RTF - Rich Text Format   
Ruby - Hello World   
Shell - Hello World   
Smalltalk -- Hello World   
Tcl - Hello World   
Tcl/Tk - Hello World   
OpenVMS-DCL - Hello World   


ABAP - Hello World    

REPORT HalloWelt
WRITE: 'Hallo Welt'.

Ada - Hello World    

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
begin
   Put_Line("Hello World");
end Hello;

Assembler (TASM-DOS) - Hello World    

IDEAL
SEGMENT code BYTE
 Assume cs:code, ds:code,ss:code

    org 100h
    START:    jmp short run

        hello db 'Hello World!',0dh,0ah,'$'
    run:
              mov   ah,09h
              mov   dx, offset hello
              int   21h
              mov   ah, 4ch
              int   21h
ENDS
END START

BASIC - Hello World    

10 print "Hello World!"

Brainfuck - Hello World    

++++++++++[>++++++++++<-]>++++.---.+++++++..+++.
>++++[>+++++++++++<-]>.---¦---¦---¦---.[-]<<
++++++++.---¦---¦--.+++.---¦---.---¦---¦--.[-]
<+[>++++++++++<-]>.[-]<

C - Hello World    

#include <stdio.h>

int main() {
  printf("Hello World\n"); 
  return 0;
}

Auf einem UNIX-System muss der folgende Code als File "hello.c" eingeben werden. Mit dem Befehl "cc hello.c" wird das Programm zu einem ausführbaren File "a.out" compiliert. Die Ausführung des Programmes erfolgt durch den Befehl "a.out" und erzeugt den Output "Hello World" (siehe auch [HelloWorldInCee]).

C++ - Hello World    

#include <iostream>

int main() {
  std::cout << "Hello World" << std::endl;
}

(siehe auch [HelloWorldInCpp])

C# - Hello World    

using System;

class Hello {
  public static void Main() {
    Console.WriteLine("Hello World!");
  }
}

Wenn das obige Programm in einem Textfile "hello.cs" gespeichert ist, kann es mittels "csc hello.cs" zu einem ausführbaren EXE-File compiliert werden.

Anmerkung: Die Sprache C# bietet selber keine Möglichkeit, einen Text auszugeben. Dazu werden Klassen aus dem .NET Framework benötigt (wie die oben verwendete Klasse System.Console), die aber nicht zum Sprachumfang von C# gehören. Das gilt auch für viele andere Sprachen, wie C++, Java, Smalltalk usw. usf.

Klar - das ist kein Alleinstellungsmerkmal von C#. Aber im Gegensatz zu C# gehören bei C/C++ genormte Bibliotheksfunktionen, die die Ausgabe auf den Bildschirm oder in Dateien regeln, zum Sprachumfang.

D - Hello World    

import std.c.stdio;

void main() { 
	printf("Hello World\n"); 
}

EASY - Hello World    
module helloworld
/* http://www.tdbengine.org */
procedure Main
cgiclosebuffer
 cgiwriteln("content-type: text/html")
 cgiwriteln("")
 cgiwriteln("Hello World!")
endproc

Aufruf auf Kommandozeile zum Kompilieren: /bin/tdbengine helloworld.mod und im Browser zum ausführen /host/wwwroot/helloworld.prg

Eiffel - Hello World     

class HELLO

creation make

feature

  make is
      do
        print("Hello World")
        print("%N")
      end

end

Für SmallEiffel ist das sogar schon genug. Andere Eiffel-Umgebungen kommen nicht mit dem Eiffel-Quelltext aus, sondern wollen mehr sehen. Vor dem Übersetzen muss noch ein ACE (Assembly of Classes in Eiffel) in der Eiffel-ähnlichen Sprache Lace erstellt werden:

system HELLO root

   HELLO(root_cluster): "make"

cluster
   root_cluster: ".";
end

Emacslisp - Hello World    

(message "Hello, World!")

Factor - Hello World    

"Hello, World!" print

Forth - Hello World    

: hello ." Hello World " ;

FORTRAN-77 - Hello World    

      program hello

      write(*, 100)
      stop

 100  format('Hello World')
      end

Aber Vorsicht: Die Einrückung ist hier keine Geschmackssache, weil FORTRAN 77 keine formatfreie Sprache ist. Was in welcher Spalte steht ist nicht egal. Das FORTRAN 77-Programm könnte also auch so aussehen

      pro
     *gramhello

      write(*, 100)
      stop

 100  forma
     *t('Hello, World!')
      end

weil Leerzeichen nicht die wichtige Rolle wie in anderen Sprachen spielen, und wenn eine Anweisung nicht in eine Zeile passt, ein '*' in der Spalte 6 genügt, um eine Lochkarte als Folgekarte der vorangegangenen Karte zu markieren.

[Man beachte bitte, daß heutzutage alle gängigen FORTRAN Compiler auch formatfreie Eingabe akzeptieren.]

Haskell - Hello World    

module Main where 
main = putStrLn "Hello, World!\n"

Java - Hello World    

Auf der Console:

public class Hello {
  public static void main(String [] args) {
    System.out.println("Hello World!");
  }
}

Als Applet:

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

public class Hello extends Applet {
  public void paint(Graphics g) {
    g.drawString("Hello World!", 25, 50);
  }
}

Applet

Das obige Applet muss in einem File "Hello.java" gespeichert und zu einem "Hello.class" compiliert werden. Zur Ausführung legt man den class-File auf den Server gemeinsam mit einem HTML-File, der "<applet code="Hello" width=150 height=100></applet>" enthält, oder ruft "appletviewer Hello.html" auf, wobei "Hello.html" eine Datei ist, die das oben beschriebene Applet-Tag enthält.

Als Fenster
import java.awt.*;
import java.awt.event.*;

public class HelloWorld extends Frame implements ActionListener
{
  
 public static void main(String[] args)
  {
    new HelloWorld();
  }

  public HelloWorld()
  {
   addWindowListener( new WindowAdapter ()
    {
     public void windowClosing(WindowEvent e)
      {
	System.exit(0);
      }
    }
   );
	
   setLocation(360,260);
   setSize(300,200);
   setTitle("HelloWorld!");
   setResizable(false);
   setVisible(true);
  }
 
  public void paint(Graphics g)
  {
    g.drawString("Hello World!", 110, 110);
  }

  public void actionPerformed(ActionEvent arg0) 
  {
  }
}

Fenster

Wenn man das Fenster kompilieren will, muss man zuerst eine Datei "HelloWorld.java" erstellen. Diese öffnet man dann mit einem Texteditor und fügt den Code ein.

Dann wechselt man mit der Eingabeaufforderung in das Verzeichnis, in dem "HelloWorld.java" liegt und gibt folgendes ein: "javac HelloWorld.java".

Wenn der Java-Compiler javac nicht im Suchpfad liegt, sollte man dafür sorgen, dass der Suchpfad entsprechend erweitert wird, d. h. dass auch in dem Verzeichnis nach ausführbaren Dateien gesucht wird, in dem die Programme javac, java, javadoc, jdb usw. liegen.

Das Übersetzen kann einige Sekunden dauern, bei einem [P4 2.4 GHz 256 MB RAM WIN98SE?] z. B. ca. 2 sec.

Um das Programm auch auszuführen einfach (mit der Eingabebeaufforderung) in den Ordner wechseln in dem die Datei "HelloWorld.java" liegt und in dem von javac eine neue Datei "HelloWorld.class" erzeugt wurde. "java HelloWorld" eingeben und das war's.

JScript - Hello World    

<script language="JavaScript">
<!--
document.write("Hello World!")
//-->
</script

JSP - Hello World    

<% out.println("Hello World"); %>

Lisp - Hello World    

(princ  "Hello World")
(terpri)

In der REPL (read, evaluate, print loop) sollte das hier auch ausreichen

"Hello World"

verifiziert in RScheme.

LPC - Hello World    

void create() { write("Hello world\n"); }

Modula-2 - Hello World    

MODULE hello;

FROM InOut IMPORT WriteString, WriteLn;

BEGIN
        WriteString("Hello World"); 
        WriteLn;
END hello.

Modula-3 - Hello World    

MODULE Main;

IMPORT IO;

BEGIN
  IO.Put ("Hello World\n");
END Main.

NATURAL - Hello World    

PRINT 'Hello World'
END

alternativ geht natürlich auch:

WRITE 'Hello World'
END

Pascal - Hello World    

program hello(input, output);

begin
   writeln('Hello World');
end.   

PEARL - Hello World    

MODULE HELLOW;

SYSTEM;
   SCHIRM:  DIS <- SDVLS(2);

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

/* ... */
PUT 'Hello World' TO SCHIRM BY A, SKIP;
/* ... */

Perl - Hello World    

#!/usr/bin/perl
print "Hello World\n";

Die erste Zeile, der sogenannte "SheBang?", ist nur auf UNIX-Systemen und als Apache CGI notwendig. Der Pfad muss unter Umständen angepaßt werden, um dorthin zu zeigen, wo Perl existiert.

Perl/Tk - Hello World    

#!/usr/bin/perl -w

use strict;
use Tk;

my $main = new MainWindow;
$main->Label(-text => 'Hello World!'
             )->pack;
$main->Button(-text => 'Quit',
              -command => sub{exit}
              )->pack;
MainLoop;

PHP - Hello World    

<?php
    echo "Hello World\n";
?>

PHP-GTK - Hello World    

<?php
    dl( 'php_gtk.' . (strstr( PHP_OS, 'WIN') ? 'dll' : 'so'));

    $win = &new GtkWindow;
    $label = &new GtkLabel( 'Hello world');
    $button = &new GtkButton( 'Quit');
    $button->connect_object( 'clicked', array( 'Gtk', 'main_quit'));

    $vbox = &new GtkVBox;
    $vbox->pack_start( $label, true, true);
    $vbox->pack_start( $button, false, false);

    $win->add( $vbox);
    $win->show_all();

    Gtk::main();
?>

Pike - Hello World    
int main(){
    write("hello world\n");
}

Prolog - Hello World    

helloWorld :- writef("Hello World!").

Python - Hello World    

#!/usr/bin/env python
print "Hallo Welt"

Im interaktiven Modus reicht

"Hallo Welt"

RTA - RT-Assembler    

;
; hallo_world.rta
;
	_name	Hallo~World~...
	pause	Hallo~World!
	exit
	_end

RTF - Rich Text Format    

{\rtf1\ansi\deff0
{\fonttbl {\f0 Times New Roman;}}
\f0\fs60 Hello, World!
}

Ruby - Hello World    

ich@host> ruby -e 'puts "Hello World"'

#!/usr/bin/ruby
#
puts "Hello world!"

Shell - Hello World    

echo Hello World

Dürfte mit sämtlichen Shells so funktionieren. Einfachste Formulierungen in der Regel bei den Shells zu finden.

Smalltalk -- Hello World    

Transcript show: 'Hello, World!'; cr

Tcl - Hello World    

#!/bin/sh
# the next line restarts using tclsh
exec tclsh "$0" "$@"

puts "Hello, world"

Tcl/Tk - Hello World    

#!/bin/sh
# the next line restarts using wish
exec wish "$0" "$@"

button .hello -text "Hello, world" -command {
    puts stdout "Hello, world"; destroy .
}
pack .hello

OpenVMS-DCL - Hello World    

$ WRITE SYS$OUTPUT "Hello, world"


Siehe auch: WardsWiki:HelloWorld

/Diskussion


Noch ca. 200 "Hello World"-Programme in vielen Sprachen: http://www2.latech.edu/~acm/HelloWorld.shtml
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 14. Mai 2008 14:14 (diff))
Suchbegriff: gesucht wird
im Titel
im Text