Hello world
Un article de Wikipédia, l'encyclopédie libre.
Vous avez de 
En informatique, pour la démonstration rapide d'un langage de programmation (par exemple à but pédagogique) ou le test d'un compilateur, il est de tradition d'écrire un petit programme, aussi simple que possible, dont le seul but soit l'affichage à l'écran des mots hello world (bonjour le monde).
Certains sont étonnamment complexes, particulièrement dans un contexte d'interface graphique. D'autres sont très simples, particulièrement ceux qui utilisent un interpréteur de ligne de commande pour afficher le résultat. Dans plusieurs systèmes embarqués, le texte peut être envoyé sur une ou deux lignes d'un afficheur LCD (ou dans d'autres systèmes, une simple DEL peut se substituer à un hello world).
Alors que les petits programmes de test existaient depuis le début de la programmation, la tradition d'utiliser hello world comme message de test a été influencée par le livre The C Programming Language de Brian Kernighan et Dennis Ritchie. Le premier exemple de ce livre affiche hello, world (sans majuscule ni point final, mais avec une virgule et un retour à la ligne final). Le premier hello world dont Ritchie et Kernighan se souviennent provient d'un manuel d'apprentissage du langage B écrit par Kernighan [1].
Aujourd'hui on affiche plus souvent Hello world! comme une phrase, avec majuscule et point d'exclamation final.
[modifier] Exemples de programmes Hello world!
[modifier] ABC
WRITE "Hello world!"
[modifier] ActionScript
trace("Hello world!");
[modifier] Ada
with STANDARD_IO;
use STANDARD_IO;
procedure bonjour is
begin
Put("Hello world!");
end bonjour;
[modifier] Alma
Hello world!
[modifier] AmigaE
PROC main()
WriteF('Hello world!')
ENDPROC
[modifier] APL
'Hello world!'
(L'une des bases d'APL est que toute expression qui, après exécution, n'est pas affectée à une variable voit son contenu affiché au terminal)
[modifier] AppleScript
display dialog "Hello world!"
[modifier] ASP
<%
Response.Write("Hello World")
%>
[modifier] AspectJ
Main.java:
public class Main {
public static void main(String[] args){
}
}
HelloWorld.aj:
public aspect HelloWorld {
pointcut mainCall() : call(public static void *.main(String[] args));
before() : mainCall() {
System.out.println( "Hello world!" );
}
}
[modifier] Assembleur de Bytecode Java
Ce code fonctionne avec les assembleurs Jasmin et Oolong.
Les commentaires sont situés après un ';'
.class public Hello
.super java/lang/Object
; spécification du constructeur par défaut
.method public <init>();
; pousse la référence à l'objet courant sur la pile
aload_0
; appel statiquement lié aux contructeur de la classe de base
invokespecial java/lang/Object/<init>()V
return
.end method
.method public static main([java/lang/String;)V
.limit stack 2
; pousse la réf. à l'objet statique out de la classe System sur la pile
getstatic java/lang/System/out Ljava/io/PrintStream
; pousse la chaîne de caractère sur la pile
ldc "Hello world!"
; appel polymorphe
invokevirtual java/io/PrintStream/println(Ljava.lang.String;)V
return
.end method
[modifier] Assembleur x86 sous DOS
cseg segment assume cs:cseg, ds:cseg org 100h main proc jmp debut mess db 'Hello world!$' debut: mov dx, offset mess mov ah, 9 int 21h ret main endp cseg ends end main
[modifier] Assembleur x86, écrit pour le compilateur TASM sous DOS
.model small
.stack 100h
.data
bonjour db "Hello world!$"
.code
main proc
mov AX,@data
mov DS, AX
mov DX, offset bonjour
mov AX,0900h
int 21h
mov AX,4C00h
mov 21h
main endp
end main
[modifier] Assembleur x86, sous Linux, écrit pour le compilateur NASM
section .data
helloMsg: db 'Hello world!',10
helloSize: equ $-helloMsg
section .text
global _start
_start:
mov eax,4 ; Appel système "write" (sys_write)
mov ebx,1 ; File descriptor, 1 pour STDOUT (sortie standard)
mov ecx, helloMsg ; Adresse de la chaine a afficher
mov edx, helloSize ; Taille de la chaine
int 80h ; Execution de l'appel système
; Sortie du programme
mov eax,1 ; Appel système "exit"
mov ebx,0 ; Code de retour
int 80h
[modifier] Awk
BEGIN { print "Hello world!" }
[modifier] BASIC
10 PRINT "Hello world!" 20 END
Noter que les étiquettes (numéros devant les lignes) ne sont plus nécessaires dans les versions modernes (BBC BASIC for Windows, Quick Basic, Turbo Basic, QBasic, Visual Basic...). Elles ne sont plus utilisées que pour les instructions de contrôle de flux (les boucles et les sauts, notamment le GOTO et le GOSUB).
[modifier] BASH
echo 'Hello world'
[modifier] BCPL
GET "LIBHDR"
LET START () BE
$(
WRITES ("Hello world!*N")
$)
[modifier] BLISS
%TITLE 'hassan'
MODULE HELLO_WORLD (IDENT='V1.0', MAIN=HELLO_WORLD,
ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN
LIBRARY 'SYS$LIBRARY:STARLET';
EXTERNAL ROUTINE
LIB$PUT_OUTPUT;
GLOBAL ROUTINE HELLO_WORLD =
BEGIN
LIB$PUT_OUTPUT(%ASCID %STRING('Hello world!'))
END;
END
ELUDOM
[modifier] Brainfuck
++++++++[>+++++++++<-]>.>+++++++[<++++>-]<+.+++ ++++..+++.>++++[>++++++++<-]>.[-]<<++++++++.--- -----.+++.------.--------.>++++++++[->++++<]>+.
[modifier] C
#include <stdio.h>
int main(void)
{
printf("Hello world!\n");
getchar();
return 0;
}
int main(void)
{
puts("Hello world");
return 0;
}
[modifier] C (uniquement sous windows)
#include <windows.h>
int WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
{
MessageBox( NULL, "Hello world!\n", "", MB_OK );
return 0;
}
On peut aussi noter :
#include <stdio.h>
int main(void)
{
printf ("Hello, World !\n");
system("PAUSE");
return 0;
}
[modifier] C#
using System;
public class HelloWorld {
public static void Main () {
Console.WriteLine("Hello world!");
}
}
[modifier] C# (sous Windows)
using System.Windows.Forms;
public class HelloWorld
{
public static void Main() {
MessageBox.Show("Hello world!");
}
}
[modifier] C++
#include <iostream>
int main()
{
std::cout << "Hello world!" << std::endl;
return 0;
}
ou
#include <iostream>
using namespace std;
int main()
{
cout << "Hello, world!" << endl;
return 0;
}
[modifier] Casio (calculatrices graphiques de la gamme «Graph xx»)
"Hello world!"
[modifier] CIL
.method public static void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello world!."
call void [mscorlib]System.Console::WriteLine(string)
ret
}
[modifier] Clean
module hello Start :: String Start = "Hello world!"
[modifier] CLIST
PROC 0 WRITE Hello world!
[modifier] COBOL
IDENTIFICATION DIVISION. PROGRAM-ID. HELLO-WORLD. ENVIRONMENT DIVISION. DATA DIVISION. PROCEDURE DIVISION. DISPLAY "Hello world!". STOP RUN.
[modifier] Common Lisp
(princ "Hello world!")
[modifier] D
import std.stdio;
int main (char[][] args)
{
printf ("Hello world!\n");
}
[modifier] Delphi
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs;
type
TForm1 = class(TForm)
procedure FormActivate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.FormActivate(Sender: TObject);
begin
ShowMessage('Hello world');
end;
end.
[modifier] Dialog/Xdialog
dialog --title 'Hello world!' --ok-label 'OK' --msgbox 'Hello world!' 0 0 Xdialog --title 'Hello world!' --ok-label 'OK' --msgbox 'Hello world!' 0 0 kdialog --title 'Hello world!' --msgbox 'Hello world!' 0 0
[modifier] DCL batch
$ write sys$output "Hello world!"
[modifier] Ed et Ex (Ed extendu)
a Hello world! . p
ou comme ceci:
echo -e 'a\nHello world!\n.\np'|ed echo -e 'a\nHello world!\n.\np'|ex
[modifier] Eiffel
class HELLO_WORLD
creation
make
feature
make is
do
io.put_string("Hello world!%N")
end -- make
end -- class HELLO_WORLD
[modifier] Erlang
-module(hello).
-export([hello_world/0]).
hello_world() -> io:fwrite("Hello world!\n").
[modifier] EUPHORIA
puts(1, "Hello world!")
[modifier] F#
type data =
{ first: string;
second: string; }
let myData =
{ first="Hello";
second="world"; }
let _ =
print_string myData.first;
print_string " ";
print_string myData.second;
print_newline()
"ou" comme ceci :
print_endline "Hello world"
[modifier] Forte TOOL
begin TOOL HelloWorld;
includes Framework;
HAS PROPERTY IsLibrary = FALSE;
forward Hello;
-- START CLASS DEFINITIONS
class Hello inherits from Framework.Object
has public method Init;
has property
shared=(allow=off, override=on);
transactional=(allow=off, override=on);
monitored=(allow=off, override=on);
distributed=(allow=off, override=on);
end class;
-- END CLASS DEFINITIONS
-- START METHOD DEFINITIONS
------------------------------------------------------------
method Hello.Init
begin
super.Init();
task.Part.LogMgr.PutLine('Hello world!');
end method;
-- END METHOD DEFINITIONS
HAS PROPERTY
CompatibilityLevel = 0;
ProjectType = APPLICATION;
Restricted = FALSE;
MultiThreaded = TRUE;
Internal = FALSE;
LibraryName = 'hellowor';
StartingMethod = (class = Hello, method = Init);
end HelloWorld;
[modifier] Forth
." Hello world!" CR
[modifier] Fortran (ANSI 77)
PROGRAM BONJOUR WRITE (*,*) 'Hello world!' END
[modifier] Frink
println["Hello world!"]
[modifier] Gambas
PUBLIC SUB Main()
Print "Hello world!"
END
[modifier] Game Maker
draw_text(x, y,"Hello world!");
[modifier] Gnuplot
#!/usr/bin/gnuplot print "hello world"
[modifier] GOTO++
GOTOPRINTDUTEXTE() ; «Hello world!»
[modifier] Groovy
print "hello world"
[modifier] Haskell
module HelloWorld (main) where main = putStrLn "Hello world!"
[modifier] Heron
program HelloWorld;
functions {
_main() {
String("Hello world!") |> GetStdOut();
}
}
end
[modifier] HP-41 et HP-42S
(calculatrice Hewlett-Packard alphanumérique)
01 LBLTHELLO 02 THELLO, WORLD 03 PROMPT
[modifier] HP-40 G
(calculatrice Hewlett-Packard)
DISP 1;"HELLO WORLD !": FREEZE:
[modifier] XHTML 1.0 Strict
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
<head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" />
<title>Dire «Hello world!» en XHTML 1.0 Strict</title>
</head>
<body>
<p>Hello world!</p>
</body>
</html>
[modifier] ICON
procedure main()
write("Hello World !")
end
[modifier] Iptscrae
ON ENTER {
"Hello " "world!" & SAY
}
[modifier] Io
"Hello world!" print
ou
write("Hello world!\n")
[modifier] Java
Note: Le fichier doit absolument s'appeler HelloWorld.java (même nom que la classe)
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
Note: Pour utiliser cette façon on doit importé javax.swing.
public class HelloWorld
{
public static void main(String[] args)
{
JOptionPane.ShowMessageDialog(null,"Hello world!");
}
}
[modifier] JavaScript / HTML DOM
En javascript :
document.write("Hello world!");
Cela peut être inclus dans du HTML de cette manière :
<script type="text/javascript" language="javascript">
document.write("Hello world!");
</script>
[modifier] Kogut
WriteLine "Hello world!"
[modifier] LaTeX
\documentclass{article}
\begin{document}
Hello world!
\end{document}
[modifier] Linotte
Livre : HelloWorld Paragraphe : Affichage Les rôles : exemple est un texte avec "Hello," Les actions : tu affiches l' exemple tu affiches "World !"
[modifier] Lisaac
section HEADER
+ name := HELLO_WORLD;
- category := MACRO;
section INHERIT
- parent_object:OBJECT := OBJECT;
section PUBLIC
- make <-
(
"Hello world !\n".print;
);
[modifier] Lisp
(write-line "Hello World!")
[modifier] Logo
print [Hello world!]
ou
pr [Hello world!]
en mswlogo seulement
messagebox [Hi] [Hello world!]
[modifier] Lua
print "Hello world!"
[modifier] MatLab
disp('Hello world')
[modifier] mIRC Script
echo -a Hello World!
[modifier] M (MUMPS)
W "Hello world!"
[modifier] Modula-2
MODULE Hello;
FROM Terminal2 IMPORT WriteLn; WriteString;
BEGIN
WriteString("Hello world!");
WriteLn;
END Hello;
[modifier] MS-DOS batch
(avec l'interpreteur standard command.com. Le symbole @ est optionel et évite au système de répéter la commande avant de l'exécuter. Le symbole @ doit être enlevé avec les versions de MS-DOS antérieures au 5.0.)
@echo Hello world!
[modifier] MUF
: main
me @ "Hello world!" notify
;
[modifier] Objective C
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc]] init];
NSLog(@"Hello world!");
[pool release];
return 0;
}
[modifier] Ocaml
print_string "Hello world!\n"
ou
print_endline "Hello world"
[modifier] Octave
#!/usr/bin/octave
disp("hello world")
[modifier] OPL
PROC hello:
PRINT "Hello world!"
ENDP
[modifier] OPS5
(object-class request
^action)
(startup
(strategy MEA)
(make request ^action hello)
)
(rule hello
(request ^action hello)
-->
(write |Hello world!| (crlf))
)
[modifier] Pascal
program Bonjour;
begin
WriteLn('Hello world!');
end.
[modifier] Perl
#!usr/bin/perl print "Hello world!\n";
[modifier] Perl 6
say "Hello world";
[modifier] PHP
<?php echo "Hello world!"; // On peut aussi utiliser les guillements simples echo 'Hello World!'; ?>
ou
<?php
print ("Hello world!");
// On peut aussi utiliser les guillements simples
print ('Hello world!');
?>
[modifier] PlanFacile
#start{0}#message{Hello world !}
ou pour les amateurs d'IOCCC
#define{d}{r}#define{r}{H#2#1#H#define{r}{#1#1}}
#H{#h{#r{#r{#e}#define{H}{#l}}{e}}{#define{d}{# }!}
{#h{#l}{#o}{#w{w}}#e#define{h}{#3#define{o}{r}#1#2}
#w{d}{#d}#define{w}{#0}}#define{h}{#1#d#3#2}#define{e}
{l}}#start{0}#define{H}{#foot{#1#define{l}{o}}}
[modifier] PL/I
hello: procedure options(main);
display ('Hello world!');
/* Ou, variante : put skip list ('Hello world!'); */
end hello;
[modifier] POP-11
'Hello world!' =>
[modifier] POV-Ray
#include "colors.inc"
camera {
location <3, 1, -10>
look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
ttf "timrom.ttf" "Hello world!" 1, 0
pigment { White }
}
[modifier] Postscript
%!PS 100 /Helvetica findfont exch scalefont setfont 10 300 moveto (Hello, world !) show showpage
[modifier] Prolog
write('Hello world!'), nl.
[modifier] PureBasic
OpenConsole()
PrintN("Hello World!")
[modifier] Python
print "Hello world!"
[modifier] Rebol
print "Hello world!"
[modifier] REXX, NetRexx, et Object REXX
say "Hello world!"
ou:
say 'Hello world!'
[modifier] RPG
[modifier] Syntaxe libre
/FREE
DSPLY 'Hello, world!';
*InLR = *On;
/END-FREE
[modifier] Syntaxe traditionnelle
Avec cette syntaxe, une constante doit être utilisée car seules les positions 12 à 25 peuvent être utilisées pour contenir le message.
d TestMessage c Const( 'Hello, world!' )
c TestMessage DSPLY
c EVAL *InLR = *On
[modifier] RPL
(Sur les calculatrices Hewlett-Packard HP-28, HP-48 et HP-49.)
<<
CLLCD
"Hello world!" 1 DISP
0 WAIT
DROP
>>
[modifier] Ruby
puts "Hello world!"
[modifier] Sather
class HELLO_WORLD is
main is
#OUT+"Hello world!\n";
end;
end;
[modifier] Scala
object HelloWorld with Application {
Console.println("Hello world!");
}
[modifier] Scheme
(display "Hello world!") (newline)
[modifier] sed
(note: requiert au moins une ligne en entrée)
sed -ne '1s/.*/Hello world!/p'
[modifier] Seed7
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln("Hello world!");
end func;
[modifier] Self
'Hello world!' print.
[modifier] Shell UNIX
#!/bin/sh echo "Hello world!"
[modifier] Simula
BEGIN
outtext("Hello World!");
outimage;
END;
[modifier] Silscript
Intr-aff-{
aff[Hello world!];
}Stop-aff-
[modifier] Smalltalk
Transcript show: 'Hello world!'
Ou
self inform: 'Hello world!'
[modifier] SML
print "Hello world!\n";
[modifier] SNOBOL
OUTPUT = "Hello world!"
END
[modifier] SQL
create table MESSAGE (TEXT char(15));
insert into MESSAGE (TEXT) values ('Hello world!');
select TEXT from MESSAGE;
drop table MESSAGE;
Ou (ex : en Oracle)
select 'Hello world!' from dual;
Ou (ex en: MySQL )
select 'Hello world!';
Ou, plus simplement
print 'Hello world!.'
Ou (pour le KB-SQL)
select Null from DATA_DICTIONARY.SQL_QUERY FOOTER or HEADER or DETAIL or FINAL event write "Hello world!"
[modifier] STARLET
RACINE: HELLO_WORLD.
NOTIONS:
HELLO_WORLD : ecrire("Hello world!").
[modifier] TACL
#OUTPUT Hello world!
[modifier] Tcl
puts "Hello world!"
[modifier] Tcl/Tk
pack [button .b -text "Hello world!" -command exit]
[modifier] Turing
put "Hello world!"
[modifier] TSQL
Declare @Output varchar(16)
Set @Output='Hello world!'
Select @Output
ou, variation plus simple:
Select 'Hello world!'
Print 'Hello world!'
[modifier] TI-Basic
Ti 80 à Ti 92 :
:Disp "Hello world!"
ou
:Output(X,Y,"Hello world!")
Où X représente la ligne et Y la colonne.
[modifier] Verilog
module main;
initial
begin
$display("Hello, world");
$finish ;
end
endmodule
[modifier] VHDL
use std.textio.all;
ENTITY hello IS
END ENTITY hello;
ARCHITECTURE Wiki OF hello IS
CONSTANT message : string := "hello world";
BEGIN
PROCESS
variable L: line;
BEGIN
write(L, message);
writeline(output, L);
wait;
END PROCESS;
END ARCHITECTURE Wiki;
[modifier] VB ou Visual Basic
Sub Main()
MsgBox("Hello world!")
End Sub
[modifier] Visual DialogScript 2,3,4 et 5
Title Hello World! Info Hello World!
[modifier] Liens externes
- 99 Bottles of Beer (Site présentant un programme simple écrit en plus de 900 langages différents)
