Salam Dünya proqram nümunələrinin siyahısı

Proqramlaşdırma dilini yeni öyrənməyə başlayarkən ilk yazılan proqram adətən "Salam Dünya" proqramı olur. Bir çox dildə yazılmış Salam Dünya proqram nümunələri:

## [[3D Games Creator]]

```actionscript
print "Salam Dünya"
wait key
```


## [[ABAP]]

```abap
REPORT Z_HALLO_WELT.
WRITE 'Salam Dünya!'.
```


## [[ActionScript]]

```actionscript
trace('Salam Dünya');
```


## [[Ada]]

```ada
with Ada.Text_IO;
procedure Salam is
begin
    Ada.Text_IO.Put_Line ("Salam Dünya!");
end Hallo;
```


## [[Algol 60|ALGOL 60]]

```algol68
'BEGIN'
     OUTSTRING(2,'('Salam Dünya')');
 'END'
```


## [[Algol 68|ALGOL 68]]

```algol68
( print("Salam Dünya!") )
```


## [[AMOS BASIC]]

```freebasic
? "Salam Dünya!"
```


## [[AppleScript]]

```applescript
display dialog "Salam Dünya"
```


## [[Active Server Pages|ASP (Active Server Pages)]]

```asp
<%
  Response.Write("Salam Dünya!")
%>
```


və ya


```asp
<%="Salam Dünya!"%>
```


## [[AutoHotkey]]

```autohotkey
MsgBox Salam Dünya!
```


## [[AutoIt]]

```autoit
MsgBox(0, "", "Salam Dünya!")
```


## [[AutoLISP]]

```lisp
(princ "Salam Dünya!")
```


## [[awk]]

```awk
BEGIN { print "Salam Dünya!" }
```


## [[B (proqramlaşdırma dili)|B]]

```c
main() {
    printf("Salam Dünya!");
}
```


## [[BASIC]]

```qbasic
10 PRINT "Salam Dünya!"
```


## [[Batch]]

```dos
@echo Salam Dünya!
```


## [[BeanShell]]

```c
print("Salam Dünya!");
```


## [[BlitzMax#BlitzMax|Blitz Max]]

```blitzbasic
Framework BRL.StandardIO
Print("Salam Dünya!")
```


## [[Boo (proqramlaşdırma dili)|Boo]]

```boo
print "Salam Dünya!"
```


## [[Microsoft Navision#C/AL|C/AL]]

```c
MESSAGE('Salam Dünya')
```


## [[C (proqramlaşdırma dili)|C]]

```c
#include <stdio.h>

int main(void)
{
    puts("Salam Dünya!");
}
```


### [[C (proqrmlaşdımra dili)|C]] [[GIMP-Toolkit|GTK]] ilə

```c
/*
 * "gcc hello_world.c -o hello_world `pkg-config --cflags --libs gtk+-2.0`" şəklində kompilyasiya edin. 
 * 
 */
#include <gtk/gtk.h>
gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) {
  return FALSE;
}
void destroy(GtkWidget *widget, gpointer data) {
  gtk_main_quit();
}
void clicked(GtkWidget *widget, gpointer data) {
  g_print("Salam Dünya!\n");
}
int main (int argc, char *argv[]) {
  gtk_init(&argc, &argv);
  GtkWidget *window;
  GtkWidget *button;
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_container_set_border_width(GTK_CONTAINER(window), 10);
  g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_event), NULL);
  g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
  button = gtk_button_new_with_label("Salam Dünya!");
  g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clicked), NULL);
  gtk_widget_show(button);
  gtk_container_add(GTK_CONTAINER(window), button);
  gtk_widget_show(window);
  gtk_main();
  return 0;
}
```


### C [[Windows API]] ilə

```c
#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  MessageBox(0, "Salam Dünya!", "Mənim birinci proqramım", MB_OK);
  return 0;
}
```


## [[C++]]

```cpp
#include <iostream>
int main()
{
    std::cout << "Salam Dünya!" << std::endl;
}
```


### [[C++/CLI]]

```cpp
int main()
{
    System::Console::WriteLine("Salam Dünya!");
}

=== [[C++]] [[gtkmm]] ilə ===
<syntaxhighlight lang="cpp" highlight="10">
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
int main (int argc, char* argv[])
{
    Gtk::Main m_main(argc, argv);
    Gtk::Window m_window;
    Gtk::Button m_button("Salam Dünya!");
    m_window.add(m_button);
    m_button.show();
    Gtk::Main::run(m_window);
    return 0;
}
```


### [[C++]] [[Qt (kitabxana)|Qt]] kitabxanası ilə

```cpp
#include <QLabel>
#include <QApplication>
int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QLabel label("Salam Dünya!");
    label.show();
    return app.exec();
}
```


## [[C-Sharp|C#]]

```csharp
class MainClass
{
    public static void Main()
    {
        System.Console.WriteLine("Salam Dünya!");
    }
}
```


## [[Common Intermediate Language|CIL]]

```cil
.assembly SalamDunya { }
.assembly extern mscorlib { }
.method public static void Main() cil managed
{
    .entrypoint
    .maxstack 1
    ldstr "Salam Dünya!"
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}
```


## [[CLIST]]

```asm
WRITE Salam Dünya
```


## [[Clojure]]

```clojure
(println "Salam Dünya!")
```


## CLP

```asm
PGM
SNDPGMMSG MSG('Salam Dünya!') MSGTYPE(*COMP)
ENDPGM
```


## [[COBOL]]

```cobol
000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID. HELLOWORLD.
000900 PROCEDURE DIVISION.
001000 MAIN.
001100 DISPLAY "Salam Dünya!".
001200 STOP RUN.
```


## [[ColdFusion|COLDFUSION]]

```cfm
<cfset beispiel = "Salam Dünya!" >
<cfoutput>#beispiel#</cfoutput>
```


## [[COMAL]]

```qbasic
10 PRINT "Salam Dünya!"
```


## [[Common Lisp]]

```lisp
(write-line "Salam Dünya!")
```


## [[Component Pascal]]

```pascal
MODULE SalamDunya;
IMPORT Out;
PROCEDURE Output*;
BEGIN
   Out.String ("Salam Dünya!");
   Out.Ln;
END Output;
END HalloWelt.
```


## [[D (proqramlaşdırma dili)|D]]

```d
import std.stdio;
void main() {
    writeln("Salam Dünya!");
}
```


## [[dBase]]/[[Foxpro]]

```visualfoxpro
? "Salam Dünya!"
```


## [[Object Pascal]]
komanda interfeysi:

```delphi
program SalamDunya;
begin
  writeln('Salam Dünya!');
end.
```


qrafik interfeys:

```delphi
program HalloWelt;
    {$APPTYPE GUI}
    uses Dialogs;
     begin
      ShowMessage('Salam Dünya!');
    end.
```


## [[Eiffel]]

```eiffel
class Salam_Dunya
create
    make
feature
    make is
    do
        io.put_string("Salam Dünya!%N")
    end
end
```


## [[ELAN]]

```c
putline ("Salam Dünya!");
```


## [[Emacs]] Lisp

```lisp
(print "Salam Dünya!")
```


## [[Erlang]]

```erlang
-module(Salam).
-export([Salam_Dunya/0]).

Salam_Dunya() -> io:fwrite("Salam Dünya!\n").
```


## [[F-Sharp|F#]]

```fsharp
printfn "Salam Dünya"
```


## [[Forth]]

```text
.( Salam Dünya!)
```


## [[Fortran]]

```fortran
program salam
write(*,*) "Salam Dünya!"
end program salam
```


## [[FreeBASIC]]

```freebasic
print "Salam Dünya!"
```


## [[Game Maker|GML]]

```gml
show_message("Salam Dünya!");
```


## [[Gambas (proqramlaşdırma dili)|Gambas]]

```gambas
PUBLIC SUB Form_Enter()
    PRINT "Salam Dünya!"
    END
```


## [[Go (proqramlaşdırma dili)|Go]]

```go
package main

import "fmt"

func main() {
	fmt.Println("Salam Dünya!")
}
```


## [[Groovy]]

```groovy
println "Salam Dünya!"
```


## [[Haskell]]

```haskell
main :: IO ()
main = putStrLn "Salam Dünya!"
```


## [[Haxe]]

```actionscript
class Test {
    static function main() {
        trace("Salam Dünya!");
    }
}
```


## [[Interactive Data Language|IDL (RSI)]]

```idl
PRO salam_dunya
    PRINT, "Salam Dünya!"
END
```


## [[Io (proqramlaşdırma dili)|Io]]

```io
"Salam Dünya!" print
```


## [[J-Sharp|J#]]

```csharp
public class HalloWelt
{
    public static void main(String[] args)
    {
        System.Console.WriteLine("Salam Dünya!");
    }
}
```


## [[JavaScript]]

```javascript
document.write("Salam Dünya!");
```


## [[Java]]

```java
class Hallo {
  public static void main( String[] args ) {
    System.out.println("Salam Dünya!");
  }
}
```


və ya


```java
import javax.swing.*;
class Salam {
  public static void main( String[] args ) {
    JOptionPane.showMessageDialog( null, "Salam Dünya!" );
  }
}
```


## [[KiXtart]]

```kixtart
? "Salam Dünya!"
```


## [[LaTeX]]

```latex
\documentclass{article}
\begin{document}
Salam Dünya!
\end{document}
```


## [[LISP]]

```lisp
(print "Salam Dünya!")
```


## [[Logo]]

```lisp
print [Salam Dünya!]
```


## [[Lua]]

```lua
print ("Salam Dünya!")
```


## [[MATLAB]]

```matlab
fprintf('Salam Dünya!');
```


və ya


```matlab
disp('Salam Dünya!');
```


və ya


```matlab
disp Salam_Dünya
```


və ya


```matlab
'Salam Dünya'
```


## [[Mirc|mIRC Script]]

```mirc
on 1:load:*: { echo Salam Dünya! }
```


## [[Oberon (proqramlaşdırma dili)|Oberon]]

```oberon2
MODULE SalamDunya;
IMPORT Write;
BEGIN
    Write.Line("Salam Dünya!");
END HalloWelt.
```


## [[Objective CAML|OCaml]]

```ocaml
print_endline "Salam Dünya!";;
```


## [[Objective C]]

```objc
#import <stdio.h>
int main()
{
  puts("Salam Dünya!");
  return 0;
}
```


### [[Objective-C]] [[Cocoa]] ilə

```objc
#import <Cocoa/Cocoa.h>
@interface Controller : NSObject
{
 NSWindow *window;
 NSTextField *textField;
}
@end
int main(int argc, const char *argv[])
{
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 NSApp = [NSApplication sharedApplication];
 Controller *controller = [[Controller alloc] init];
 [NSApp run];
 [controller release];
 [NSApp release];
 [pool release];
 return EXIT_SUCCESS;
}
@implementation Controller
- (id)init
{
 if ((self = [super init]) != nil) {
                textField = [[NSTextField alloc] initWithFrame:NSMakeRect(10.0, 10.0, 85.0, 20.0)];
                [textField setEditable:NO];
                [textField setStringValue:@"Salam Dünya!"];

                window = [[NSWindow alloc] initWithContentRect:NSMakeRect(100.0, 350.0, 200.0, 40.0)
                                                                                         styleMask:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask
                                                                                           backing:NSBackingStoreBuffered
                                                                                                 defer:YES];
                [window setDelegate:self];
                [window setTitle:@"Salam Dünya!"];
                [[window contentView] addSubview:textField];
                [window makeKeyAndOrderFront:nil];
 }

 return self;
}
- (void)windowWillClose:(NSNotification *)notification
{
 [NSApp terminate:self];
}

@end
```


## [[OpenLaszlo]]

```xml
<canvas>
   <text>Salam Dünya!</text>
</canvas>
```


## [[Oz (proqramlaşdırma dili)|Oz]]

```oz
{Show 'Salam Dünya'}
```


## [[Pascal]]

```pascal
program Hallo ( output );
begin
  writeln('Salam Dünya!');
end.
```


## [[PAWN]]

```c
main()
{
        printf("Salam Dünya!\n");
}
```


## [[PEARL]]

```pascal
MODULE (HALLOWELT);
    SYSTEM;
        TERMINAL:DIS<->SDVLS(2);

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

    MAIN:TASK;
       OPEN TERMINAL;
       PUT 'Hallo Welt!' TO TERMINAL;
       CLOSE TERMINAL;
   END;

MODEND;
```


## [[Perl]]

```perl
print "Salam Dünya!\n";
```


## [[PHP]]

```php-brief
<?php
    print "Salam Dünya!";
?>
```


və ya:


```php-brief
<?php
    echo "Salam Dünya!";
?>
```


və ya:


```php-brief
<?="Salam Dünya!"?>
```


## [[Pike (proqramlaşdırma dili)|Pike]]

```pike
int main() {
    write("Salam Dünya!\n");
    return 0;
}
```


## [[PL/I]]

```pli
Test: procedure options(main);
    put skip list("Salam Dünya!");
 end Test;
```


## [[PocketC]]
Konsole:

```c
main() {
  puts("Salam Dünya!");
}
```


## [[POV-Ray]]

```povray
camera {
 location <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"
 "Salam Dünya!", 0.015, 0
 pigment {
   color rgb <0, 0, 1>
 }
 translate -3*x
}
```


## [[Windows PowerShell|PowerShell]]

```powershell
"Salam Dünya!"
```


və ya:


```powershell
echo "Salam Dünya!"
```


və ya:


```powershell
[System.Console]::WriteLine("Salam Dünya!")
```


## [[Progress Software|Progress 4GL]]

```progress
DISPLAY "Salam Dünya!".
```

oder:

```progress
MESSAGE "Salam Dünya!"
   VIEW-AS ALERT-BOX INFO BUTTONS OK.
```


## [[Prolog dili]]

```prolog
?- write('Salam Dünya!'), nl.
```


## [[PureBasic]]

```purebasic
OpenConsole()
   Print("Salam Dünya!")
   Input() ;Beendet das Programm beim nächsten Tastendruck
 CloseConsole()
```


## [[Python (proqramlaşdırma dili)|Python]]
python 3-cü versiyaya qədər:


```python
print "Salam Dünya!"
```


pyton 3-cü versiyadan sonra (3-cü versiya daxil olmaqla):


```python
print("Salam Dünya")
```


## [[QBasic|QBASIC]]

```qbasic
PRINT "Salam Dünya!"
```


## [[GNU R|R]]

```bash
print ("Salam Dünya!")
```


və ya


```bash
cat ("Salam Dünya!\n")
```


## [[REXX]]

```bash
say "Salam Dünya!"
```


## [[Ruby]]

```ruby
puts "Salam Dünya!"
```


### [[Ruby]] [[GTK+]] ilə

```ruby
require "gtk2"
Gtk::Window.new("Salam Dünya!").show_all.signal_connect(:delete_event){Gtk.main_quit}
Gtk.main
```


### [[Ruby]] [[Tk (Toolkit)|Tk]] ilə

```ruby
require "tk"
TkRoot.new{ title "Salam Dünya!" }
Tk.mainloop
```


## SAC (Single Assignment C)

```c
use StdIO: all;
int main()
{
  printf("Salam Dünya!\n");
  return(0);
}
```


## [[SAS Base|SAS]]

```sas
data _null_;
   put "Salam Dünya!";
run;
```


## [[Scala]]

```scala
object HalloWelt extends Application {
  println("Salam Dünya!")
}
```


## [[Scheme]]

```scheme
(display "Salam Dünya!")
(newline)
```


## [[Smalltalk]]

```smalltalk
'Salam Dünya!' out.
```


## [[Spec-Sharp|Spec#]]

```csharp
using System;
 public class Programm
 {
    public static void Main(string![]! args)
    requires forall{int i in (0:args.Length); args[i] != null};
    {
        Console.WriteLine("Salam Dünya!");
    }
 }
```


## [[Standard ML]]

```ocaml
print "Salam Dünya!\n"
```


## [[SPL]]

```bash
debug "Salam Dünya!";
```


## [[SQL]]

```sql
SELECT 'Salam Dünya' AS message;
```


Oracle və MySQL üçün:

```sql
SELECT 'Salam Dünya!' FROM dual;
```


IBM-DB2 üçün:

```sql
SELECT 'Salam Dünya!' FROM sysibm.sysdummy1;
```


MSSQL, MySQL, PostgreSQL üçün:

```sql
SELECT 'Salam Dünya!';
```


## StarOffice Basic

```oobas
sub main
 print "Salam Dünya!"
 end sub
```


və ya:


```oobas
sub HalloWeltAlternativ
     MsgBox "Salam Dünya!"
 end sub
```


## [[Tcl]]

```tcl
puts "Salam Dünya!"
```


## [[Tcl/Tk]]

```tcl
label .l -text "Salam Dünya"
pack .l
```


## [[TeX]]

```latex
Salam, Dunya!\bye
```


## [[XOTcl]]

```tcl
proc hello {
puts "Salam Dünya!"
}
```


## [[Turing (proqramlaşdırma dili)|Turing]]

```bash
put "Salam Dünya!"
```


## [[Unix-Shell]]

```bash
echo 'Salam Dünya!'
```


## [[Verilog]]

```verilog
module salam_dunya;
initial begin
 $display ("Salam Dünya!");
 #10 $finish;
end
endmodule
```


## [[Very High Speed Integrated Circuit Hardware Description Language|VHDL]]

```vhdl
entity HelloWorld is
end entity HelloWorld;
architecture Bhv of HelloWorld is
begin
  HelloWorldProc: process is
  begin
    report "Salam Dünya!";
    wait;
  end process HelloWorldProc;
end architecture Bhv;
```


## [[VBScript]]

```vb
MsgBox "Salam Dünya!"
```


## [[Visual Basic .NET]]
Konsoldan:

```vbnet
Module Module1
    Sub Main()
        Console.WriteLine("Salam Dünya!")
    End Sub
End Module
```


Qrafik interfeyslə:

```vbnet
Class Salam
    Sub SalamDunya
       MsgBox("Salam Dünya")
    End Sub
End Class
```


## [[XML User Interface Language|XUL]]

```xml
<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<label value="Salam Dünya!"/>
</window>
```


## [[XAML]]

```xml
<?Mapping ClrNamespace="System" Assembly="mscorlib"
         xmlNamespace="http://www.gotdotnet.com/team/dbox/mscorlib/System" ?>
<Object xmlns="http://www.gotdotnet.com/team/dbox/mscorlib/System"
         xmlns:def="Definition" def:Class="MyApp.Hello">
    <def:Code>
    <![CDATA[
     Shared Sub Main()
     '{
         System.Console.WriteLine("Salam Dünya!")' ;
     '}
     End Sub
    ]]>
    </def:Code>
</Object>
```


## Həmçinin bax

## İstinadlar

## Xarici keçidlər