add Hungarian translation (#1874)

hu-hu/typescript-hu.html.markdown

@@ -0,0 +1,174 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Tamás Diószegi", "https://github.com/ditam"]
+filename: learntypescript-hu.ts
+---
+
+A TypeScript nyelv a JavaScript nyelven írt nagy méretű alkalmazások fejlesztését kívánja megkönnyíteni.
+A TypeScript olyan, más nyelvekből ismert gyakori fogalmakat ad hozzá a JavaScripthez, mint például osztályok, interfészek, generikusság, és (opcionális) statikus típusosság.
+A JavaScript egy befoglaló halmazát képzi: minden JavaScript kód érvényes TypeScript kód, így könnyen hozzáadható meglévő projektekhez. A TypeScript fordító kimenetként JavaScript kódot állít elő.
+
+Ez a dokumentum a TypeScript által hozzáadott új szintaxissal foglalkozik, nem pedig a [Javascripttel](../javascript/).
+
+Hogy kipróbáld a TypeScript fordítót, látogass el a [Játszótérre avagy Playground-ra](http://www.typescriptlang.org/Playground) ahol kódot írhatsz automatikus kódkiegészítéssel, és közvetlenül láthatod az előállított JavaScript kódot.
+
+```js
+// 3 alapvető típus létezik TypeScriptben
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Amikor nem lehet a típust előre tudni, használható az "Any" típus
+var notSure: any = 4;
+notSure = "talán mégis sztring lesz";
+notSure = false; // tévedtem, mégis boolean
+
+// Kollekciókból létezik típusos és generikus tömb
+var list: number[] = [1, 2, 3];
+// ugyanez a generikus típus használatával
+var list: Array<number> = [1, 2, 3];
+
+// Enumerált típusok:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Végül, "void" használható a visszatérési értékkel nem bíró függvényeknél
+function bigHorribleAlert(): void {
+  alert("Kis idegesítő doboz vagyok!");
+}
+
+// A függvények elsőrangú (first-class) típusok, használható a vastag nyilas
+// lambda szintaxis,
+// a compiler pedig kikövetkezteti a típusokat (inferred types)
+
+// A következők egyenértékűek, ugyanaz a szignatúra kerül kikövetkeztetésre, és
+// így ugyanaz a JavaScript kód lesz előállítva
+var f1 = function(i: number): number { return i * i; }
+// Következtetett visszatérési értékkel
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Következtetett visszatérési értékkel
+var f4 = (i: number) => { return i * i; }
+// Következtetett visszatérési értékkel, 
+// ebben az egysoros formában nem szükséges a return kulcsszó
+var f5 = (i: number) =>  i * i;
+
+// Az interfészek szerkezeti alapon működnek, vagyis minden objektum, ahol 
+// jelen vannak a megfelelő mezők kompatibilis az interfésszel
+interface Person {
+  name: string;
+  // Az opcionális tagokat "?" jelöli
+  age?: number;
+  // És persze függvények is:
+  move(): void;
+}
+
+// Egy objektum, ami megvalósítja a "Person" interfészt
+// Tekinthető Personnek, hiszen van name és move mezője
+var p: Person = { name: "Bobby", move: () => {} };
+// Egy objektum, ahol az opcionális mező is jelen van:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Ez viszont nem Person, mert az age mező típusa nem szám!
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Az interfészekkel függvény típusok is leírhatóak:
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Csak a paraméterek típusai számítanak, a neveik nem.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Osztályok - a mezők alapértelmezésben publikusak
+class Point {
+    // Mezők
+    x: number;
+
+    // Konstruktor - a public/private kulcsszavak ebben a kontextusban
+    // legenerálják a mezőkhöz szükséges kódot a konstruktorban.
+    // Ebben a példában az "y" ugyanúgy definiálva lesz, mint az "x", csak 
+    // kevesebb kóddal.
+    // Alapértelmezett (default) értékek is megadhatóak.
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Metódusok
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Statikus mezők
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y itt 0 lesz
+
+// Öröklés
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Szükséges az ősosztály konstruktorának explicit hívása
+    }
+
+    // Felülírás
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Modulok
+// ("." használható az almodulok számára)
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Új lokális név definiálása a module számára
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Generikus típusok
+// Osztályok
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfészek
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// és függvények
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// definíciós fájl hivatkozása:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## További források
+ * [TypeScript hivatalos weboldala] (http://www.typescriptlang.org/)
+ * [TypeScript nyelv specifikációja (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Forráskód GitHubon] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - típusdefiníciók gyűjteménye] (http://definitelytyped.org/)