Helló Világ programpéldák
Az alábbiakban példákat láthatunk a „Helló, világ!” programokra különböző programozási nyelveken. A megjelenített szöveg a legtöbb helyen ékezetek nélkül, ugyanis bizonyos nyelvek, környezetek és eszközök nem képesek az ékezetek megjelenítésére.
Szöveges felhasználói felület[szerkesztés]
Szöveges felhasználói felületekben (TUI; más néven konzolban) használt nyelvek példái.
ABC[szerkesztés]
WRITE "Hello, vilag!"
Ada[szerkesztés]
with Ada.Text_Io; use Ada.Text_Io; procedure Hello is begin Put_Line ("Hello, vilag!"); end Hello;
AmigaE[szerkesztés]
PROC main() WriteF('Hello, vilag!') ENDPROC
APL[szerkesztés]
'Hello, vilag!'
Assembly[szerkesztés]
Csak akkumulátor architektúra[szerkesztés]
Példa csak-akkumulátor architektúrára: DEC PDP–8, PAL–III Assembler
A példa a Digital PDP–8 Handbook Series, Introduction to Programming könyvből származik.
*200 / összeállítás-származás megadása (betöltési cím) hello, cla cll tls / tls a nyomtatójelölő megadásához. tad charac / indexregiszter beállítása dca ir1 / a karakterek megszerzéséhez. tad m6 / számláló beállítása dca count / a karakterek kiírásához. next, tad i ir1 / karakter megszerzése. jms type / kiírása. isz count / elkészült? jmp next / nem: újabb begépelése. hlt type, 0 / type szubrutin tsf jmp .-1 tls cla jmp i type charac, . / az ir1 kezdeti értéke 310 / H 305 / E 314 / L 314 / L 317 / O 254 / , 240 / 326 / V 311 / I 314 / L 300 / A 307 / G 241 / ! m6, -15 count, 0 ir1 = 10 $
Első sikeres µP/OS-kombinációk[szerkesztés]
Intel 8080/Zilog Z80, CP/M, RMAC assembler
bdos equ 0005H ; BDOS belépési pont start: mvi c,9 ; BDOS függvény: karakterlánc kivitele lxi d,msg$ ; msg címe call bdos ret ; visszatérés a CCP-hez msg$: db 'Hello, vilag!$' end start
Accumulator + indexregisztergép[szerkesztés]
MOS Technology 6502, CBM KERNAL, ca65 assembler
MSG: .ASCIIZ "Hello, vilag!" LDX #0 LDA MSG,X ; kezdőkarakter betöltése @LP: JSR $FFD2 ; chrout INX LDA MSG,X BNE @LP RTS
Accumulator/Index mikrokódolt gép[szerkesztés]
; "Helló, világ!" program RDOS-t futtató Novára; az eredetit írta: Toby Thain ; PCHAR rendszerhívást használ .titl hello .nrel .ent start start: dochar: lda 0,@pmsg ; ac0 betöltése következő karakterrel, mov# 0,0,snr ; ac0 tesztelése; kihagyás ha nem nulla (ne töltse be az eredményt) jmp done .systm .pchar ; első kiírása jmp er ; kihagyva, ha jó movs 0,0 ; bájtcsere .systm .pchar ; második kiírása jmp er ; kihagyva, ha jó isz pmsg ; mutatás a következő szóra jmp dochar ; újrakezdés done: .systm ; normál kilépés .rtn er: .systm ; hibás kilépés .ertn halt pmsg: .+1 ; mutató a karakterlánc első szavához ; a megjegyzésbájtok alapértelmezés szerint jobbról balra vannak csomagolva .txt /Hello, vilag!<15><12>/ ; CR LF 0 ; szó megjelölése a karakterlánc befejezéséhez .end start
Bővített accumulator gép[szerkesztés]
MODEL SMALL IDEAL STACK 100H DATASEG MSG DB 'Hello, vilag!$' CODESEG MOV AX, @data MOV DS, AX MOV DX, OFFSET MSG MOV AH, 09H ; DOS: ASCII$ karakterlánc kivitele INT 21H MOV AX, 4C00H INT 21H END
Általános célú fiktív számítógép[szerkesztés]
TERM EQU 19 konzoleszköz száma (19 = írógép) ORIG 1000 címkezdet START OUT MSG(TERM) adat kivitele a cél-MSG-nél HLT megszakítás végrehajtása MSG ALF "HELLO" ALF ", VIL" ALF "AG! " END START program vége
Általános célú CISC regiszter[szerkesztés]
DEC PDP–11, RT-11, MACRO-11
.MCALL .REGDEF,.TTYOUT,.EXIT .REGDEF HELLO: MOV #MSG,R1 MOVB (R1),R0 LOOP: .TTYOUT MOVB +(R1),R0 BNE LOOP .EXIT MSG: .ASCIZ /HELLO, VILAG!/ .END HELLO
CISC irányított többfolyamatos operációs rendszeren[szerkesztés]
.title hello .psect data, wrt, noexe chan: .blkw 1 iosb: .blkq 1 term: .ascid "SYS$OUTPUT" msg: .ascii "Hello, vilag!" len = . – msg .psect code, nowrt, exe .entry hello, ^m<> ; Csatorna létesítése terminálos I/O-hoz $assign_s devnam=term, - chan=chan blbc r0, end ; I/O-kérelem sorbaállítása $qiow_s chan=chan, - func=#io$_writevblk, - iosb=iosb, - p1=msg, - p2=#len ; Állapot és IOSB-állapot ellenőrzése blbc r0, end movzwl iosb, r0 ; Visszatérés az operációs rendszerhez end: ret .end hello
RISC processzor[szerkesztés]
ARM, RISC OS, a BBC BASIC interpretere
.program ADR R0,message SWI "OS_Write0" SWI "OS_Exit" .message DCS "Hello, vilag!" DCB 0 ALIGN
Vagy még kisebb változat (qUE-től):
SWI"OS_WriteS":EQUS"Hello, vilag!":EQUB0:ALIGN:MOVPC,R14
Awk[szerkesztés]
BEGIN {print "Hello, vilag!"; exit}
BASIC[szerkesztés]
CASIO-BASIC – Casio grafikus számológépeken használt BASIC-nyelv[szerkesztés]
"HELLO, VILAG!"
MS BASIC (hagyományos, strukturálatlan)[szerkesztés]
10 PRINT "Hello, vilag!" 20 END
TI-BASIC[szerkesztés]
:Disp "Hello, vilag!"
:HelloVilag() :Prgm :Disp "Hello, vilag!" :EndPrgm
StarOffice/OpenOffice Basic[szerkesztés]
sub main print "Hello, vilag!" end sub
Strukturált BASIC[szerkesztés]
print "Hello, vilag!" end
BCPL[szerkesztés]
GET "LIBHDR" LET START () BE $( WRITES ("Hello, vilag!*N") $)
BLISS[szerkesztés]
%TITLE 'HELLO_VILAG' MODULE HELLO_VILAG (IDENT='V1.0', MAIN=HELLO_VILAG, ADDRESSING_MODE (EXTERNAL=GENERAL)) = BEGIN LIBRARY 'SYS$LIBRARY:STARLET'; EXTERNAL ROUTINE LIB$PUT_OUTPUT; GLOBAL ROUTINE HELLO_VILAG = BEGIN LIB$PUT_OUTPUT(%ASCID %STRING('Hello, vilag!')) END; END ELUDOM
Brainfuck[szerkesztés]
+++++ +++++ [ > +++++ ++ > +++++ +++++ > +++ > + <<<< - ] > ++ . 'H' > + . 'e' +++++ ++ . 'l' . 'l' +++ . 'o' >++ . ' ' << +++++ +++++ +++++ . 'W' > . 'o' +++ . 'r' ----- - . 'l' ----- --- . 'd' > + . '!'
Egy sorban:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
C[szerkesztés]
#include <stdio.h> int main() { printf("Hello, vilag!\n"); return 0; }
C++[szerkesztés]
#include <iostream> int main() { std::cout << "Helló, világ!\n"; return 0; }
Calprola[szerkesztés]
#BTN A1 #PRI "HELLO WORLD!" #END
CIL[szerkesztés]
.method public static void Main() cil managed { .entrypoint .maxstack 8 ldstr "Hello, vilag!" call void [mscorlib]System.Console::WriteLine(string) ret }
Clean[szerkesztés]
module hello Start :: String Start = "Hello, vilag!"
CLIST[szerkesztés]
PROC 0 WRITE Hello, vilag!
COBOL[szerkesztés]
IDENTIFICATION DIVISION. PROGRAM-ID. HELLO-VILAG. ENVIRONMENT DIVISION. DATA DIVISION. PROCEDURE DIVISION. DISPLAY "Hello, vilag!". STOP RUN.
Common Lisp[szerkesztés]
(format t "Hello, vilag!~%")
C# Console[szerkesztés]
using System; class Hello { static void Main() { Console.WriteLine("Hello World!"); } }
D[szerkesztés]
import std.stdio; int main() { writef("Hello, vilag!\n"); return 0; }
D (DTrace)[szerkesztés]
#pragma D option quiet
BEGIN { printf("Hello, vilag!\n"); exit(0); }
DCL parancsfájl[szerkesztés]
$ write sys$output "Hello, vilag!"
Ed és Ex (Ed extended)[szerkesztés]
a hello, vilag! . p
Vagy:
echo -e 'a\nhello, vilag!\n.\np'|ed echo -e 'a\nhello, vilag!\n.\np'|ex
Eiffel[szerkesztés]
class HELLO_VILAG creation make feature make is local io:BASIC_IO do !!io io.put_string("%N Hello, vilag!") end—make end—class HELLO_VILAG
Erlang[szerkesztés]
-module(hello). -export([hello_vilag/0]). hello_vilag() -> io:fwrite("Hello, vilag!\n").
EUPHORIA[szerkesztés]
puts(1, "Hello, vilag!")
F#[szerkesztés]
type data = { first: string; second: string; } let myData = { first="Hello,"; second="vilag!"; } let _ = print_string myData.first; print_string " "; print_string myData.second; print_newline()
Focus[szerkesztés]
-TYPE Hello vilag
Forte TOOL[szerkesztés]
begin TOOL HelloVilag; 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('HelloVilag!'); end method; -- END METHOD DEFINITIONS HAS PROPERTY CompatibilityLevel = 0; ProjectType = APPLICATION; Restricted = FALSE; MultiThreaded = TRUE; Internal = FALSE; LibraryName = 'hellovil'; StartingMethod = (class = Hello, method = Init); end HelloVilag;
Forth[szerkesztés]
." Hello, vilag!" CR
FORTRAN[szerkesztés]
PROGRAM HELLO WRITE(*,10) 10 FORMAT('Hello, vilag!') STOP END
FoxPro/dBase/Clipper[szerkesztés]
? 'Hello, vilag!'
Frink[szerkesztés]
println["Hello, vilag!"]
Gambas[szerkesztés]
Lásd még a GUI részt.
PUBLIC SUB Main() Print "Hello, vilag!" END
Game Maker[szerkesztés]
Bizonyos objektumok draw eseményében:
draw_text(x,y,"Hello, vilag");
Go[szerkesztés]
package main func main() { print("Hello Világ!\n") }
Haskell[szerkesztés]
module HelloVilag (main) where main = putStr "Hello, vilag\n"
Heron[szerkesztés]
program HelloVilag; functions { _main() { String("Hello, vilag!") |> GetStdOut(); } } end
HP–41 és HP–42S[szerkesztés]
(Kézi Hewlett-Packard RPN-alapú alfanumerikus mérnöki számológépek.)
01 LBLTHELLO 02 THELLO, VILAG 03 PROMPT
Iptscrae[szerkesztés]
ON ENTER { "Hello " "vilag!" & SAY }
Io[szerkesztés]
"Hello, vilag!" print
Vagy:
write("Hello, vilag!\n")
Java[szerkesztés]
Lásd még a GUI részt.
public class Hello { public static void main(String[] args) { System.out.println("Helló, világ!"); } }
JVM[szerkesztés]
(Disassemblerkivitel: javap -c Hello.class)
public class Hello extends java.lang.Object { public Hello(); public static void main(java.lang.String[]); } Method Hello() 0 aload_0 1 invokespecial #1 <Method java.lang.Object()> 4 return Method void main(java.lang.String[]) 0 getstatic #2 <Field java.io.PrintStream out> 3 ldc #3 <String "Helló, világ!"> 5 invokevirtual #4 <Method void println(java.lang.String)> 8 return
Kogut[szerkesztés]
WriteLine "Hello, vilag!"
Logo[szerkesztés]
print [Hello, vilag!]
vagy
pr [Hello, vilag!]
Csak mswlogóban:
messagebox [Hi] [Hello, vilag!]
Csak magyar Comenius Logóban:
kiír [Hello, világ!]
LPC[szerkesztés]
tell_object(this_player(), "Helló világ");
// vagy
write("Helló világ");
Lua[szerkesztés]
print "Hello, vilag!"
M (MUMPS)[szerkesztés]
W "Hello, vilag!"
vagy
WRITE "Hello, vilag!"
Mathematica[szerkesztés]
Print["Hello, vilag"]
Modula-2[szerkesztés]
MODULE Hello; FROM Terminal2 IMPORT WriteLn, WriteString; BEGIN WriteString("Hello, vilag!"); WriteLn; END Hello;
MS-DOS parancsfájl[szerkesztés]
A szabványos command.com parancsértelmezővel. A @ jel opcionális, és megakadályozza a rendszert, hogy a parancs végrehajtása előtt magát a parancsot is kiírja. A @ jelet el kell hagyni az 5.0-snál korábbi MS-DOS-verziók esetén.
@echo Helló, világ!
MUF[szerkesztés]
: main me @ "Hello, vilag!" notify ;
Objective C[szerkesztés]
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog(@"Hello, vilag!");
[pool release];
return 0;
}
OCaml[szerkesztés]
let _ = print_endline "Hello, vilag!";;
OPL[szerkesztés]
Lásd még a GUI részt.
PROC hello: PRINT "Hello, vilag" ENDP
OPS5[szerkesztés]
(object-class request
^action)
(startup
(strategy MEA)
(make request ^action hello)
)
(rule hello
(request ^action hello)
-->
(write |Hello, vilag!| (crlf))
)
Pascal[szerkesztés]
program Hello; begin writeln('Helló, világ!'); readln; end.
Perl[szerkesztés]
print "Hello, vilag!\n";
PHP[szerkesztés]
<?php echo "Helló, világ!"; ?>
vagy
<?php print('Helló, világ!'); ?>
vagy (ez csak akkor működik, ha a php-ban be van kapcsolva a short_open_tag = On, ami alapértelmezetként ki van kapcsolva!)
<?='Helló, világ!'?>
Pike[szerkesztés]
int main() { write("Hello, vilag!\n"); return 0; }
PL/I[szerkesztés]
Test: procedure options(main); declare My_String char(20) varying initialize('Hello, vilag!'); put skip list(My_String); end Test;
POP-11[szerkesztés]
'Hello, vilag!' =>
Postscript[szerkesztés]
%! /Courier findfont 12 scalefont setfont newpath 100 100 moveto (Hello World!) show showpage
POV-Ray[szerkesztés]
#include "colors.inc"
camera {
location <3, 1, -10>
look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
ttf "timrom.ttf" "Hello, vilag!" 1, 0
pigment { White }
}
Prolog[szerkesztés]
write('Hello, vilag!'),nl.
Python[szerkesztés]
print("Hello, vilag!")
REXX, NetRexx és Object REXX[szerkesztés]
say "Hello, vilag!"
RPL[szerkesztés]
Lásd még a GUI részt.
(A Hewlett-Packard HP–28, HP–48 és HP–49 sorozatú gráfszámológépeken.)
<< CLLCD "Hello, vilag!" 1 DISP 0 WAIT DROP >>
Ruby[szerkesztés]
puts "Hello, vilag!"
SAS[szerkesztés]
data _null_; put 'Hello, vilag!'; run;
Sather[szerkesztés]
class HELLO_VILAG is main is #OUT+"Hello, vilag\n"; end; end;
Scala[szerkesztés]
object HelloVilag with Application { Console.println("Hello, vilag!"); }
Scheme[szerkesztés]
(display "Hello, vilag!") (newline)
sed[szerkesztés]
Megjegyzés: Legalább egysornyi bevitelre szüksége van.
sed -ne '1s/.*/Hello, vilag!/p'
Seed7[szerkesztés]
$ include "seed7_05.s7i";
const proc: main is func begin writeln("Hello, vilag!"); end func;
Self[szerkesztés]
'Hello, vilag!!' print.
Smalltalk[szerkesztés]
Transcript show: 'Hello, vilag!'
SML[szerkesztés]
print "Hello, vilag!\n";
SNOBOL[szerkesztés]
OUTPUT = "Hello, vilag!" END
SQL[szerkesztés]
create table MESSAGE (TEXT char(15)); insert into MESSAGE (TEXT) values ('Helló, Világ!'); select TEXT from MESSAGE; drop table MESSAGE;
Vagy (például Oracle-dialektus):
select 'Helló, világ!' from dual;
Vagy (például MySQL-dialektus):
select 'Helló, világ!';
Vagy még egyszerűbben:
print 'Helló, világ!'
Vagy (KB-SQL-dialektus):
select Null from DATA_DICTIONARY.SQL_QUERY FOOTER vagy HEADER vagy DETAIL vagy FINAL esemény write "Helló, világ!"
STARLET[szerkesztés]
RACINE: HELLO_VILAG. NOTIONS: HELLO_VILAG : ecrire("Hello, vilag!").
TACL[szerkesztés]
#OUTPUT Hello vilag!
Tcl[szerkesztés]
puts "Hello, vilag!"
Turing[szerkesztés]
put "Hello, vilag!"
TSQL[szerkesztés]
Declare @Output varchar(16) Set @Output='Helló, világ!' Select @Output
Vagy egyszerűbb variációk:
Select 'Helló, világ!'
Print 'Helló, világ!'
UNIX-stílusú rendszerhéj[szerkesztés]
echo 'Hello, vilag!'
Whitespace[szerkesztés]
üres-sor üres-sor/EOF
Grafikus felhasználói felületek (GUI)[szerkesztés]
AutoIt[szerkesztés]
MsgBox(0, "Tutorial", "Hello World!")
ActionScript (Macromedia Flash MX)[szerkesztés]
trace ("Helló, világ!")
AppleScript[szerkesztés]
display dialog "Helló, világ!"
Cocoa vagy GNUstep (Objective C-ben)[szerkesztés]
#import <Cocoa/Cocoa.h> @interface hello : NSObject { } @end @implementation hello -(void)awakeFromNib { NSBeep(); // Nem szükséges, de szokás hangjelzést adni figyelmeztetés megjelenítésekor NSRunAlertPanel(@"Üzenet a számítógéptől", @"Helló, világ!", @"Hello!", nil, nil); } @end
Delphi, Kylix[szerkesztés]
ShowMessage('Hello, vilag!');
FLTK eszközkészlet[szerkesztés]
C nyelven[szerkesztés]
#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Button.H>
int main(int argc, char *argv[]) {
Fl_Window* w = new Fl_Window(330, 190);
new Fl_Button(110, 130, 100, 35, "Hello World");
w->end();
w->show(argc, argv);
return Fl::run();
}
Python nyelven[szerkesztés]
#!/usr/bin/python
import fltk
window = fltk.Fl_Window(100, 100, 200, 50)
button = fltk.Fl_Button(9,10,180,30)
button.label("Hello World")
window.end()
window.show()
fltk.Fl.run()
Gambas[szerkesztés]
Lásd még a TUI részt.
PUBLIC SUB Main() Message.Info("Hello, vilag!") END
GTK eszközkészlet[szerkesztés]
C++ példa:[szerkesztés]
#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
using namespace std;
class HelloVilag : public Gtk::Window {
public:
HelloVilag();
virtual ~HelloVilag();
protected:
Gtk::Button m_button;
virtual void on_button_clicked();
};
HelloVilag::HelloVilag() : m_button("Hello, vilag!") {
set_border_width(10);
m_button.signal_clicked().connect(SigC::slot(*this, &HelloVilag::on_button_clicked));
add(m_button);
m_button.show();
}
HelloVilag::~HelloVilag() {}
void HelloVilag::on_button_clicked() {
cout << "Helló, világ!" << endl;
}
int main (int argc, char *argv[]) {
Gtk::Main kit(argc, argv);
HelloVilag hellovilag;
Gtk::Main::run(hellovilag);
return 0;
}
C# példa:[szerkesztés]
using Gtk;
using GtkSharp;
using System;
class Hello {
static void Main()
{
Application.Init ();
Window window = new Window ("Helló, világ!");
window.Show();
Application.Run ();
}
}
Euphoria példa:[szerkesztés]
include gtk2/wrapper.e
Info(NULL,"Hello","Hello, vilag!")
Python példa:[szerkesztés]
#!/usr/bin/python
import gtk
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
button = gtk.Button("Hello World")
button.connect_object("clicked", gtk.main_quit, window)
window.add(button
button.show()
window.show()
gtk.main()
Java Swing[szerkesztés]
Lásd még a TUI részt.
import javax.swing.JOptionPane; public class Hello { public static void main(String[] args) { JOptionPane.showMessageDialog(null, "Helló, világ!"); System.exit(0); } }
Java-applet[szerkesztés]
A Java-kisalkalmazások HTML-fájlokkal működnek együtt.
<HTML> <HEAD> <TITLE>Helló, világ!</TITLE> </HEAD> <BODY> A HelloVilag program üzeni: <APPLET CODE="HelloVilag.class" WIDTH=600 HEIGHT=100> </APPLET> </BODY> </HTML>
import java.applet.*; import java.awt.*; public class HelloVilag extends Applet { public void paint(Graphics g) { g.drawString("Helló, világ!", 100, 50); } }
JavaScript (más néven ECMAScript) és JScript[szerkesztés]
A JavaScript egy ügyféloldali parancsleírónyelv, melyet HTML-fájlokban használnak. Az alábbi kódot bármely HTML fájlban elhelyezhetjük.
<script type="text/javascript"><!--
function helloVilag()
{
alert("Helló, világ!");
}
//--></script>
<a href="#" onclick="helloVilag()">Helló, világ! példa</a>
Egy egyszerűbb módszer implicit módon használja a JavaScriptet, a lefoglalt alert függvényt hívva meg. Az alábbi sort a <BODY>
… </BODY>
HTML-címkék közé kell helyezni.
<a href="#" onclick="alert('Helló, világ!')">Helló, világ! példa</a>
Egy, még ennél is egyszerűbb módszer a népszerű böngészők virtuális „javascript” protokolljának használata, mellyel JavaScript-kódot lehet végrehajtani. Az alábbit internetcímként kell megadni:
javascript:alert('Helló, világ!')
Messenger Plus Live Script (JavaSCript alapon; bejelentkezéskor)[szerkesztés]
function OnEvent_Initialize(MessengerStart) { }
function OnEvent_Uninitialize(MessengerExit) {
}
function OnEvent_Signin (Email) { if (Email == Messenger.MyEmail) { Debug.Trace("Hello Világ!"); MsgPlus.DisplayToast("Hello Világ!", "Hello Világ!"); } }
OPL[szerkesztés]
Lásd még a TUI részt.
(A Psion Series 3-as és annál újabb, kompatibilis PDA-kon.)
PROC guihello: ALERT("Hello, vilag!","","Kilépés") ENDP
Qt eszközkészlet[szerkesztés]
C++ példa:[szerkesztés]
#include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton hello("Hello world!");
hello.resize(100, 30);
hello.show();
return app.exec();
}
Python példa:[szerkesztés]
#!/usr/bin/python
import sys
from PyQt4 import Qt
a = Qt.QApplication(sys.argv)
hello = Qt.QLabel("Hello World")
hello.show()
a.exec_()
REALbasic[szerkesztés]
MsgBox "Hello, vilag!"
RPL[szerkesztés]
Lásd még a TUI részt.
(A Hewlett-Packard HP–48G és HP–49G sorozatú számológépeken.)
<< "Hello, vilag!" MSGBOX >>
SWT[szerkesztés]
import org.eclipse.swt.widgets.*; public class Main { public static void main (String [] args) { Display display = new Display (); Shell shell = new Shell(display); shell.open (); while (!shell.isDisposed ()) { if (!display.readAndDispatch ()) display.sleep (); } display.dispose (); } }
TK eszközkészlet[szerkesztés]
Python nyelven[szerkesztés]
#!/usr/bin/python
import Tkinter
root = Tkinter.Tk()
w = Tkinter.Label(root, text="Hello, world!")
w.pack()
root.mainloop()
Tcl nyelven[szerkesztés]
#!/usr/bin/wish
button .hello -text "Hello, World!" -command { exit }
pack .hello
Visual Basic és VBA[szerkesztés]
Ha nincs form csak egy .bas modul a Sub Main eljárás az alapértelmezett belépési pont.
Public Sub Main() MsgBox "Helló, világ!" End Sub
Ha adtunk formot a projekthez, akkor a Load eseményhez rendelhetjük hozzá az Msgbox függvény hívását:
Public Sub Form_Load() MsgBox "Helló, világ!" End Sub
Windows API (C-ben)[szerkesztés]
#include <windows.h> LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM); char szClassName[] = "MainWnd"; HINSTANCE hInstance; int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { HWND hwnd; MSG msg; WNDCLASSEX wincl; hInstance = hInst; wincl.cbSize = sizeof(WNDCLASSEX); wincl.cbClsExtra = 0; wincl.cbWndExtra = 0; wincl.style = 0; wincl.hInstance = hInstance; wincl.lpszClassName = szClassName; wincl.lpszMenuName = NULL; //No menu wincl.lpfnWndProc = WindowProcedure; wincl.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); //Ablak színe wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); //EXE-ikon wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); //Kis programikon wincl.hCursor = LoadCursor(NULL, IDC_ARROW);
wxWidgets eszközkészlet[szerkesztés]
Python nyelven[szerkesztés]
#!/usr/bin/python
import wx
w=wx.App()
frame = wx.Frame(None, -1, "Test", pos=(50,50), size=(100,40), style=wx.DEFAULT_FRAME_STYLE)
button = wx.Button(frame, -1, "Hello World!", (20, 20))
frame = frame
frame.Show()
w.MainLoop()
Egyéb nyelvek[szerkesztés]
Verilog[szerkesztés]
module main;
initial
begin
$display("Hello world!");
$finish;
end
endmodule
- Egy egyszerű példa RS tárolóra (áramköri "Hello World")
module rs_ff(q, q_neg, reset, set);
output q, q_neg;
input reset, set;
reg q, q_neg;
always @(set or q)
#1 q = !(q_neg && set);
always @(reset or q)
#1 q_neg= !(q && reset);
endmodule
VHDL[szerkesztés]
entity hello_world is
end hello_world;
architecture behaviour of hello_world is
begin
process
variable l : line;
begin
write (l, String'("Hello world!"));
writeline (output, l);
wait;
end process;
end behaviour;