Ouvrir le menu principal

Liste de programmes Hello world

page de liste de Wikipédia
Article général Pour un article plus général, voir Hello world.
Programme en Piet "Hello World"
Programme en Piet "Hello World"

Voici une liste non exhaustive de codes pour effectuer le programme Hello world.

4e DimensionModifier

ALERTE("Hello, world!")

ABCModifier

WRITE "Hello, world!"

ABAP (langage SAP)Modifier

WRITE "Hello, world!".

ActionScript 3.0Modifier

En Flex dans une fenêtre alerte :

Alert.show("Hello, world!");

AdaModifier

with Ada.Text_IO;
use Ada.Text_IO;

procedure Bonjour is
begin -- Bonjour
    Put("Hello, world!");
end Bonjour;

APLModifier

'Hello, world!'

AppleScriptModifier

display dialog "Hello, world!"

ASP et ASP.NETModifier

<%
Response.Write("Hello, world!")
%>

AspectJModifier

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!" );
    }
}

Assembleur de Bytecode JavaModifier

Ce code fonctionne avec les assembleurs Jasmin et Oolong.

.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 constructeurs 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ères sur la pile
    ldc "Hello, world!" 
    ; appel polymorphe
    invokevirtual java/io/PrintStream/println(Ljava.lang.String;)V
    return
.end method

Assembleur x86Modifier

Assembleur x86 sous DOSModifier

cseg    segment
        assume  cs:cseg, ds:cseg
        org     100h	
main    proc	
        mov     dx, offset Message
        mov     ah, 9   ; Fonction DOS : afficher une chaîne.
        int     21h     ; Appel à MS-DOS
        ret             ; Fin du programme COM
main    endp

Message db      "Hello, world!$"
	
cseg    ends
        end     main

Assembleur x86, écrit pour l'assembleur TASM sous DOSModifier

 .model small
 
 .stack 100h
 
 .data
    bonjour  db  "Hello, world!$"
 
 .code
    main  proc
        mov  AX,@data
        mov  DS, AX
        mov  DX, offset bonjour
        mov  AH,09h
        int  21h
        mov  AX,4C00h
        int  21h
    main endp
 end main

Assembleur x86, sous Linux, écrit pour l'assembleur NASMModifier

 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 chaîne a afficher
        mov edx, helloSize    ; Taille de la chaîne
        int 80h               ; Exécution de l'appel système
                              ; Sortie du programme
        mov eax,1             ; Appel système "exit"
        mov ebx,0             ; Code de retour
        int 80h

Assembleur x86 écrit pour l'assembleur FASMModifier

org 100h
mov dx, message
mov ah, 09h
int 21h

; Les quatre lignes suivantes servent à attendre qu'une touche soit frappée
; avant de quitter le programme normalement.
; Elles peuvent donc être exclues du programme,
; à ceci près que la visualisation du résultat sera impossible,
; la fenêtre de console se refermant trop vite.
xor ah, ah
int 16h
mov ax, 4c00h
int 21h

message db "Hello, world!$"

Assembleur x86 écrit pour l'assembleur MASMModifier

.386
.MODEL flat, stdcall
OPTION CASEMAP: none

Include kernel32.inc
Include masm32.inc

Includelib kernel32.lib
Includelib masm32.lib

.data													
HelloWorld  db   "Hello, world!", 0

.data?
WaitBufer   db 10 dup(?)

.code							
Start :
invoke StdOut, addr HelloWorld
invoke StdIn, addr WaitBufer, 1
invoke ExitProcess, 0

End Start

AutoHotkeyModifier

MsgBox % "Hello, world!"

AutoItModifier

MsgBox(0, "Hello, world!", "Hello, world!")

AwkModifier

#!/usr/bin/awk -f
END{ print "Hello, world!" }

BASICModifier

10 PRINT "Hello, world!"
20 END 'Le END n'est pas indispensable

Les étiquettes (numéros devant les lignes) ne sont plus nécessaires dans les versions modernes (BBC BASIC for Windows, QuickBasic, 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).

BashModifier

#!/bin/bash
echo 'Hello, world!'

BatchModifier

echo Hello, world!

BCPLModifier

GET "LIBHDR"
 
LET START () BE
$(
   WRITES ("Hello, world!*N")
$)

BefungeModifier

<q_,#! #:<"Hello, world!"a

BrainfuckModifier

préparation
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
écrit "Hello "
>++. >+. +++++++. . +++. >++.
écrit "World!" et passe à la ligne
<<+++++++++++++++. >. +++. ------. --------. >+. >.

Même code sans aucun commentaire :

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

CModifier

Exemple classique donné dans The C Programming Language de Brian W. Kernighan et Dennis M. Ritchie :

#include <stdio.h>

main()
{
    printf("hello, world\n");
}

C# (en Console)Modifier

 using System;

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

C# (Application Windows)Modifier

 using System.Windows.Forms;

 public class HelloWorld
 {
    public static void Main() {
       MessageBox.Show("Hello, world!");
    }
 }

Voir Windows Forms.

C++Modifier

Voici l'exemple de Hello world donné dans The C++ Programming Language, Third Edition de Bjarne Stroustrup :

#include <iostream>
 
int main()
{
    std::cout << "Hello, new world!\n";
}

C++/CLIModifier

using namespace System;

int main(array<System::String ^> ^args)
{
    Console::WriteLine(L"Hello, world");
    return 0;
}

CamlModifier

print_endline "Hello, world!";;

Casio (calculatrices graphiques de la gamme « Graph xx »)Modifier

"Hello, world!"

ou :

Locate 1,1,"Hello, world!"

ou encore :

Text 1,1,"Hello, world!"

CeylonModifier

void hello() {
  print("Hello, world!");
}


CILModifier

.method public static void Main() cil managed
{
    .entrypoint
    .maxstack 8
    ldstr "Hello, world!"
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}

CLISTModifier

PROC 0
WRITE Hello, world!

COBOLModifier

      IDENTIFICATION DIVISION.
      PROGRAM-ID. HELLO-WORLD.

      ENVIRONMENT DIVISION.

      DATA DIVISION.

      PROCEDURE DIVISION.
          DISPLAY "Hello, world!".
          STOP RUN.

Dans les versions modernes du langage, le programme se simplifie ainsi (la suppression du point sur l'avant-dernière ligne n'est pas une innovation) :

      IDENTIFICATION DIVISION.
      PROGRAM-ID. HELLO-WORLD.

      PROCEDURE DIVISION.
          DISPLAY "Hello, world!"
          STOP RUN.

CoffeeScriptModifier

alert("Hello, world!")

Ou bien :

alert "Hello, world!"

Common LispModifier

(princ "Hello, world!")

CrystalModifier

puts "Hello, world!"

DModifier

import std.stdio;

void main ()
{
    writeln("Hello, world!");
}

Dark basicModifier

 print "Hello, world"

DartModifier

main() {
  print('Hello, world!');
}

DelphiModifier

 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.

ou en console :

program hello_world;

{$APPTYPE CONSOLE}

uses
  SysUtils;

begin
  Writeln('Hello, world!');
  Readln;
end.

Dialog/XdialogModifier

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

DCL batchModifier

$ write sys$output "Hello, world!"

ed et ex (Ed extended)Modifier

a
Hello, world!
.
p

ou comme ceci:

echo -e 'a\nHello, world!\n.\np'|ed
echo -e 'a\nHello, world!\n.\np'|ex

EiffelModifier

class HELLO_WORLD
 
create
     execute
 
feature {NONE} -- Initialization

    execute is
         -- Execute Hello World !
         do
             io.put_string("Hello, world!%N")
         end
 
end

ErlangModifier

-module(hello).
-export([hello_world/0]).

hello_world() -> io:fwrite("Hello, world!\n").

EUPHORIAModifier

puts(1, "Hello, world!")

F#Modifier

printfn "Hello, world!"

ForthModifier

." Hello, world!" CR

Fortran (ANSI 77)Modifier

 PROGRAM BONJOUR
 WRITE (*,*) 'Hello, world!'
 END

Langage FrinkModifier

println["Hello, world!"]

FSProgModifier

console (show)
cWrite (Hello world{em})
cExec (PAUSE>NUL)

ou, pour afficher un message :

message(Hello world{em},Hello world{em},0)

GambasModifier

   Public Sub Main()
 
     Print "Hello, world!"
 
   End

GML (Game Maker Language)Modifier

draw_text(x, y,"Hello, world!");

ou, pour afficher un message:

show_message("Hello, world!");

GnuplotModifier

 #! /usr/bin/gnuplot
 print "Hello, world!"

GoModifier

package main

import "fmt"

func main() {
   fmt.Println("Hello, world!")
}

GrailsModifier

   class HelloWorldController {
        def index = {render "Hello, world!" }
   }

GraphvizModifier

echo "digraph G {Hello->World}" | dot -Tpng >hello.png

GroovyModifier

print "Hello, world!"

HaskellModifier

   module HelloWorld (main) where
 
   main = putStrLn "Hello, world!"

HaxeModifier

class Test {
    static function main() {
        trace("Hello, world!");
    }
}

HopModifier

(define-service (hello-world)
  (<HTML>
     (<HEAD>
	(<TITLE> "Hello, world"))
     (<BODY>
	"Hello, world!")))

HP-41 et HP-42SModifier

(calculatrice Hewlett-Packard alphanumérique)

 
   01 LBLTHELLO
   02 THELLO, WORLD
   03 PROMPT 

 

HP-40 GModifier

(calculatrice Hewlett-Packard)

DISP 1;"HELLO WORLD !":
FREEZE:

HP PPL (en) (Prime Programming Language, langage de programmation Prime)Modifier

(calculatrice HP Prime graphing calculator (en))

EXPORT Hello_world()
BEGIN
  PRINT("Hello, world!")
END;

Ou, pour un message :

EXPORT Hello_world()
BEGIN
  MSGBOX("Hello, world!")
END;

HQ9+Modifier

H

HTMLModifier

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<title>Hello, world!</title>
<p>Hello, world!

HTML5Modifier

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Hello, world!</title>
    </head>
    <body>
        <p>Hello, world!</p>
    </body>
</html>

XHTML 1.0 StrictModifier

<!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="application/xhtml+xml; charset=utf-8" />
		<title>Afficher «Hello world» en XHTML 1.0 Strict</title>
	</head>
 
	<body>
		<p>Hello, world!</p>
	</body>
</html>

ICONModifier

procedure main()
    write("Hello, world!")
end

Inform 6Modifier

[ Main;
	"Hello, world!";
];

Inform 7Modifier

"Hello World" by "Anonymous"

Earth is a room. The description of Earth is "Hello, world!"

When play begins:
	say "Bonjour tout le monde !"

INTERCALModifier

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

IptscraeModifier

   ON ENTER {
       "Hello, " "world!" & SAY
   }

IoModifier

"Hello, world!" print

ou

write("Hello, world!\n")

JModifier

'Hello, world!'

JavaModifier

Exemple avec les fonctions de basesModifier

Voici l'exemple avec les fonctions les plus basiques :

/* Affichage console */
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!"); 
    }
}

Exemple avec la bibliothèque SwingModifier

Voici un exemple avec la bibliothèque graphique Swing :

/* Affichage graphique */
public class HelloWorld {
    public static void main(String[] args) {
        javax.swing.JOptionPane.showMessageDialog(null, "Hello, world!");
    }
}

Exemple pour un appletModifier

Voici un exemple pour faire un applet, avec la bibliothèque graphique awt :

import java.applet.Applet;
import java.awt.Graphics;

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

JavaScriptModifier

En javascript :

alert("Hello, world!");

ou

console.log("Hello, world!");

Ce code peut être inclus dans du HTML de cette manière :

<script>
alert("Hello, world!");
</script>

Exemple utilisant le DHTML :

document.writeln("Hello, world!");

Exemple utilisant jQuery :

$(function() {
    $("body").html("Hello, world!");
});

JSPModifier

<% out.println("Hello, world!"); %>

JuliaModifier

println("Hello, world!")

KogutModifier

WriteLine "Hello, world!"

KotlinModifier

fun main(args : Array<String>) { 
  println("Hello, world!") 
}

Langage machineModifier

Pour x86, obtenu par compilation d'assembleur FASM

  • en binaire :
10111010 00010000
00000001 10110100
00001001 11001101
00100001 00110000
11100100 11001101
00010110 10111000
00000000 01001100
11001101 00100001
01001000 01100101  (he)
01101100 01101100  (ll)
01101111 00100000  (o )
01010111 01101111  (wo)
01110010 01101100  (rl)
01100100 00100001  (d!)
00100100           ($)
  • en hexadécimal :
BA 10 01 B4 09 CD 21 30 E4 CD 16 B8 00 4C CD 21 48 65 6C 6C 6F 20 57 6F 72 6C 64 21 24

LaTeXModifier

    \documentclass{minimal}
    \begin{document}
    Hello, world!
    \end{document}

Lingo pour Director 8.5 et plusModifier

   put "Hello, world!"

ou

   mbtext = member(#text).new()
   mbtext.text = "Hello, world!"

LinotteModifier

Hello World :
 t <- "Hello, world!"
 début
   affiche t

LisaacModifier

Section Header
  
  + name        := HELLO_WORLD;

Section Public
  - main <-
  ( 
    "Hello, world!".println;
  );

LispModifier

(write-line "Hello, world!")

Modifier

   print [Hello, world!]

ou

   pr [Hello, world!]

en mswlogo seulement

   messagebox [Hi] [Hello, world!]

LOLCODEModifier

   HAI
   CAN HAS STDIO?
   VISIBLE "HELLO, WORLD!"
   KTHXBYE

LSL (Linden Scripting Language)Modifier

 default
   {state_entry()                       //(événement) Lorsque le Script est réinitialisé
      {llSay(0, "Hello, world!");}      //(fonction) dit "Hello, world!" sur le channel 0
   touch_start(integer total_number)    //(événement) Lorsque l'objet contenant le Script est touché
      {llSay(0, "Touched.");}           //(fonction) dit "Hello, world!" sur le channel 0
   }

LuaModifier

print("Hello, world!")

Lua sur PSPModifier

	screen:print(00,10,"Hello, world", 255,0,0)

MalbolgeModifier

 (=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
 hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCBA@98\6543W10/.R,+O<

MATLABModifier

disp('Hello, world!');

ou

fprintf('Hello, world\n');

METAFONTModifier

message "Hello, world!";
bye

mIRC ScriptModifier

echo -a 'Hello, world!'

M (MUMPS)Modifier

   W "Hello, world!"

Modula-2Modifier

   MODULE Hello;
 
   FROM Terminal2 IMPORT WriteLn, WriteString;
 
   BEGIN
      WriteString("Hello, world!");
      WriteLn;
   END Hello.

MS-DOS batchModifier

Utilisé avec l’interpréteur standard command.com. Le symbole « @ » est optionnel 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!
     pause

MXMLModifier

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	<mx:Label text="Hello, world!"/>
</mx:Application>

NimModifier

echo "Hello, world!"

Node.jsModifier

Exemple d'implémentation sous forme de serveur web :

1 const { createServer } = require('http');
2 
3 //Creation du serveur
4 const server = createServer((request, response) => {
5     response.writeHead(200, {'Content-Type': 'text/plain'});
6     response.end('Hello World\n');
7 });
8 
9 server.listen(3000, () => console.log(`Adresse du serveur : http://localhost:3000`));

NSISModifier

Name "Hello, world!"
OutFile "helloworld.exe"

Section .main
; En tant qu'action courante
DetailPrint "Hello, world!"

; Sur une boîte de dialogue
MessageBox MB_OK "Hello, world!"
SectionEnd

Objective CModifier

#import <Foundation/Foundation.h>

int main () 
{
    NSLog(@"Hello, world!");
    return 0;
}

OCamlModifier

let _ =
  print_string "Hello, world!\n";
  exit 0

OctaveModifier

#!/usr/bin/octave
disp("Hello, world!")

Ook!Modifier

Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook?

OpenLaszloModifier

<canvas>
    <text>Hello, world!</text>
</canvas>

OPLModifier

   PROC hello:
     PRINT "Hello, world!"
   ENDP

OPS5Modifier

(object-class request
         ^action)

(startup
   (strategy MEA)
   (make request ^action hello)
)

(rule hello
   (request ^action hello)
   -->
     (write |Hello, world!| (crlf))
)

OzModifier

{Browse 'Hello, world!'}

PascalModifier

PROGRAM salutation; // Facultatif
BEGIN
    writeln('Hello, world!');
    readln; // Nécessaire pour marquer une pause à la fin de l'affichage, à défaut le programme termine.
END.

PawnModifier

#include <console>

main()
{
    print("Hello, world!\n");
}

PDFModifier

%PDF-1.3
1 0 obj
  << /Type /Catalog
     /Outlines 2 0 R
     /Pages 3 0 R
  >>
endobj

2 0 obj
  << /Type /Outlines
     /Count 0
  >>
endobj

3 0 obj
  << /Type /Pages
     /Kids [4 0 R]
     /Count 1
  >>
endobj

4 0 obj
  << /Type /Page
     /Parent 3 0 R
     /MediaBox [0 0 612 792]
     /Contents 5 0 R
     /Resources << /ProcSet 6 0 R
                   /Font << /F1 7 0 R >>
                >>
>>
endobj

5 0 obj
  << /Length 73 >>
stream
  BT
    /F1 24 Tf
    100 100 Td
    (Hello World) Tj
  ET
endstream
endobj

6 0 obj
  [/PDF /Text]
endobj

7 0 obj
  << /Type /Font
     /Subtype /Type1
     /Name /F1
     /BaseFont /Helvetica
     /Encoding /MacRomanEncoding
  >>
endobj

xref
0 8
0000000000 65535 f
0000000009 00000 n
0000000074 00000 n
0000000120 00000 n
0000000179 00000 n
0000000364 00000 n
0000000466 00000 n
0000000496 00000 n

trailer
  << /Size 8
     /Root 1 0 R
  >>
startxref
625
%%EOF

PerlModifier

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

Perl 6Modifier

Sur les versions récentes de perl, l'instruction print avec le saut de ligne ("\n") terminal peut être remplacé par un simple say

say "Hello, world!";

PharoModifier

In a Playground
'Hello, world!' asMorph openInWorld

PHPModifier

<?php
 echo "Hello, world!";

 // On peut aussi utiliser les guillemets simples
 echo 'Hello, world!';
?>

ou

<?php
 print ("Hello, world!");
?>

ou (version printf() du c)

<?php
printf("%s %s","Hello,","world!");
?>

Ou encore en version raccourcie (supporté si short_open_tag est activé)

<?="Hello, world!"?>

PietModifier

 

PlanFacileModifier

#start{0}#message{Hello, world!}

PL/IModifier

hello: procedure options(main);
       display ('Hello, world!');
       /* Ou, variante : put skip list ('Hello, world!'); */
       end hello;

PL/SQLModifier

    SET SERVEROUTPUT ON
    BEGIN
    DBMS_OUTPUT.PUT_LINE('Hello, world!');
    END;

PL/pgSQLModifier

CREATE FUNCTION hello_world() RETURNS VOID AS $$
BEGIN
    RAISE NOTICE 'Hello, world!';
END
$$ LANGUAGE 'plpgsql' VOLATILE;

POP-11Modifier

'Hello, world!' =>

POV-RayModifier

#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 }
}

Ce qui donnera :

 

PostScriptModifier

%!PS
/Helvetica 100 selectfont
10 300 moveto
(Hello, world!) show
showpage

PowerShellModifier

Write-Host "Hello, world!"

PROC (langage de commande Pick)Modifier

001 PQ
002 C Affiche 'Hello, world!' à l'écran
003 OHello, world!
004 X

ProcessingModifier

Dans une consoleModifier

println("Hello, world!");

Dans une interface graphiqueModifier

text("Hello, world!", 10, 10);
/* Les nombres en 2e et 3e paramètres sont les coordonnées, où se placera le début du texte */

Progress 4GLModifier

 DISPLAY "Hello, world!".


PrologModifier

:- write('Hello, world!'), nl.

PureBasicModifier

    OpenConsole()
    PrintN("Hello, world!")
;ou en mode fenêtré

MessageRequester("Titre","Hello, world!")

Pure DataModifier

 

PythonModifier

print "Hello, world!"

ou depuis version 3.0:

print('Hello, world!')

ou graphique:

try:
    import Tkinter as Tk
except ImportError:
    import tkinter as Tk  # Pour Python 3.x

root = Tk.Tk("Hello, world!")
Tk.Label(root, text="Hello world!").pack()
root.mainloop()

RModifier

cat("Hello, world!\n")

ou:

print("Hello, world!")

RebolModifier

print "Hello, world!"

ReiaModifier

"Hello, world!".puts()

REXX, NetRexx, et Object REXXModifier

say "Hello, world!"

ou:

say 'Hello, world!'

RockstarModifier

Say "Hello, world!"

RPGModifier

Syntaxe libreModifier

      /FREE

          DSPLY 'Hello, world!';

          *InLR = *On;

      /END-FREE 

Syntaxe traditionnelleModifier

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


RPLModifier

(Sur les calculatrices Hewlett-Packard HP-28, HP-48 et HP-49.)

   <<
     CLLCD
     "Hello world!" 1 DISP
     0 WAIT
     DROP
   >>

RubyModifier

puts "Hello, world!"

Ruby on RailsModifier

render :text => "Hello, world!"

RustModifier

fn main() {
    println!("Hello, world!");
}

SASModifier

%put Hello, world!;

SatherModifier

class HELLO_WORLD is
    main is 
        #OUT+"Hello, world!\n"; 
    end; 
end;

ScalaModifier

object HelloWorld extends App {
    println("Hello, world!");
}

Ou en console :

println("Hello, world!")

ScilabModifier

disp("Hello, world!");

SchemeModifier

    (display "Hello, world!")
    (newline)

ScratchModifier

 

sedModifier

sed -ne '1s/.*/Hello, world!/p'

ou

   sed "i\
Hello World" << EOF    
EOF

Seed (JavaScript)Modifier

#!/usr/bin/env seed

print("Hello, world!");

Seed7Modifier

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln("Hello, world!");
  end func;

SelfModifier

'Hello, world!' print.

SegFaultProgModifier

SegFaultProg V1Modifier

*A+H.[-]+e.+7..+3.*B+32.*A+8.-8.+3.[-]+d.

SegFaultProg V2Modifier

*$0x00$+cH.-$3$.+$7$..>+&+$0x03$.>+c .>+$0x57$.<<.+$3$.<.-$0x08$.

Shakespeare Programming LanguageModifier

Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.

                   Act I: Hamlet's insults and flattery.
                   Scene I: The insulting of Romeo.
[Enter Hamlet and Romeo]
Hamlet:
You lying stupid fatherless big smelly half-witted coward! You are as
stupid as the difference between a handsome rich brave hero and thyself!
Speak your mind!
You are as brave as the sum of your fat little stuffed misused dusty
old rotten codpiece and a beautiful fair warm peaceful sunny summer's
day. You are as healthy as the difference between the sum of the
sweetest reddest rose and my father and yourself! Speak your mind!
You are as cowardly as the sum of yourself and the difference
between a big mighty proud kingdom and a horse. Speak your mind.
Speak your mind!
[Exit Romeo]
                   Scene II: The praising of Juliet.
[Enter Juliet]
Hamlet:
Thou art as sweet as the sum of the sum of Romeo and his horse and his
black cat! Speak thy mind!
[Exit Juliet]
                   Scene III: The praising of Ophelia.
[Enter Ophelia]
Hamlet:
Thou art as lovely as the product of a large rural town and my amazing
bottomless embroidered purse. Speak thy mind!
Thou art as loving as the product of the bluest clearest sweetest sky
and the sum of a squirrel and a white horse. Thou art as beautiful as
the difference between Juliet and thyself. Speak thy mind!
[Exeunt Ophelia and Hamlet]

                   Act II: Behind Hamlet's back.
                   Scene I: Romeo and Juliet's conversation.
[Enter Romeo and Juliet]
Romeo:
Speak your mind. You are as worried as the sum of yourself and the
difference between my small smooth hamster and my nose. Speak your
mind!
Juliet:
Speak YOUR mind! You are as bad as Hamlet! You are as small as the
difference between the square of the difference between my little pony
and your big hairy hound and the cube of your sorry little
codpiece. Speak your mind!
[Exit Romeo]
                   Scene II: Juliet and Ophelia's conversation.
[Enter Ophelia]
Juliet:
Thou art as good as the quotient between Romeo and the sum of a small
furry animal and a leech. Speak your mind!
Ophelia:
Thou art as disgusting as the quotient between Romeo and twice the
difference between a mistletoe and an oozing infected blister! Speak
your mind!
[Exeunt]

Shell UnixModifier

#!/bin/sh
echo "Hello, world!"

SimulaModifier

BEGIN
    outtext("Hello, world!");
    outimage;
END;

SilscriptModifier

   Intr-aff-{
       aff[Hello world!];
   }Stop-aff-

SkriptModifier

send "Hello, world!" to player

SmalltalkModifier

Transcript show: 'Hello, world!'

Ou

self inform: 'Hello, world!'

SMLModifier

print "Hello, world!\n";

SNOBOLModifier

       OUTPUT = "Hello, world!"
   END

SpoonModifier

1111111111001000101111111010111111111101011101010110110110110000
0110101100101001010010101111111001010001010111001010010110010100
1101111111111111111100101001000101011100101000000000000000000000
10100000000000000000000000000010100101001010010001010

SQFModifier

    hint "Hello, world!";

SQLModifier

    create table MESSAGE (TEXT char(15));
    insert into MESSAGE (TEXT) values ('Hello, world!');
    select TEXT from MESSAGE;
    drop table MESSAGE;

Ou, plus simplement :

print 'Hello, world!'

Ou en KB-SQL

    select Null from DATA_DICTIONARY.SQL_QUERY
 
    FOOTER ''or HEADER or DETAIL or FINAL event''
    write "Hello, world!"

Ou en MySQL

select 'Hello, world!';

Ou en Oracle

select 'Hello, world!' from dual;

Ou en SQLite

.print 'Hello, world!'

Ou avec VALUES

SELECT * FROM (VALUES ('Hello, World!')) AS msg;

Swift 4Modifier

import Foundation 

print("Hello World")

TACLModifier

   #OUTPUT Hello, world!

TclModifier

puts "Hello, world!"

Tcl/TkModifier

pack [button .b -text "Hello, world!" -command exit]

TestAlgo 3Modifier

algo HelloWorld
principal
debut
	afficherln("Hello, World!");
fin

TeXModifier

Hello, world!
\bye

ThueModifier

a::=~Hello World!
::=
a

Turbo PascalModifier

program Hello_World; {titre du programme, facultatif}
begin
  writeln('Hello, world!'); {affiche le message et saute une ligne}
  readln; {Sert de pause, facultatif}
end.

TuringModifier

put "Hello, world!"

TSQLModifier

Declare @Output varchar(16)
Set @Output='Hello, world!'
Select @Output

ou, variation plus simple:

Select 'Hello, world!'
Print 'Hello, world!'

TI-59Modifier

Texas Instruments TI 58, TI 58C, TI 59 : Ce code imprime HELLO WORLD! sur l'imprimante thermique

000 69 OP 
001 00 00    efface la ligne
002 02  2 
003 03  3    H
004 01  1 
005 07  7    E
006 69 OP 
007 01 01    dans la zone de gauche
008 02  2    
009 07  7    L
010 02  2 
011 07  7    L
012 03  3 
013 02  2    O
014 00  0 
015 00  0    espace
016 04  4 
017 03  3    W
018 69 OP 
019 02 02    dans la zone milieu-gauche
020 03  3 
021 02  2    O
022 03  3 
023 05  5    R
024 02  2 
025 07  7    L
026 01  1 
027 06  6    D
028 07  7 
029 03  3    !
030 69 OP 
031 03 03    dans la zone milieu-droit
032 69 OP 
033 05 05    imprime la ligne
034 91 R/S   arrêt du programme

ou avec le TI Compiler (voir page sur la TI-59):

ClrLine
    "HE     <<line
    "LLO_W  <line
    "ORLD!  line>
PrtLine
R/S

TI-82 (calculatrice graphique)Modifier

Disp "HELLO WORLD!"

TI-BasicModifier

Ti 80 à Ti 92 :

:Disp "Hello world!"

ou plus simplement :

:Disp "Hello World!

ou

:Output(X,Y,"Hello world!")

ou plus simplement :

:Output(X,Y,"Hello World!

Où X représente la ligne et Y la colonne.

ou dans l'interface graphique :

:text(X,Y,"Hello Word!")

TypeScriptModifier

greet("Hello, world!");

ValaModifier

public class HelloWorld
{
    public static int main(string[] args) {
        print("Hello, world!");
        return 0;
    }
}

VerilogModifier

module main;
    initial
    begin
        $display("Hello, world");
        $finish ;
    end
endmodule

VHDLModifier

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;

VBA (Visual Basic for Application)Modifier

Sub Main()
    MsgBox "Hello, world!"
End Sub

Visual Basic .NET (Application Console)Modifier

Imports System
Public Shared Sub Main()
    Console.WriteLine("Hello, world!")
End Sub

Visual Basic .NET (Application Windows Forms)Modifier

Imports System.Windows.Forms
Public Shared Sub Main()
    MessageBox.Show("Hello, world!")
End Sub

Ou

Imports System.Windows.Forms
Public Shared Sub Main()
    MsgBox("Hello, world!")
End Sub

Visual Basic Script (VBS)Modifier

Soit message.vbs un Visual Basic Script.

MsgBox("Hello, world!")

message.vbs est utilisable dans un fichier Batch.

@echo off
start message.vbs

Visual DialogScript 2,3,4 et 5Modifier

Title Hello world!
Info Hello world!

WhitespaceModifier

   
   	  	   
		    	
   		  	 	
		    	 
   		 		  
		    		
   		 		  
		    
	  
   		 				
		    	 	
   	 		  
		    		 
   	     
		    			
   			 			
		  
  	   
   		 				
		    	  	
   			  	 
		    	 	 
   		 		  
		    	 		
   		  
	  
		    		  
   	    	
		    		 	
   		 	
		    			 
   	 	 
		    				
    
	
	     
empty-line
    	
empty-line
 			 
empty-line
	  	 
	
     	
	   
empty-line
  	
empty-line
   	 
empty-line
empty-line/EOF

WLangage (WinDev)Modifier

Info("Hello, world!")

XML (Extensible Markup Language)Modifier

<?xml version="1.0" encoding="UTF-8"?>

<root>
  <title>
    XML Document
  </title>
  <para>
    Hello, world!
  </para>
</root>

XSLT (eXtensible Stylesheet Language Transformations)Modifier

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
      version="2.0">
<xsl:template match="/">Hello, world!</xsl:template>
</xsl:stylesheet>

XULModifier

<?xml version="1.0" encoding="ISO-8859-1" ?>
<window title="Hello, world!"
        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<description>Hello, world!</description>
<label value="Hello world!" />
</window>

YaBasicModifier

print "Hello, world!"

ou

print @(1,1) "Hello, world!"

ou

open window 30,100
text 1,20,"Hello, world!"

Notes et référencesModifier