javascript-tutorial · szcsl · Jan 3, 2021 · Dec 19, 2020 · Dec 19, 2020 · Dec 19, 2020
diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md
@@ -1,63 +1,63 @@
-# Developer console
+# A developer console
 
-Code is prone to errors. You will quite likely make errors... Oh, what am I talking about? You are *absolutely* going to make errors, at least if you're a human, not a [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
+A kód hajlamos a hibákra. Te magad is elég nagy valószínűséggel fogsz hibákat ejteni a kódban... Sőt, szinte *biztos* hogy te is fogsz hibákat ejteni, amennyiben ember vagy, és nem csak egy [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
 
-But in the browser, users don't see errors by default. So, if something goes wrong in the script, we won't see what's broken and can't fix it.
+A probléma az, hogy a böngészőkben alapból nem látjuk a hibákat, tehát ha a szkriptben (script) valami probléma van nem fogunk tudni róla, és nem tudjuk majd mit kéne megjavítani.
 
-To see errors and get a lot of other useful information about scripts, "developer tools" have been embedded in browsers.
+Ahoz, hogy lássuk a hibákat, és egyéb hasznos információkat kaphassunk szkriptjeinkről, a böngészők beépítétettek valamit, amit mi "Developer Toolsnak" (Röviden: DevTools), vagy fejlesztői segédeszközöknek nevezünk.
 
-Most developers lean towards Chrome or Firefox for development because those browsers have the best developer tools. Other browsers also provide developer tools, sometimes with special features, but are usually playing "catch-up" to Chrome or Firefox. So most developers have a "favorite" browser and switch to others if a problem is browser-specific.
+A legtöbb fejlesztő a Chrome és a Firefoxot preferálja, ha fejlesztésről van szó, mivel azok rendelkeznek a legjobb DevTools felülettel. Egyéb böngészők is kínálnak a Chrome és a Firefoxéhoz hasonló DevTools felületeket, de az estek nagy részében ezek közelről sem olyan jók mint az előbbiekben felsoroltak. A legtöbb fejlesztőnek van egy "kedvenc" böngészője, és egy másikra váltanak ha csak egy bizonyos böngészőre exkluzív (browser-specific) problémát találnak.
 
-Developer tools are potent, they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
+A DevToolsok szinte nélkülözhetetlenek, tekintve a sok hasznos funkciót amit kínálnak. Először azt fogjuk megtanulni, hogy ezeket az eszközöket hogyan nyissuk meg, hogyan keressünk vele hibákat és futtassunk benne JavaScript parancsokat.
 
 ## Google Chrome
 
-Open the page [bug.html](bug.html).
+Nyisd meg a [bug.html](bug.html) oldalt.
 
-There's an error in the JavaScript code on it. It's hidden from a regular visitor's eyes, so let's open developer tools to see it.
+Ezen az oldalon, a látogató szemei elől rejtve található egy hiba, úgyhogy nyissuk meg a DevTools ablakot, és nézzük meg mi lehet az a hiba!
 
-Press `key:F12` or, if you're on Mac, then `key:Cmd+Opt+J`.
+Nyomd meg a `F12` gombot, vagy ha Mac rendszert használasz, akkor a `Cmd+Opt+J`-t, hogy megnyisd a Developer Tools ablakot.
 
-The developer tools will open on the Console tab by default.
+A DevTools ablak alapból a console résznél fog megnyílni.
 
-It looks somewhat like this:
+Az utóbbinak, ha minden igaz így kell kinéznie:
 
 ![chrome](chrome.png)
 
-The exact look of developer tools depends on your version of Chrome. It changes from time to time but should be similar.
+A Developer Tools ablaknak a pontos kinézete Chrome verziótól függően változhat, de ha minden igaz az utóbbihoz hasonlóan fog kinézni fog..
 
-- Here we can see the red-colored error message. In this case, the script contains an unknown "lalala" command.
-- On the right, there is a clickable link to the source `bug.html:12` with the line number where the error has occurred.
+- Itt láthatjuk piros színnel jelölve a hibaüzenetet. Ebben az esetben a hiba szerint a szkriptünk tartalmaz egy ismeretlen "lalala" nevű parancsot.
+- A jobb oldalon láthatunk egy klikkelhető linket `bug.html:12` néven. Ebben a linkben a `bug.html` a fájlnak a neve ahol a hiba van és a `:12` az annak a sornak a száma amiben a hibát okozó parancs van.
 
-Below the error message, there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands. Press `key:Enter` to run them.
+A hibaüzenet alatt található kék `>` szimbólum az a parancssort azaz a "command line"-t jelzi, ahova parancsokat írhatunk be, amit aztán az `Enter` billentyű használatatával futtathatunk.
 
-Now we can see errors, and that's enough for a start. We'll come back to developer tools later and cover debugging more in-depth in the chapter <info:debugging-chrome>.
+Most, hogy látjuk a hibákat, egyelőre megállhatunk itt. Később még visszatérünk a DevToolsra, és majd még mélyebbre merülünk a hibák elhárításában egy következő fejezetben <info:debugging-chrome>.
 
 ```smart header="Multi-line input"
-Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+Alapból, ha beírunk egy sor kódot a consoleba és megnyomjuk az Enter gombot, a parancs rögtön le is fut.
 
-To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+Ahoz hogy több sorban írjunk, nyomd meg a `Shift+Enter` gombokat. Ez úton egy nagyabb adag JavaScript kódot is kényelemesen be lehet gépelni.
 ```
 
-## Firefox, Edge, and others
+## Firefox, Edge, és egyéb böngészők
 
-Most other browsers use `key:F12` to open developer tools.
+A böngészők nagyrészénél az `F12` gomb lenyomásával lehet megnyitni a Developer Tools ablakot.
 
-The look & feel of them is quite similar. Once you know how to use one of these tools (you can start with Chrome), you can easily switch to another.
+A kinézetük, felületük és használatuk legtöbbször nagyon hasonló, ezért ha az egyik böngészőjét megtanultad használni, a többi is már viszonylag könnyen fog menni.
 
 ## Safari
 
-Safari (Mac browser, not supported by Windows/Linux) is a little bit special here. We need to enable the "Develop menu" first.
+Safari, a Mac saját (Windows/Linux által nem támogatott) böngészője ezen a téren kicsit kilóg a sorból. Itt először manuálisan kell bekapcsolnunk a fejlesztői menüt, más néven a "Develop Menu"-t
 
-Open Preferences and go to the "Advanced" pane. There's a checkbox at the bottom:
+Nyisd meg a preferenciák (Preferences) menüt, majd nyomj rá az "Advanced" menüpontra, aminek az alján fogsz látni egy kicsi jelölőnégyzetet, amit be is pipálhatunk.
 
 ![safari](safari.png)
 
-Now `key:Cmd+Opt+C` can toggle the console. Also, note that the new top menu item named "Develop" has appeared. It has many commands and options.
+Mostmár a `Cmd+Opt+C` gombkombinációval végre megnyithatjuk a consolet! Emellett, még észrevehető változás, hogy egy "Develop" névre hallgató menüpont megjelent. Az utóbbiban még több hasznos funkciót tudunk majd elérni!
 
-## Summary
+## Összesítés
 
-- Developer tools allow us to see errors, run commands, examine variables, and much more.
-- They can be opened with `key:F12` for most browsers on Windows. Chrome for Mac needs `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (need to enable first).
+- A DevTools sok dologban segíthet. Ezek között van például a hibák megjelenítése, parancsok futtatása és még sok minden más is!
+- A legtöbb Windowsos böngészőben az `F12`, a Macre való Chromeban a `Cmd+Opt+J`-vel, a Safariban pedig a `Cmd+Opt+C` gombokkal nyithatjuk meg (az utóbbiban először a beállításokban be kell kapcsolni).
 
-Now we have the environment ready. In the next section, we'll get down to JavaScript.
+Most, hogy a fejlesztői környezetünk készen áll, nekiállhatunk a JavaScripthez!
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
@@ -1,89 +1,89 @@
-# The modern mode, "use strict"
+# A modern mode, "use strict"
 
-For a long time, JavaScript evolved without compatibility issues. New features were added to the language while old functionality didn't change.
+Egy hosszú ideig a JavaScript kompatibilitási hibák nélkül fejlődött. Új funkciók gyakran jelentek meg, ám a régiek viszont sosem változtak.
 
-That had the benefit of never breaking existing code. But the downside was that any mistake or an imperfect decision made by JavaScript's creators got stuck in the language forever.
+Ennek nagy előnye volt, hogy a kódot bármikor is írták mindig helytálló maradt, ám viszont azzal hogy a régi dolgok sosem változtak azzal az a nagy baj, hogy bármilyen imperfekciót is ejtettek a JavaScript készítői, az örökre a nyelvben ragadt.
 
-This was the case until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most such modifications are off by default. You need to explicitly enable them with a special directive: `"use strict"`.
+Ez volt a helyzet, míg 2009-ben meg nem jelent az ECMAScript 5 (ES5). Az ES5 sok új funkciót hozott a JS-be és sok régit is megváltoztatott. Ahoz hogy a régi kód továbbá is működőképes maradhasson, ezeknek a változtatásoknak nagy részét alapból kikapcsolták. Ezeket a funciókat egy különleges diretívával kapcsolhatjuk be, a `"use strict"`-el.
 
 ## "use strict"
 
-The directive looks like a string: `"use strict"` or `'use strict'`. When it is located at the top of a script, the whole script works the "modern" way.
+Ez a direktíva pontosan úgy néz ki mint egy átlagos szöveg (string) objektum: `"use strict"`, vagy `'use strict'`. Mikor ezt a direktívát a szkript tetejére hejezed, akkor az a szkriptet arra utasítja, hogy a "modern módon" működjön.
 
-For example:
+Példa:
 
 ```js
 "use strict";
 
-// this code works the modern way
+// ez a kód a modern úton fog működni
 ...
 ```
 
-Quite soon we're going to learn functions (a way to group commands), so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
+Nemsokára külön tanulni fogunk a függvényekről (egy mód JS parancsok csoportosítására), de előre lefektethetjük, hogy a `"use strict"`-et tudjuk használni függvények elején. Ezzel azt érhetjük el, hogy csak azon a függvényen belül fusson modern módon a kód. De általában az egész szkriptre szokták használni a `"use strict"`-et.
 
-````warn header="Ensure that \"use strict\" is at the top"
-Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.
+````warn header="Győződj meg róla, hogy a \"use strict\" mindig a szkript tetején van!"
+Fontos, hogy a `"use strict"` **mindig** a szkript elején legyen, különben a modern mód nem lesz bekapcsolva.
 
-Strict mode isn't enabled here:
+Ebben a példában a `"use strict" hibás elhelyezkedése miatt a modern mód nem lesz bekapcsolva`:
 
 ```js no-strict
-alert("some code");
-// "use strict" below is ignored--it must be at the top
+alert("valami");
+// a "use strict"-et ignorálja a kód, hacsak nem a szkript, vagy egy függvény legelején van.
 
 "use strict";
 
-// strict mode is not activated
+// a strict mode ki van kapcsolva
 ```
 
-Only comments may appear above `"use strict"`.
+A `"use strict"` felé csak kommenteket szabad tenni.
 ````
 
-```warn header="There's no way to cancel `use strict`"
-There is no directive like `"no use strict"` that reverts the engine to old behavior.
+```warn header="A `use strict`-et nem lehet utólag kikapcsolni"
+Nincsen olyan direktíva, mint például egy `"no use strict"`, ami visszaállítaná a motort a régi viselkedési módra.
 
-Once we enter strict mode, there's no going back.
+Ha egyszer bekapcsoltad a strict modeot, nincs visszaút.
 ```
 
-## Browser console
+## Használat a böngészők consolejain belül
 
-When you use a [developer console](info:devtools) to run code, please note that it doesn't `use strict` by default.
+Ha a [fejlesztői consolet](info:devtools) használod a kódod futtatására, akkor fontos, hogy az utóbbi alapból nem használ `strict mode`-ot.
 
-Sometimes, when `use strict` makes a difference, you'll get incorrect results.
+Bizonyos alkalmakkor, amikor a `use strict` különbséget tesz, akkor nem kívánt eredményeket kaphatsz.
 
-So, how to actually `use strict` in the console?
+De akkor hogyan is használjuk helyesen a `use strict`-et a consoleban?
 
-First, you can try to press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, like this:
+Először is, megpróbálhatod a `Shift+Enter` gombok lenyomásával több sorba írni a kódot, majd az egész legetetejére odatenni a `use strict`-et. Az utóbbi valahogy így fog kinézni:
 
 ```js
-'use strict'; <Shift+Enter for a newline>
-//  ...your code
-<Enter to run>
+'use strict'; <Shift+Enter, hogy új sort kezdj>
+//  ...a kódod
+<Nyomd meg az entert a futtatáshoz>
 ```
 
-It works in most browsers, namely Firefox and Chrome.
+Ez a legtöbb böngészőben (mint például a Chrome vagy a Firefox) működik.
 
-If it doesn't, e.g. in an old browser, there's an ugly, but reliable way to ensure `use strict`. Put it inside this kind of wrapper:
+Ha esetleg mégse (például egy régi böngészőben), akkor van egy csúnya, de megbízható megoldás a `use strict` használatára. Egy ilyesmi kód blokkra lesz szükségünk:
 
 ```js
 (function() {
   'use strict';
 
-  // ...your code here...
+  // ...a kód hátralévő része...
 })()
 ```
 
-## Should we "use strict"?
+## Használjuk-e a "use strict"-et?
 
-The question may sound obvious, but it's not so.
+Ez a kérdés, míg először eléggé egyértelműnek hangzik, a valóságban nem az.
 
-One could recommend to start scripts with `"use strict"`... But you know what's cool?
+Ugye, egyesek azt ajánlanák, hogy használd előszeretettel a `"use strict"`-et ...De tudod mi itt a menő dolog?
 
-Modern JavaScript supports "classes" and "modules" - advanced language structures (we'll surely get to them), that enable `use strict` automatically. So we don't need to add the `"use strict"` directive, if we use them.
+A modern JavaScript támogat olyanokat mint például a "class"-ek és a "module"-ok (majd azokat is tanulni fogjuk), amik automatikusan engedélyezik a `"use strict"`-et. Tehát ha ilyenek vannak a kódunkban, a `"use strict"`-et nyugodtan nélkülözhetjük.
 
-**So, for now `"use strict";` is a welcome guest at the top of your scripts. Later, when your code is all in classes and modules, you may omit it.**
+**Tehát egyelőre a `"use strict";` az csak egy kis extra a szkriptjeink elején. Később, amikor a kódunk tele lesz modulokkal és classokkal, már nyugodtan kihagyhatjuk a `"use strict"`-et.**
 
-As of now, we've got to know about `use strict` in general.
+Jelenleg, az alapok miatt jó tudni a `use strict` létezéséről.
 
-In the next chapters, as we learn language features, we'll see the differences between the strict and old modes. Luckily, there aren't many and they actually make our lives better.
+A következő fejezetekben tanulunk majd egy kicsit a nyelvi funckiókról és az új és régi módok közti különbségekről. Szerencsénkre az utóbbiakból nincsen sok, és azok amik vannak azok is csak a mi dolgunkat fogják könnyíteni.
 
-All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
+Az ebben a fejezetben lévő példák mind elvárják a "strict mode" használatát, hacsak ennek az állításnak hamisságát nem fejeztük ki előre.