Անվան այլ կիրառումների համար տե՛ս՝ D (այլ կիրառումներ)

**D–ն**, օբյեկտակողմնորորշված, համակարգային ծրագրավորման լեզու է։ Ստեղծել է Ուոլթեր Բրայթը (անգլ. *Walter Bright*)։ D–ի ստեղծումը և զարգացումը սկսվել է 1999 թվականին և առաջին անգամ թողարկվել է 2001 թվականին։ Հիմնական տարբերակը՝ D (1.0), թողարկվել է 2007 թվականին։ Արդեն կա նաև D2 տարբերակը։ D–ի քերականությունը նման է C–ին։ D–ն շատ նմանություններ ունի C–ի և C++–ի հետ, սակայն ունի նաև թվարկված լեզունների հետ կապ չունեցող առանձնահատկություններ։
D–ն բազմաբնույթ նմուշային ծրագրավորման լեզու է, այսինքն՝ նրանում առկա են օբյեկտային կողմնորոշվածություն, մետածրագրավորում, ֆունկցիոնալ և մրցակցային ծրագրավորում։

Հիմնական քերականություն
-----------------------

```
import std.stdio;

void main(string[] args)
{
 writeln("test!");
}

```

Ծրագրի օգտագործման տարբերակը

```
$ dmd test.d
$ ./test

```

Արդյունքում կտպի

```
test

```

Փոփոխականներ
------------

Փոփոխականները D–ում ունեն բնորոշ տիպերը, որը որոշում է տրված փոփոխականի չափսը հիշողության տարածքում։ Փոփոխականները D–ում կարող են լինել հետևյալ տիպերի.
*char, int, float, double, void*։
Փոփոխականների օգտագործման օրինակ՝

```
import std.stdio;

int a = 10, b =10;
int c;
float f;

int main ()
{
 writeln("Value of a is : ", a);
 
 int a, b;
 int c;
 float f;

 
 a = 30;
 b = 40;
 writeln("Value of a is : ", a);
 c = a + b;
 writeln("Value of c is : ", c);

 f = 70.0/3.0;
 writeln("Value of f is : ", f);
 return 0;
}

```

Կոմպիլյացիայի արդյունքում հետևյալ պատասխանը ցույց կտա՝

```
Value of a is : 10
Value of a is : 30
Value of c is : 70
Value of f is : 23.3333

```

Պայմանագրային ծրագրավորումը D–ում
---------------------------------

Պայմանագրային ծրագրավորումը D–ում կենտրոնացված է, որպեսզի ապահովի պարզ և հասկանալի միջոցներ սխալների հայտնաբերման համար։ Այն D–ում իրականացվում է երեք տարբերակով՝

1)body block

2)in block

3)out block

body block–ը պարունակում է արդիական ֆունկցիոնալություն կոդի կատարման համար։ In և out block–ները գործում են, քանի դեռ body block պարտադիր է։ Սովորական քերականությունը տրված է այստեղ։

```
 
return\_type function\_name(function\_params)
in
{
 // բլոկում
}
out (result)
{
 // բլոկում
}
body
{
 // արդիական ֆունկցիայի բլոկում
}

```

in block–ը նախատեսված է սովորական նախապայմանների համար, որպեսզի ստուգի, թե ներմուծված պարամետրերը ընդունելի են թե ոչ և տրված տիրույթում կարող են հայտնաբերվել կոդի օգնությամբ։Block–ի առավելությունն այն է, որ բոլոր մուտքային պայմանները պահվում են միասին և բաժանվում են ֆունկցիայի գործող մասից։

```
 
import std.stdio;
import std.string;

bool isValid(string password)
in
{
 assert(password.length>=5);
}
body
{
 // ուրիշ պայմաններ
 return true;
}

void main()
{
 writeln(isValid("password"));
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
true

```

out block–ը ապահովում է ֆունկցիայի վերադարձնող արժեքները։ Այն հաստատում է, որ վերադարձնող արժեքը գտնվում է ակնկալվող տիրույթում։

```
import std.stdio;
import std.string;

double getAge(double months,double years)
in
{
 assert(months >= 0);
 assert(months <= 12);
}
out (result)
{
 assert(result>=years);
}
body
{
 return years + months/12;
}

void main ()
{
 writeln(getAge(10,12));
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
12.8333

```

Խառնուրդներ (Mixins)
--------------------

```
Խառնուրդը (Mixins) կառուցվածք է, որը հնարավորություն է տալիս գեներացվող կոդի միացումը սկզբնական կոդի։ Լինում է երեք տարբերակ
```

1) String Mixins

2)Template Mixins

3)Mixin name spaces

**String Mixins**
D–ն հնարավորություն ունի մուտքագրել տողը որպես long, եթե իհարկե այդ տողը հայտնի է կոմպիլացիայի ժամանակ։

```
mixin (compile\_time\_generated\_string)

```

Տվյալ օրինակը ցույց է տալիս տողային խառնուրդը (Mixins)։

```
import std.stdio;

void main()
{
 mixin(`writeln("Hello World!");`);
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
Hello World!

```

Կարելի է նաև ներկայացնել մեկ այլ օրինակ, որտեղ կարելի է փոխանցել տողը կոմպիլիացյիայի ընթացքում, այնպես որ խառնուրդը (Mixins) կարող է օգտագործել ֆունկցիան կրկնակի օգտագործման համար։

```
import std.stdio;

string print(string s)
{
 return `writeln("` ~ s ~ `");`;
}

void main()
{
 mixin (print("str1"));
 mixin (print("str2"));
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
str1
str2

```

**Template Mixins**
D–ն սահմանում է ընդհանուր կոդի կաղապարները, որպեսզի կոմպիլիատորը գեներացնի ընդհանուր օրինակները տրված կաղապարներից։ Կաղապարները կարող են գեներացնել կառուցվածքներ, կլասներ, ֆունկցիաներ։

```
mixin a\_template!(template\_parameters)

```

Սովորական օրինակը տրված է այստեղ։

```
import std.stdio;

template Department(T, size\_t count)
{
 T[count] names;

 void setName(size\_t index, T name)
 {
 names[index] = name;
 }

 void printNames()
 {
 writeln("The names");

 foreach (i, name; names) 
 {
 writeln(i," : ", name);
 }
 }
}

struct College
{
 mixin Department!(string, 2);
}

void main()
{
 auto college = College();

 college.setName(0, "name1");
 college.setName(1, "name2");

 college.printNames();
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
The names
0 : name1
1 : name2

```

**Mixin name spaces**
Mixin name space–ը օգտագործում են, որպեսզի խուսափեն կաղապարների երկիմաստություններից։ Որպես օրինակ կարեի է դիտարկել երկու փոփոխականներ, որոնցից մեկը հայտատրված է main–ում, իսկ մյուսը միքսին է։ Եթե խառնուրդի (Mixins) անունը նույնն է, ինչ որ շրջակա շրջանակում, ապա օգտագործվում է այդ անունը։

```
import std.stdio;

template Person()
{
 string name;
 void print()
 {
 writeln(name);
 }
}

void main()
{
 string name;

 mixin Person a;

 name = "name 1";
 writeln(name);

 a.name = "name 2";
 print();
}

```

Երբ վերը նշված կոդը կոմպիլացվում և կատարվում է, ցույց է տալիս հետևյալ պատասխանը։

```
name 1
name 2

```

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * դ
* ք
* խ
Հիմնական ծրագրավորման լեզուները (համեմատումը  • IDE  • պատմությունը  • ժամանակագրութունը) |
| --- |
|  |
| Օգտագործվողլեզուները | 
Ada •
APL •
Ասեմբլեր •
ActionScript •
ABAP/4 •
AutoIt •
AWK •
Basic •
C •
Կոբոլ •
C++ •
C# •
Cω •
Clarion •
Clojure •
ColdFusion •
Common Lisp •
D •
dBase •
Delphi •
Eiffel •
Erlang •
Euphoria •
F# •
Fort •
Fortran •
Gambas •
Go •
Groovy •
HAL/S •
Haskell •
Icon •
Ջավա •
ՋավաՍկրիպտ •
Limbo •
Lua •
Mudula-3 •
Object Pascal •
Objective-C •
OCaml •
Oz •
Parser •
Pascal •
Perl •
PHP •
PowerBASIC •
Python •
PL/1 •
Prolog •
R •
Ruby •
Scala •
Scheme •
Smalltalk •
SQL •
Standard ML •
PL/SQL •
Tcl •
Vala •
Visual Basic
(.NET)
 |
|  |
| Ուսումնական | 
Agda •
Clean •
Curry •
Logo •
ML •
REFAL •
Simula •
Oberon
 |
|  |
| IEC 61131-3 | 
Instruction List •
ST •
FBD •
Ladder Diagram (LD) •
SFC
 |
|  |
| Այլ | 
Modula-2 •
Miranda •
Hope •
Rexx
 |
|  |
| Էզոտերիկ | 
HQ9+/HQ9++ •
INTERCAL •
Brainfuck •
Brainfork •
Befunge •
Malbolge •
Piet •
Spoon •
Unlambda •
Whitespace •
FALSE •
LOLCODE
 |
|  |
| Վիզուալ | 
G
(LabVIEW) •
Microsoft VPL •
Sikuli •
VisSim •
Scratch
 |

 |