diff --git a/.gitignore b/.gitignore
index fecb262f..c37ad084 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,16 @@
-/site/index.html
 /build
 /html
 /log
 /node_modules
-/site/de
-/site/ru
-/site/zh
-/site/en
-/site/fi
-/site/tr
+/.idea/*
+
+/site
+!/site/favicon.ico
+!/site/image
+!/site/javascript
+!/site/style
+!/site/style
+
 *.md~
 *.src.md
+*.DS_store
diff --git a/.lvimrc b/.lvimrc
new file mode 100644
index 00000000..23b445a9
--- /dev/null
+++ b/.lvimrc
@@ -0,0 +1,4 @@
+set wildignore=node_modules
+set tabstop=2
+set shiftwidth=2
+set softtabstop=2
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..fe3c6b6f
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,19 @@
+# Contributing to Javascript Garden
+
+1. We're about Javascript AKA [ECMA script](http://www.ecma-international.org/ecma-262/5.1/) not a specific implementation. So we don't cover issues specific to one environment or interpreter, like browsers or V8 for node.
+1. Micro-performance is out of scope: anything that's not a result of essential algorithmic complexity (e.g O(log n) vs O(n^2)) is down to a specific version of a specific interpreter (see 1).
+1. Please test code examples to ensure they work, there's nothing more confusing than incorrect examples!
+1. Contributing to JS Garden makes you a fantastic person, and Brendan Eich will find you immensely attractive.
+
+Thank you for being kind enough to help out!
+
+## Testing locally
+
+1. Run `npm run build` to build
+1. Run a webserver from the root of the repo to view
+
+## Getting changes merged
+
+1. Squash your changes into one commit
+1. Make sure the site still works :)
+1. Make a PR
diff --git a/JavaScript-Garden b/JavaScript-Garden
new file mode 120000
index 00000000..dcc6db5e
--- /dev/null
+++ b/JavaScript-Garden
@@ -0,0 +1 @@
+./site
\ No newline at end of file
diff --git a/README.md b/README.md
index 6371eb25..be02cfd5 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,18 @@
 JavaScript Garden
 =================
 
+2024 update: this project has not been actively maintained in years. The original author
+[took the site down](https://github.com/BonsaiDen/JavaScript-Garden/commit/93278fbcafa569fd193f8784abc267e9db09c645) 
+in 2022 (no judgement - updating it would be a big project!). At that point it was already long out of date, e.g. missing
+the new language features from ES6 onwards.
+
+Many excellent modern guides exist, e.g. [Eloquent Javascript](https://eloquentjavascript.net/), or
+the [MDN guide](https://developer.mozilla.org/en-US/docs/Web/JavaScript).
+
+Thanks for all the maintainers and translators over the years!
+
+-----
+
 **JavaScript Garden** is a growing collection of documentation about the most 
 quirky parts of the JavaScript programming language. It gives advice to 
 avoid common mistakes, subtle bugs, as well as performance issues and bad 
@@ -15,12 +27,15 @@ the excellent [guide][1] on the Mozilla Developer Network.
 ### The authors
 
 This guide is the work of two lovely Stack Overflow users, [Ivo Wetzel][6]
-(Writing) and [Zhang Yi Jiang][5] (Design).
+(Original English Language Version) and [Zhang Yi Jiang][5] (Design), and
+[many others](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+who've worked hard to provide translations or fixes.
+
+It was maintained by [Tim Ruffles](http://twitter.com/timruffles) from 2013-2020ish.
 
-### Contributors
+## Contributing
 
- - [Caio Romão][8] (Spelling corrections)
- - [Andreas Blixt][9] (Language corrections)
+Please submit fixes and translations as [pull requests](https://help.github.com/articles/using-pull-requests).
 
 ### License
 
diff --git a/build.js b/build.js
index 7fb93be0..0c7be50a 100644
--- a/build.js
+++ b/build.js
@@ -1,206 +1,106 @@
-var fs = require('fs'),
-    path = require('path');
-    jade = require('jade'),
-    md = require('node-markdown'),
-    Class = require('neko').Class;
-
-var format = new require('fomatto').Formatter();
-
-
-// Garden Generator -------------------------------------------------------------
-// ------------------------------------------------------------------------------
-var Garden = Class(function(options) {
-    var languages = fs.readdirSync(options.dir);
-
-    this.languages = {};
-    this.options = options;
-    this.options.language = this.json([this.options.dir, 'language.json'].join('/'));
-
-    var that = this;
-    languages.forEach(function(lang) {
-        if (fs.statSync(that.options.dir + '/' + lang).isDirectory()) {
-            that.log('Parsing language "{}"...', lang);
-            that.lang = {
-                id: lang,
-                navigation: [],
-                index: []
-            };
-
-            if (that.loadIndex()) {
-                that.languages[lang] = that.lang;
-                that.log('    Done.')
-
-            } else {
-                that.log('    Error: Could not find "index.json"!')
-            }
-        }
-    });
-
-    delete this.lang;
-    this.log('');
-    this.generateAll();
-
-}, {
-    log: function() {
-        console.log(format.apply(null, arguments));
-    },
-
-    loadIndex: function() {
-        var that = this;
-        this.lang.index = this.json([this.options.dir,
-                                     this.lang.id, 'index.json'].join('/'));
-
-        if (this.lang.index === null) {
-            return false;
-        }
-
-        that.lang.title = that.lang.index.langTitle;
-        this.lang.navigation = [];
-        this.lang.index.sections.forEach(function(section, i) {
-            that.loadSection(section);
-            that.lang.navigation.push({
-                title: section.title,
-                link: section.dir,
-                articles: section.articles,
-                parsed: section.parsed
-            });
-        });
-        return true;
-    },
-
-    loadSection: function(section) {
-        var files = fs.readdirSync(this.folder(section.dir));
-        section.parsed = {};
-        section.link = section.dir;
-
-        var that = this;
-        section.articles = section.articles || [];
-        section.articles.concat('index').forEach(function(article, e) {
-            if (files.indexOf(article + '.md') !== -1) {
-                var parsed = that.parseArticle(that.md(section.dir, article));
-                section.parsed[article] = parsed;
-                if (section.articles.indexOf(article) !== -1) {
-                    section.articles[e] = {
-                        id: article,
-                        link: section.link + '.' + article,
-                        title: parsed.title,
-                        parsed: parsed
-                    };
-                }
-            }
-        });
-    },
-
-    parseArticle: function(text) {
-        var title = text.substring(0, text.indexOf('\n'));
-        text = text.substring(title.length);
-        title = md.Markdown(title.replace(/\#/g, '').trim());
-        text = this.toMarkdown(text);
-
-        var parts = text.split('<h3>');
-        var subs = [];
-        for(var i = 0, l = parts.length; i < l; i++) {
-            var sub = parts[i];
-            subs.push((i > 0 ? '<h3>' : '') + sub);
-        }
-
-        return {
-            title: title.substring(3, title.length - 4),
-            text: text,
-            subs: subs
-        };
-    },
-
-    toMarkdown: function(text) {
-        text = md.Markdown(text).replace(/'/g,'&#39;');
-        text = text.replace(/<blockquote>/g, '<aside>').
-                    replace(/<\/blockquote>/g, '</aside>');
-
-        return text.replace(/<aside>\s+<p><strong>ES5/g,
-                            '<aside class="es5"><p><strong>ES5');
-    },
-
-    json: function(file) {
-        try {
-            return JSON.parse(fs.readFileSync(file).toString());
-
-        } catch (err) {
-            return null;
-        }
-    },
-
-    md: function(section, article) {
-        var file = [this.folder(section), article].join('/') + '.md';
-        return fs.readFileSync(file).toString();
-    },
+var fs = require("fs");
+var _ = require("lodash");
+var jade = require('jade');
+var md = require("marked");
+
+function main(opts) {
+  loadLanguages(opts.languagesDir)
+  .sort(function(a,b) {
+    return a.id > b.id ? 1 : -1
+  })
+  .forEach(function(lang,_,languages) {
+    outputLanguage(lang,languages,opts);
+  });
+}
 
-    folder: function(section) {
-        return [this.options.dir, this.lang.id, section].join('/');
-    },
+function loadLanguages(path) {
+  var index = readJson(path + "/language.json");
+  var availableListedLanguages = _.intersection(index.listed,fs.readdirSync(path));
+  return availableListedLanguages.reduce(function(all,lang) {
+    var langPath = path + "/" + lang;
+    if(!fs.statSync(langPath).isDirectory()) return all;
+    var data = _.extend(loadLanguage(langPath),{id: lang});
+    return all.concat(data);
+  },[]);
+}
 
-    render: function(language, template, out) {
-        var lang = this.languages[language];
-        if (lang) {
-            this.log('Rendering "{}" to "{}"...', language, out);
+function loadLanguage(path) {
+  var index = readJson(path + '/index.json');
+  var language = _.extend(index,{
+    sections: index.sections.map(function(section) {
+      return _.extend(section,{
+        link: section.dir,
+        isIntro: section.dir == "intro",
+        articles: section.articles.map(function(article) {
+          return _.extend({
+            link: section.dir + "." + article
+          },loadArticle(path + "/" + section.dir + "/" + article + ".md"));
+        })
+      })
+    })
+  });
+  language.navigation = language.sections;
+  return language;
+}
 
-            var languages = [];
-            for(var i in this.languages) {
-                if (this.languages.hasOwnProperty(i)) {
-                    if (this.options.language.listed.indexOf(i) !== -1) {
-                        languages.push(this.languages[i]);
-                    }
-                }
-            }
+function loadArticle(path) {
+  var text = fs.readFileSync(path,"utf8");
+  var title = text.substring(0, text.indexOf('\n'));
+  text = text.substring(title.length);
+  title = md(title.replace(/\#/g, '').trim());
+  var titleText = title.substring(3, title.length - 5);
+  text = processArticleBody(text);
+
+  var parts = text.split('<h3>');
+  var subs = parts.map(function(sub,i) {
+    return (i > 0 ? '<h3>' : '') + sub;
+  });
+
+  return {
+    title: titleText,
+    text: text,
+    subs: subs
+  };
+}
 
-            var options = {
-                pathPrefix: this.options.pathPrefix,
-                baseLanguage: this.options.language.default,
-                language: language,
-                languages: languages,
-                title: lang.index.title,
-                description: lang.index.description,
-                navigation: lang.navigation,
-                sections: lang.index.sections,
-                top: lang.navigation[0]
-            };
+function processArticleBody(text) {
+  text = md(text).replace(/'/g,'&#39;');
+  text = text.replace(/<blockquote>/g, '<aside>').
+              replace(/<\/blockquote>/g, '</aside>');
 
-            jade.renderFile(template, {locals: options}, function(err, html){
-                if (err) throw err;
-                fs.writeFileSync(out, html);
-            });
-            this.log('    Done.');
-        }
-    },
+  return text.replace(/<aside>\s+<p><strong>ES5/g,
+                      '<aside class="es5"><p><strong>ES5');
+}
 
-    generateAll: function() {
-        for(var i in this.languages) {
-            if (this.languages.hasOwnProperty(i)) {
-                this.generate(i);
-            }
-        }
-    },
+function readJson(path) {
+  return JSON.parse(fs.readFileSync(path,"utf-8"));
+}
 
-    generate: function(lang) {
-        var that = this;
+function outputLanguage(lang,languages,opts) {
+  var langBase = lang.id == opts.baseLanguage ? "/" : "/" + lang.id;
+  fs.mkdir(opts.outDir + langBase,function(err) {
+    if(err && err.code != "EEXIST") {
+      console.error("Couldn't make dir " + opts.outDir + ": " + err);
+      process.exit(1);
+    }
+    var out = opts.outDir + langBase + "/index.html";
+    var perLangOpts = _.extend({out: out,languages: languages},opts);
+    writeTemplate(perLangOpts,lang);
+  })
+}
 
-        var dir = [this.options.out];
-        if (lang !== this.options.language.default) {
-            dir.push(lang);
-        }
-        dir = dir.join('/');
+function writeTemplate(options,language) {
+  var templateData = _.extend({language: language.id},language,options);
 
-        path.exists(dir, function(exists) {
-            if (!exists) {
-                fs.mkdirSync(dir, '777');
-            }
-            that.render(lang, that.options.template, dir + '/index.html');
-        });
-    }
-});
+  var jadefile = fs.readFileSync(options.template);
+  var jadetemplate = jade.compile(jadefile,{compileDebug: false,debug: false});
+  var html = jadetemplate(templateData);
+  fs.writeFileSync(options.out, html);
+}
 
-exports.build = function (options) {
-    options = options || {dir: 'doc', pathPrefix: 'JavaScript-Garden/', template: 'garden.jade', out: 'site'};
-    new Garden(options);
+exports.build = function (opts) {
+  opts = _.defaults(opts || {},{ languagesDir: "doc", baseLanguage: "en", template: 'garden.jade', pathPrefix: 'JavaScript-Garden/', outDir: "site" });
+  return main(opts);
 }
 
 exports.build();
diff --git a/deploy.sh b/deploy.sh
new file mode 100644
index 00000000..f36cb273
--- /dev/null
+++ b/deploy.sh
@@ -0,0 +1,33 @@
+set -e
+remote=mine
+if [[ $PRODUCTION ]]; then
+  echo "Deploy to production? (y/n)"
+  read ans
+  if [[ $ans == "y" ]]; then
+    remote="origin"
+  fi
+fi
+diffs=`git diff --name-status HEAD`
+if [[ "" != $diffs ]]; then
+  echo "Can't deploy, unsaved changes:"
+  echo $diffs
+  exit
+fi
+git checkout gh-pages
+git reset --hard master
+echo "Starting build"
+node build.js
+echo "Build complete"
+rm -rf `ls -d * | grep -vP 'site|node_modules' | xargs`
+echo "Cleaned out directory"
+mv site/* .
+if [[ $BUILD_ONLY ]]; then
+  exit
+fi
+rm -rf site
+git add . -A
+git commit -m 'latest'
+echo "Commit created"
+git push --force $remote gh-pages
+echo "Deployed to $remote"
+git checkout master
diff --git a/doc/by/array/constructor.md b/doc/by/array/constructor.md
new file mode 100644
index 00000000..6eaa5f2a
--- /dev/null
+++ b/doc/by/array/constructor.md
@@ -0,0 +1,31 @@
+## Канструктар `Array`
+
+Праз тое, што канструктар `Array` неадназначна апрацоўвае свае параметры,
+крайне рэкамендуецца выкарыстоўваць літэрал - `[]` - для стварэння масіваў.
+
+    [1, 2, 3]; // Вынік: [1, 2, 3]
+    new Array(1, 2, 3); // Вынік: [1, 2, 3]
+
+    [3]; // Вынік: [3]
+    new Array(3); // Вынік: []
+    new Array('3') // Вынік: ['3']
+
+У выпадку, калі канструктару `Array` перадаецца толькі адзін параметр, і калі гэты
+аргумент тыпу `Number`, канструктар верне *разрэджаны* масіў, які мае уласціваць
+`length` са значэннем аргумента. Варта адзначыць, што такім чынам будзе зменена
+**толькі** значэнне ўласцівасці `length` масіва; індэксы масіва не будуць
+праініцыялізаваныя.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, індэкс не праініцыялізаваны
+
+Магчымасць загадзя вызначыць даўжыню масіва карысна толькі ў рэдкіх выпадках,
+напрыклад, паўтор радка без выкарыстання цыкла.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### У заключэнне
+
+Літэралы маюць перавагі над канструктарам Array. Яны карацейшыя, маюць больш чысты
+сінтаксіс і робяць код больш чытэльным.
diff --git a/doc/by/array/general.md b/doc/by/array/general.md
new file mode 100644
index 00000000..3e358d5a
--- /dev/null
+++ b/doc/by/array/general.md
@@ -0,0 +1,56 @@
+## Ітэрацыі па масівам і ўласцівасці
+
+Хоць масівы ў JavaScript — аб'екты, няма добрых падставаў для таго, каб
+выкарыстоўваць [цыкл `for in`](#object.forinloop) для ітэрацыі па масівах.
+Фактычна, ёсць шэраг добрых падстаў **супраць** гэтага.
+
+> **Заўвага:** масівы JavaScript **не** *асацыятыўныя масівы*. JavaScript мае
+> [аб'екты](#object.general) для структуры ключ-значэнне. Але калі асацыятыўныя
+> масівы **захоўваюць** парадак, аб'екты — **не**.
+
+З той прычыны, што цыкл `for in` пералічвае ўсе ўласцівасці, якія ёсць у ланцужку прататыпаў,
+і таму, што адзіны спосаб выключыць гэтыя значэнні — [`hasOwnProperty`](#object.hasownproperty),
+ітэрацыя атрымліваецца ў **20 разоў** марудней за звычайны цыкл `for`.
+
+### Ітэрацыя
+
+Для таго, каб атрымаць найлепшую прадукцыйнасць у ітэрацыі па масіву, лепш
+выкарыстаць класічны цыкл `for`.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+У вышэйпрыведзеным прыкладзе ёсць яшчэ адзін прыём, з дапамогай якога можна кэшаваць
+памер масіва: `l = list.length`.
+
+Негледзячы на тое, што ўласцівасць `length` вызначана ў самім масіве, пошук
+гэтай уласцівасці накладвае выдаткі на пошук пры кожнай ітэрацыі цыкла. І хоць
+новыя рухавікі JavaScript **могуць** прымяніць аптымізацыю у гэтым выпадку, няма
+магчымасці дакладна ведаць, ці будзе код выкананы на гэтых новых рухавіках.
+
+Фактычна, адсутнасць кэшавання можа зрабіць выкананне цыкла **ў два разы больш
+марудным**, чым з кэшаваным 'length'.
+
+### Уласцівасць `length`
+
+Хоць *гэтэр* уласцівасці `length` проста вяртае колькасць элементаў, што
+знаходзяцца у масіве, *сэтэр* можа быць выкарыстаны для **абразання** масіва.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Прысвойванне ўласцівасці 'length' меншага значэння абразае масіў. Прысваенне большага
+значэнне створыць разрэджаны масіў.
+
+### У заключэнне
+
+Для лепшай прадукцыйнасці рэкамендуецца заўсёды выкарыстоўваць звычайны цыкл `for`,
+і кэшаваць уласціваць `length`. Выкарыстоўванне `for in` для ітэрацыі па масіву —
+прыкмета дрэнна напісанага коду, схільнага да памылак і дрэннай прадукцыйнасці.
diff --git a/doc/by/core/delete.md b/doc/by/core/delete.md
new file mode 100644
index 00000000..07e2c1ce
--- /dev/null
+++ b/doc/by/core/delete.md
@@ -0,0 +1,81 @@
+## Аператар `delete`
+
+У JavaScript *немагчыма* выдаліць глабальныя пераменныя, функцыі і некаторыя іншыя
+рэчы, што маюць атрыбут `DontDelete`.
+
+### Глабальны код і код функцый.
+
+Калі пераменная або функцыя аб'яўленыя ў глабальнай зоне бачнасці, або [зоне бачнасці
+функцыі](#function.scopes) то яна будзе ўласцівасцю або аб'екта актывацыі, або
+глабальнай зоны бачнасці. Такія ўласцівасці маюць набор атрыбутаў, адзін з іх —
+`DontDelete`. Пераменныя і функцыі, аб'яўленыя ў глабальнай зоне бачнасці і зоне
+бачнасці функцыі, заўсёды ствараюцца з уласцівасцю `DontDelete`, а таму не могуць
+быць выдаленыя.
+
+    // глабальная пераменная:
+    var a = 1; // мае ўласцівасць DontDelete
+    delete a; // false
+    a; // 1
+
+    // звычайная функцыя:
+    function f() {} // мае ўласціваць DontDelete
+    delete f; // false
+    typeof f; // "function"
+
+    // перапрызначэнне не дапамагае:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Яўна прызначаныя ўласцівасці
+
+Яўна прызначаныя ўласцівасці могуць быць лёгка выдаленыя.
+
+    // яўна прызначаныя ўласцівасці:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+У вышэйпрыведзеным прыкладзе, `obj.x` і `obj.y` могуць быць выдаленыя, бо не маюць
+атрыбута `DontDelete`. Таму і прыкад ніжэй працуе:
+
+    // Гэта працуе правільна, акрамя IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true — глабальная пераменная
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Гэта прыём, каб выдаліць `a`. [`this`](#function.this) спасылаецца на глабальны
+аб'ект, і мы яўна аб'яўляем пераменную `a` як яго ўласцівасць, што дазваляе нам
+выдаліць яе.
+
+IE (прынамсі 6-8) мае хібы, таму вышэйпрыведзены код там працаваць не будзе.
+
+### Аргументы функцый і ўбудаваныя ўласцівасці
+
+Звычайныя аргументы функцыі, [аб'ект `arguments`](#function.arguments), а таксама
+убудаваныя ўласцівасці таксама маюць атрыбут `DontDelete`.
+
+    // аргументы функцыі і ўласцівасці:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### У заключэнне
+
+Аператар `delete` часта паводзіць сябе нечакана, таму адзінае надзейнае выкарыстанне
+`delete` — выдаленне яўна прызначаных уласцівасцяў.
diff --git a/doc/by/core/eval.md b/doc/by/core/eval.md
new file mode 100644
index 00000000..7e07dbcd
--- /dev/null
+++ b/doc/by/core/eval.md
@@ -0,0 +1,47 @@
+## Чаму не варта выкарыстоўваць `eval`
+
+Функцыя `eval` выконвае радок JavaScript коду ў лакальнай зоне бачнасці.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+Тым не менш, `eval` выконваецца ў лакальнай прасторы імён толькі ў тым выпадку, калі
+яна была выклікана наўпрост *і* імя выкліканай функцыі — `eval`.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+Лепш пазбягаць выкарыстоўвання `eval`. 99,9% яе «выкарыстанняў» можа быць дасягнута
+**без** яе.
+
+### Схаваны `eval`
+
+Абедзве [функцыі тайм-аўты](#other.timeouts) `setTimeout` і `setInterval` могуць
+прымаць радок у якасці першага аргумента. Гэты радок будзе **заўсёды** выконвацца
+ў глабальнай прасторы імёнаў, бо `eval` не выклікаецца наўпрост у дадзеным выпадку.
+
+### Праблемы з бяспекаю
+
+Таксама `eval` мае праблемы з бяспекаю, бо ён выконвае **любы** перададзены код.
+Таму яе **ніколі** не варта выкарыстоўваць з радкамі, што паходзяць з ненадзейных
+крыніцаў.
+
+### Заключэнне
+
+Лепш ніколі не выкарыстоўваць `eval`. Любы код, што выкарыстоўвае яе, спрэчны ў
+плане якасці, карэктнасці, прадукцыйнасці і бяспекі. Калі для таго, каб нешта
+працавала, патрэбны `eval`, **не** трэба прымаць гэта рашэнне ў першую чаргу.
+*Лепшым рашэннем* будзе тое, што не будзе выкарыстоўваць `eval`.
diff --git a/doc/by/core/semicolon.md b/doc/by/core/semicolon.md
new file mode 100644
index 00000000..db78ed7d
--- /dev/null
+++ b/doc/by/core/semicolon.md
@@ -0,0 +1,109 @@
+## Аўтаматычная ўстаўка кропкі з коскай
+
+Хаця JavaScript мае C-падобны сінтакс, ён **не** прымушае выкарыстоўваць кропку
+з коскай у кодзе, таму ёсць магчымасць прапускаць іх.
+
+Але JavaScript — не мова без кропак з коскай. Насамрэч яны патрэбны ёй, каб разумець
+зыходны код. Таму парсер JavaScript **аўтаматычна** ўстаўляе іх паўсюль, дзе
+сустракае памылку адсутнасці кропкі з коскай.
+
+    var foo = function() {
+    } // памылка разбора, парсер чакаў кропку з коскай
+    test()
+
+Адбываецца ўстаўка, парсер спрабуе зноў.
+
+    var foo = function() {
+    }; // памылкі няма, парсер працягвае
+    test()
+
+Аўтаматычная ўстаўка кропкі з коскай лічыцца адной з **найвялікшых** архітэктурных
+памылак у мове, бо *можа* змяніць паводзіны кода.
+
+### Як яно працуе
+
+Ніжэйпрыведзены код не мае кропак з коскай, таму парсер вырашае дзе іх уставіць.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Ніжэй — вынік гульні парсера ў адгадванне.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Не ўстаўлена, радкі былі аб'яднаныя
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- устаўлена
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- устаўлена
+
+            return; // <- устаўлена, разбіў аператар return на два блока
+            { // парсер лічыць гэты блок асобным
+                foo: function() {}
+            }; // <- устаўлена
+        }
+        window.test = test; // <- устаўлена
+
+    // Радкі зноў аб'ядналіся
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- устаўлена
+
+    })(window); //<- устаўлена
+
+> **Заўвага:** Парсер JavaScript не апрацоўвае "карэктна" аператар return, калі
+> пасля яго пачынаецца новы радок. Магчыма прычына і не ў аўтаматычнай устаўцы
+> кропак з коскай, але гэта, тым не менш, непажаданы эфект.
+
+Парсер кардынальна памяняў паводзіны кода. У пэўных выпадках ён прымае **памылковыя
+рашэнні**.
+
+### Вядучыя дужкі
+
+У выпадку вядучай дужкі парсер **не** уставіць кропку з коскай.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Гэты код ператворыцца ў радок.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+**Вельмі** верагодна, што `log` **не** вяртае функцыю; Таму вышэйпрыведзены
+код справакуе `TypeError` з заявай, што `undefined` не з'яўляецца функцыяй.
+
+### Заключэнне
+
+Крайне рэкамендуецца **ніколі** не прапускаць кропку з коскай. Таксама заўсёды
+рэкамендуецца ставіць дужкі на той жа лініі, што і адпаведныя канструкцыі, і ніколі
+не прапускаць іх у аднарадковых канструкцыях `if` / `else`. Гэтыя меры не толькі
+павысяць кансістэнтнасць кода, але таксама прадухіляць ад таго, што парсер
+JavaScript зменіць паводзіны кода.
diff --git a/doc/by/core/undefined.md b/doc/by/core/undefined.md
new file mode 100644
index 00000000..18af0f2d
--- /dev/null
+++ b/doc/by/core/undefined.md
@@ -0,0 +1,69 @@
+## `undefined` і `null`
+
+JavaScript мае два розныя значэнні для 'нічога' - гэта `null` і `undefined`, пры
+гэтым апошняе больш карыснае.
+
+### Значэнне `undefined`
+
+`undefined` — гэта тып з роўна адным значэннем: `undefined`.
+
+Мова таксама аб'яўляе глабальную пераменную, што мае значэнне `undefined`; Гэта
+пераменная таксама называецца `undefined`. Тым не менш, гэта пераменная, а **не**
+канстанта, ці ключавое слова. Гэта азначае, што яе *значэнне* можа быць
+з лёгкасцю перазапісаным.
+
+> **Заўвага для ES5:** у ECMAScript 5 `undefined` **больш** *нельга запісваць* у
+> строгім рэжыме, але гэта імя можа ўся яшчэ быць перакрыта праз выкарыстанне
+> функцыі з іменем `undefined`.
+
+Ніжэй пералічаныя некалькі выпадкаў, калі вяртаецца `undefined`:
+
+ - Доступ да (немадыфікаванай) глабальнай пераменнай `undefined`.
+ - Доступ да аб'яўленай, *але яшчэ не* ініцыалізаванай пераменнай.
+ - Няяўна вернутае значэнне функцыі праз адсутнасць аператара `return`.
+ - З аператара `return`, які нічога яўна не вяртае.
+ - У выніку пошуку неіснуючай уласцівасці аб'екта.
+ - Параметры функцыі, якім яўна не было прысвоена значэнне.
+ - Усё, чаму было прысвоена значэнне `undefined`.
+ - Любы выраз у форме `void(expression)`.
+
+### Апрацоўка зменаў значэння `undefined`
+
+З той прычыны, што глабальная пераменная `undefined` утрымлівае толькі копію
+актуальнага *значэння* `undefined`, прысвойванне ёй новага значэння **не** мяняе
+значэнне *тыпа* `undefined`.
+
+Таксама для таго, каб параўнаць што-небудзь з значэннем `undefined`, спачатку
+трэба атрымаць значэнне `undefined`.
+
+Звыклая тэхніка абароны ад магчымага перазапісвання пераменнай `undefined` —
+дадатковы параметр у [ананімнай абгортцы](#function.scopes), што выкарыстоўвае
+адсутны аргумент.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // цяпер undefined у лакальнай зоне бачнасці
+        // зноў спасылаецца на значэнне `undefined`
+
+    })('Hello World', 42);
+
+Гэтага ж выніку можна дасягнуць праз аб'яўленне ўнутры абгорткі.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+Адзіная розніца ў тым, што гэта апошняя версія будзе большай на 4 байты пры
+мініфікацыі, а ў першым унутры ананімнай абгорткі не будзе аператара `var`.
+
+### Выкарыстоўванне `null`
+
+Хаця `undefined` у кантэксце мовы JavaScript у асноўным выкарыстоўваецца ў сэнсе
+традыйнага *null*, сам `null` (і літэрал і тып) з'яўляецца яшчэ адным тыпам дадзеных.
+
+Выкарыстоўваецца ў некаторых унутранных механізмах JavaScript (напрыклад аб'яўленне
+канца ланцужка прататыпаў пазначаючы `Foo.prototype = null`), але амаль што ва ўсіх
+выпадках ён можа быць заменены на `undefined`.
diff --git a/doc/by/function/arguments.md b/doc/by/function/arguments.md
new file mode 100644
index 00000000..98ac3d2b
--- /dev/null
+++ b/doc/by/function/arguments.md
@@ -0,0 +1,130 @@
+## Аб'ект `arguments`
+
+У зоне бачнасці любой функцыі JavaScript ёсць доступ да адмысловай пераменнай
+`arguments`. Гэтая пераменная утрымлівае спіс усіх аргументаў, што былі
+перададзеныя функцыі.
+
+> **Заўвага:** У выпадку, калі `arguments` ужо быў створаны ўнутры зоны бачнасці
+> функцыі праз выраз `var`, або з'яўляецца фармальным параметрам,
+> аб'ект `arguments` не будзе створаны.
+
+Аб'ект `arguments` **не з'яўляецца** спадкаемцам `Array`. Ён мае падабенствы
+з масівам, напрыклад уласцівасць `length`. Але ён не ўспадкоўвае `Array.prototype`,
+а ўяўляе з сябе `Object`.
+
+Таму **не**магчыма выклікаць стандартныя метады `push`, `pop` або `slice`
+у аб'екта `arguments`. Тым не менш, ітэрацыя з звычайным цыклам `for` працуе карэктна.
+Неабходна канвертаваць яго ў сапраўдны аб'ект `Array`, каб прымяніць стандартныя
+метады масіваў.
+
+### Канвертацыя ў масіў
+
+Ніжэйпрыведезны код верне новы масіў, які будзе ўтрымліваць усе элементы аб'екта
+`arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Такая канвертацыя **марудная**, яе **не рэкамендуецца** выкарыстоўваць у крытычных
+у плане прадукцыйнасці частках кода.
+
+### Перадача `arguments`
+
+Ніжэй прадстаўлены рэкамендаваны спосаб перадачы аргументаў з адной функцыі ў іншую.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // тут робім што-небудзь
+    }
+
+Яшчэ адзін прыём — гэта выкарыстанне `call` і `apply` разам, каб ператварыць метады,
+што выкарыстоўваюць значэнне `this` як і свае аргументы, у звычайныя функцыі,
+што выкарыстоўваюць толькі аргументы.
+
+    function Person(first, last) {
+      this.first = first;
+      this.last = last;
+    }
+
+    Person.prototype.fullname = function(joiner, options) {
+      options = options || { order: "western" };
+      var first = options.order === "western" ? this.first : this.last;
+      var last =  options.order === "western" ? this.last  : this.first;
+      return first + (joiner || " ") + last;
+    };
+
+    // Ствараем незвязаную версію "fullname", што можа быць выкарыстана з любым
+    // аб'ектам, які мае ўласцівасці 'first' і 'last', перададзеным у якасці
+    // першага параметра. Гэтую абгортку не трэба будзе мяняць, калі колькасць або
+    // парадак аргументаў fullname зменяцца.
+    Person.fullname = function() {
+      // Result: Person.prototype.fullname.call(this, joiner, ..., argN);
+      return Function.call.apply(Person.prototype.fullname, arguments);
+    };
+
+    var grace = new Person("Grace", "Hopper");
+
+    // 'Grace Hopper'
+    grace.fullname();
+
+    // 'Turing, Alan'
+    Person.fullname({ first: "Alan", last: "Turing" }, ", ", { order: "eastern" });
+
+
+### Фармальныя параметры і індэксы аргументаў
+
+Аб'ект `arguments` стварае *гэтэр* і *сэтэр* як да кожнай са сваіх уласцівасцяў,
+так і да фармальных параметраў функцыі.
+
+У выніку змена значэння фармальнага параметра зменіць таксама адпаведную ўласцівасць
+аб'екта `arguments`, і наадварот.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Міфы і праўда аб прадукцыйнасці
+
+Адзінае, калі `arguments` не ствараецца, — гэта калі ёсць фармальны аргумент функцыі
+або пераменная ўнутры яе з такім іменем. Не важна, выкарыстоўваюцца яны ці не.
+
+Як *гэтэры*, так і *сэтэры* ствараюцца **заўсёды**, таму іх выкарыстоўванне не
+мае амаль ніякага ўплыву на прадукцыйнасць.
+
+> **Заўвага для ES5:** *гэтэры* і *сэтэры* не ствараюцца ў строгім рэжыме.
+
+Тым не менш, ёсць адна рэч, якая можа жахліва знізіць прадукцыйнасць у сучасных
+рухавіках JavaScript — гэта выкарыстанне `arguments.callee`.
+
+    function foo() {
+        arguments.callee; // робім што-небудзь з функцыяй foo
+        arguments.callee.caller; // і з функцыяй, якая выклікала foo
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Звычайна ўстаўляецца...
+        }
+    }
+
+У вышэйпрыведзеным кодзе `foo` больш не можа быць [устаўлена][1], бо ёй трэба
+ведаць аб сабе і аб функцыі, што яе выклікала. Гэта не толькі знішчае павышэнне
+прадукцыйнасці, якое магло адбыцца дзякуючы ўстаўцы, але і парушае інкапсуляцыю, бо
+функцыя цяпер залежыць ад спецыфічнага кантэксту, які яе выклікае.
+
+Выкарыстоўванне `arguments.callee` або яго ўласцівасцяў **вельмі непажадана**.
+
+> **Заўвага для ES5:** У строгім рэжыме `arguments.callee` кіне памылку `TypeError`,
+> бо яго выкарыстанне аб'яўлена састарэлым.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
diff --git a/doc/by/function/closures.md b/doc/by/function/closures.md
new file mode 100644
index 00000000..23911e6a
--- /dev/null
+++ b/doc/by/function/closures.md
@@ -0,0 +1,113 @@
+## Замыканні і спасылкі
+
+Адна з найбольш магутных магчымасцяў JavaScript — магчымасць ствараць *замыканні*.
+Зона бачнасці замыканняў **заўсёды** мае доступ да знешняй зоны бачнасці, у якой
+замыканне было аб'яўлена. З той прычыны, што ў JavaScript адзіны механізм працы
+з зонай бачнасці — гэта [зоны бачнасці функцыі](#function.scopes), усе функцыі
+выступаюць у якасці замыканняў.
+
+### Эмуляцыя прыватных пераменных
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+Тут `Counter` вяртае **два** замыканні: функцыю `increment` і функцыю `get`.
+Абедзьве функцыі маюць **спасылку** на зону бачнасці `Counter` і таму заўсёды
+маюць доступ да пераменнай `count`, што была аб'яўлена ў гэтай зоне бачнасці.
+
+### Якім чынам гэта працуе
+
+З той прычыны, што ў JavaScript немагчыма спасылацца або прысвойваць зоны бачнасці,
+**немагчыма** атрымаць доступ да пераменнай `count` звонку. Адзіны спосаб
+узаемадзейнічаць з ім — выкарыстоўваць два замыканні.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+Вышэйпрыведзены код **не** памяняе значэнне пераменнай `count` у зоне бачнасці
+`Counter`, бо `foo.hack` не быў аб'яўлены у **гэтай** зоне бачнасці. Замест гэтага
+ён створыць або перазапіша *глабальную* пераменную `count`.
+
+### Замыканні ўнутры цыклаў
+
+Частая памылка - выкарыстанне замыканняў унутры цыклаў, як быццам бы яны капіруюць
+значэнне пераменнай індэксу цыкла.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+Вышэйпрыведзены код **не** выведзе нумары ад `0` да `9`, ён проста выведзе
+нумар `10` дзесяць разоў.
+
+*Ананімная* функцыя захоўвае **спасылку** на `i`. У той час, калі функцыя `console.log`
+выклікаецца, `цыкл for` ужо адпрацаваў, а значэнне `i` ўжо стала `10`.
+
+Каб атрымаць пажаданыя паводзіны, неабходна стварыць **копію** значэння `i`.
+
+### Як абыйсці праблемы спасылкі
+
+Каб стварыць копію значэння пераменнай індэкса цыкла, лепшы спосаб — стварэнне
+[ананімнай абгорткі](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+Знешняя ананімная функцыя выконваецца імгненна з `i` ў якасці першага аргумента
+і атрымае копію **значэння** `i` ў якасці параметра `e`.
+
+Ананімная функцыя, што перадаецца метаду `setTimeout`, цяпер мае спасылку на
+`e`, чыё значэнне **не** мяняецца на працягу цыкла.
+
+Яшчэ адзін спосаб атрымаць такі вынік — вяртаць функцыю з ананімнай абгорткі,
+што будзе паводзіць сябе такім жа чынам, як і папярэдні прыклад.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+Яшчэ адзін папулярны спосаб дасягнуць гэтага — дадаць яшчэ адзін аргумент выкліку
+функцыі `setTimeout`, якая перадасць агрумент функцыі зваротнага выкліку.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function(e) {
+            console.log(e);  
+        }, 1000, i);
+    }
+
+Некаторыя старыя асяродкі JS (Internet Explorer 9 і ніжэй) не падтрымліваюць
+гэтую магчымасць.
+
+Таксама магчыма выканаць гэта выкарыстоўваючы `.bind`, якая можа звязаць
+`this` і аргументы функцыі. Ніжэйпрыведзены прыклад працуе як папярэднія.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
diff --git a/doc/by/function/constructors.md b/doc/by/function/constructors.md
new file mode 100644
index 00000000..1da70bf5
--- /dev/null
+++ b/doc/by/function/constructors.md
@@ -0,0 +1,122 @@
+## Канструктары
+
+Канструктары ў JavaScript таксама адрозніваюцца ад большасці іншых моваў. Любы
+выклік функцыі, якому папярэднічае ключавое слова `new` з'яўляецца канструктарам.
+
+Унутры канструктара (выкліканай функцыі) - значэнне `this` спасылаецца на
+новаствораны аб'ект. [Прататыпам](#object.prototype) **новага**
+аб'екта прызначаецца `prototype` функцыі, што была выклікана ў якасці канструктара.
+
+У выпадку, калі выкліканая функцыя не вяртае яўнага значэння праз `return`, будзе
+не яўна вернута значэнне `this`, то бок новы аб'ект.
+
+    function Person(name) {
+        this.name = name;
+    }
+
+    Person.prototype.logName = function() {
+        console.log(this.name);
+    };
+
+    var sean = new Person();
+
+У гэтым прыкладзе `Person` выклікаецца ў якасці канструктара, адпаведна `prototype`
+створанага аб'екта будзе прывязаны да `Person.prototype`.
+
+Вярнуць яўнае значэнне праз `return`, можна **толькі** калі гэта значэнне - `Object`.
+
+    function Car() {
+        return 'ford';
+    }
+    new Car(); // новы аб'ект, не 'ford'
+
+    function Person() {
+        this.someValue = 2;
+
+        return {
+            name: 'Charles'
+        };
+    }
+    new Person(); // вяртае аб'ект ({name:'Charles'}), які не ўтрымлівае someValue
+
+Калі ключавое слова `new` прапушчана, функцыя **не** верне аб'ект.
+
+    function Pirate() {
+        // пазначыць значэнне ў глабальным аб'екце!
+        this.hasEyePatch = true;
+    }
+    var somePirate = Pirate(); // somePirate == undefined
+
+Гэты прыклад можа спрацаваць у некаторых выпадках, праз тое як працуе
+[`this`](#function.this) у JavaScript. Значэннем `this` тут будзе
+*глабальны аб'ект*.
+
+### Фабрыкі
+
+Каб мець магчымасць прапусціць ключавое слова `new`, канструктар функцыі мае яўна
+вяртаць значэнне.
+
+    function Robot() {
+        var color = 'gray';
+        return {
+            getColor: function() {
+                return color;
+            }
+        }
+    }
+
+    new Robot();
+    Robot();
+
+Абодва выклікі `Robot` вернуць тое ж самае, новы аб'ект, які мае ўласцівасць
+`getColor`, што з'яўляецца [замыканнем](#function.closures).
+
+Таксама варта адзначыць, што выклік `new Robot()` **не** ўплывае на прататып
+вернутага аб'екта. Хаця прататып будзе прызначаны новастворанаму аб'екту, `Robot`
+ніколі не верне гэты аб'ект.
+
+У прыкладзе вышэй, няма розніцы паміж выклікам функцыі з аператарам `new` або
+без яго.
+
+
+### Стварэнне новых аб'ектаў з выкарыстаннем фабрык
+
+Часта рэкамендуюць **не** выкарыстоўваць `new` бо забыўшыся выкарыстаць яго, можна
+стварыць памылку.
+
+Каб стварыць новы аб'ект, лепш выкарыстоўваць фабрыку і стварыць новы аб'ект
+*унутры фабрыкі*.
+
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
+
+        var milesPerGallon = 2;
+
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
+        }
+
+        car.getMPG = function() {
+            return milesPerGallon;
+        }
+
+        return car;
+    }
+
+Хоць гэты прыклад і спрацуе негледзячы на забытае `new`, і бясспрэчна выкарыстоўвае
+[прыватныя пераменныя](#function.closures), ён мае некалькі недахопаў.
+
+ 1. Ён выкарыстоўвае больш памяці, бо функцыі створаных аб'ектаў **не** захоўваюццца
+    у прататыпе, а ствараюцца на нова для кожнага аб'екта.
+ 2. Каб эмуляваць спадкаемства, фабрыка мае скапіраваць метады іншага аб'екта, або
+    пазначыць прататыпам новага аб'екта стары.
+ 3. Разрыў ланцужка прататыпаў, проста па прычыне забытага ключавога слова `new`,
+    не адпавядае духу мовы JavaScript.
+
+### У заключэнне
+
+Негледзячы на тое, што прапушчанае `new` можа выліцца ў памылку, гэта **не**
+прычына адмовіцца ад выкарыстання прататыпаў. У выніку лепш высвятліць якое рашэнне
+больш адпавядае патрабаванням праграмы. Асабліва важна выбраць пэўны стыль і
+**паслядоўна** выкарыстоўваць яго.
diff --git a/doc/by/function/general.md b/doc/by/function/general.md
new file mode 100644
index 00000000..da5f4ba3
--- /dev/null
+++ b/doc/by/function/general.md
@@ -0,0 +1,48 @@
+## Выразы і аб'яўленне функцый
+
+У JavaScript функцыі таксама з'яўляюцца аб'ектамі. Гэта значыць іх можна перадаваць
+і прысвойваць як і любыя іншыя аб'екты. Адзін, часта выкарыстоўваемы варыянт,
+гэтай магчымасці - перадача *ананімнага метада* як функцыі зваротнага выкліку
+іншай, магчыма асінхроннай функцыі.
+
+### Аб'яўленне `function`
+
+    function foo() {}
+
+У вышэй прыведзеным прыкладзе функцыя [уздымаецца](#function.scopes) перад тым
+як пачынаецца выконванне праграмы; Такім чынам, яна даступная *паўсюль* у зоне
+бачнасці, у якой яна была *аб'яўлена*, нават калі выклік адбываецца да фактычнага
+аб'яўлення ў кодзе.
+
+    foo(); // Працуе, бо функцыя будзе створана да выконвання кода
+    function foo() {}
+
+### `function` як выраз
+
+    var foo = function() {};
+
+У гэтым прыкладзе пераменнай `foo` прысвойваецца *ананімная* функцыя.
+
+    foo; // 'undefined'
+    foo(); // уздыме TypeError
+    var foo = function() {};
+
+Праз тое, што `var` - гэта аб'яўленне якое уздымае імя пераменнай `foo` перад тым
+як код будзе выкананы, `foo` будзе ўжо аб'яўленым калі ён пачне выконвацца.
+
+Але так як прысвойванні адбываюцца толькі пад час выконвання, значэнне `foo`
+будзе змоўчанным ([undefined](#core.undefined)) да выконвання адпаведнага кода.
+
+### Выразы з іменаванымі функцыямі
+
+Яшчэ адзін выбітны выпадак - прысвойванне іменавай функцыі.
+
+    var foo = function bar() {
+        bar(); // працуе
+    }
+    bar(); // ReferenceError
+
+Тут, `bar` не даступны ў знешнім скоўпе, бо функцыя толькі прысвойваецца пераменнай
+`foo`; аднак, унутры `bar`, імя даступнае. Так адбываецца праз асаблівасці працы
+з [прастранствамі імён](#function.scopes) у JavaScript - імя функцыі *заўсёды*
+даступнае ў лакальным скоўпе функцыі.
diff --git a/doc/by/function/scopes.md b/doc/by/function/scopes.md
new file mode 100644
index 00000000..7ade2cfd
--- /dev/null
+++ b/doc/by/function/scopes.md
@@ -0,0 +1,230 @@
+## Зоны бачнасці і прасторы імёнаў
+
+Негледзячы на тое, што JavaScript добра працуе з сінтаксісам фігурных дужак для
+блокаў, у ім **няма** падтрымкі блочнай зоны бачнасці; усё што ёсць на гэты конт
+у мове - *зона бачнасці функцыі*.
+
+    function test() { // зона бачнасці
+        for(var i = 0; i < 10; i++) { // не зона бачнасці
+            // лічым
+        }
+        console.log(i); // 10
+    }
+
+> **Заўвага:** Калі не выкарыстана ў прысвойванні, аператары return або аргуменце
+> функцыі, натацыя `{...}` будзе інтэрпрэтавана як блочны выраз, а **не** як літэрал
+> аб'екта. Гэта з'ява, сумесна з [аўтаматычнай устаўкай коскі з кропкай](#core.semicolon),
+> можа прывесці да хітрых памылак.
+
+Таксама JavaScript не падтрымлівае выразныя прасторы імёнаў, усё аб'яўляецца ў
+агульнадаступнай прасторы імёнаў.
+
+Для кожнай спасылкі на пераменную, JavaScript пойдзе ўверх па ўсіх зонах бачнасці,
+пакуль не знойдзе яе. У выпадку, калі ён дойдзе да глабальнай прасторы імён і ўсё
+яшчэ не знойдзе неабходнае імя, ён уздыме `ReferenceError`.
+
+### Атрута глабальнымі пераменнымі
+
+    // скрыпт A
+    foo = '42';
+
+    // скрыпт B
+    var foo = '42'
+
+Вышэйпрыведзеныя скрыпты маюць **розныя** вынікі. Скрыпт A аб'яўляе пераменную
+`foo` у *глабальнай* зоне бачнасці, скрыпт B аб'яўляе `foo` у *актуальнай* зоне
+бачнасці.
+
+Паўторымся, гэта абсалютна **не** *той жа самы вынік*: не выкарыстоўваенне `var`
+можа мець сур'ёзныя наступствы.
+
+    // глабальная зона бачнасці
+    var foo = 42;
+    function test() {
+        // лакальная зона бачнасці
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+З-за таго, што аператар `var` прапушчаны ўнутры функцыі `test`, значэнне `foo`
+у глабальнай прасторы імён будзе перазапісаным. Хаця першапачаткова гэта можа
+падацца невялікай праблемай, не выкарыстоўванне `var` у кодзе на тысячы радкоў,
+прывядзе да жахлівых, цяжкіх для адладкі памылак.
+
+    // глабальная прастора імёнаў
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // прастора імёнаў subLoop
+        for(i = 0; i < 10; i++) { // аператар var прапушчаны
+            // робім чароўныя рэчы!
+        }
+    }
+
+Знешні цыкл скончыцца пасля першага выкліка `subLoop`, бо `subLoop` перазапісвае
+глабальную пераменную `i`. Выкарыстоўваючы `var` для другога цыкла `for` можна
+было б пазбегнуць памылкі. **Ніколі** не прапускайце аператар `var`, акрамя
+выпадкаў, калі змена дадзеных у знешняй зоне бачнасці ёсць *пажаданым вынікам*.
+
+### Лакальныя пераменныя
+
+Адзіная крыніца лакальных пераменных у JavaScript гэта параметры [функцыі](#function.general)
+і пераменныя аб'яўленыя праз аператар `var`.
+
+    // глабальная зона бачнасці
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // лакальная зона бачнасці функцыі test
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+`foo` і `i` гэта лакальныя пераменныя унутры зоны бачнасці функцыі `test`,
+а вось прызначэнне `bar` перазапіша глабальныю пераменную з тым жа іменем.
+
+### Падыманне
+
+JavaScript **падымае** аб'яўленні. Гэта азначае, што абодва аб'яўленні аператараў
+`var` і `function` падымуцца на верх іх зоны бачнасці.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+Вышэйпрыведзены код трансфармуецца перад пачаткам выконвання. JavaScript падымае
+аператары `var`, як і аб'яўленне `function`, наверх бліжэйшай зоны бачнасці.
+
+    // аператар var перамяшчаецца сюды
+    var bar, someValue; // па змоўчванню - 'undefined'
+
+    // аб'яўленне функцыі таксама падымаецца наверх
+    function test(data) {
+        var goo, i, e; // адсутная блочная зона бачнасці перайшла сюды
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // падае з TypeError бо ўсё яшчэ 'undefined'
+    someValue = 42; // прысвойванні не падымаюцца
+    bar = function() {};
+
+    test();
+
+Адсутнасць блочнай зоны бачнасці не толькі падыме аператар `var` па-за межы цыкла
+і яго цела, але таскама зробіць вынік некаторых канструкцый `if` не-інтуітыўным.
+
+Хоць у арыгінальным кодзе падаецца што канструкцыя `if` змяняе *глабальную
+пераменную* `goo`, на дадзены момант гэта мяняе *лакальную пераменную* - пасля
+таго, як было прыменена падыманне.
+
+Без ведаў аб *падыманні*, можна падумаць што код ніжэй кіне `ReferenceError`.
+
+    // правярае ці было SomeImportantThing праініцыалізавана
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Але канешне, гэта працуе праз тое, што аператар `var` быў падняты на верх
+глабальнай *зоны бачнасці*.
+
+    var SomeImportantThing;
+
+    // тут нейкі код можа ініцыалізаваць SomeImportantThing, або не
+
+    // тут у гэтым можна ўпэўніцца
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Парадак доступу да пераменных
+
+Усе зоны бачнасці ў JavaScript, уключаючы *глабальную зону бачнасці*, маюць
+адмысловае імя [`this`](#function.this), аб'яўленае ўнутры іх, якое спасылаецца
+на *актуальны аб'ект*.
+
+Зоны бачнасці функцый таксама маюць імя [`arguments`](#function.arguments),
+аб'яўленае ў іх, якое спасылаецца на аргументы, што былі перададзеныя ў функцыю.
+
+Напрыклад, калі паспрабаваць атрымаць доступ да пераменнай `foo` унутры зоны
+бачнасці функцыі, JavaScript будзе шукаць імя ў наступным парадку:
+
+ 1. У выпадку калі прысутнічае канструкцыя `var foo` у актуальнай зоне бачнасці,
+ ёна і выкарыстоўваецца.
+ 2. Калі параметр функцыі мае імя `foo`, ён будзе выкарыстаны.
+ 3. Калі сама функцыя называецца `foo`, яна будзе выкарыстана.
+ 4. Пераходзіць у знешнюю зону бачнасці, і пачынае з пункта **#1**.
+
+> **Заўвага:** Наява параметра названага `arguments` **перадухіліць** стварэнне
+> параметра `arguments` па змоўчванні.
+
+### Прасторы імёнаў
+
+Вялікая праблема, звязаная з выкарыстоўваннем глабальнай прасторы імёнаў, гэта
+высокая верагоднасць перасячэння імёнаў пераменных. У JavaScript, гэта праблема
+можа быць лёгка пазбегнута праз выкарыстанне *ананімных абгортак*.
+
+    (function() {
+        // аўтаномная "прастора імён"
+
+        window.foo = function() {
+            // адкрытае замыканне
+        };
+
+    })(); // імгненнае выкананне функцыі
+
+
+Ананімныя функцыі з'яўляюцца [выразамі](#function.general); таму каб быць выкліканымі,
+яны спачатку маюць быць ацэненымі.
+
+    ( // ацэньваем функцыю ўнутры дужак
+    function() {}
+    ) // вяртаем аб'ект функцыі
+    () // выклік выніку ацэнкі
+
+Ёсць і іншыя спосабы ацаніць і імгненна выклікаць выраз функцыі, хаця яны і
+адрозніваюцца па сінтаксісу, паводзяць сябе аднолькава.
+
+    // Яшчэ некалькі спосабаў наўпрост выклікаць функцыю
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // і так далей...
+
+### Заключэнне
+
+Рэкамендуецца заўсёды выкарыстоўваць *ананімную абгортку* каб інкапсуліраваць код
+у яго асабістай прасторы імёнаў. Гэта не толькі абараняе код ад перасячэння імёнаў,
+але і дапамагае падзяляць праграму на модулі.
+
+Таксама выкарыстанне глабальных пераменных лічыцца **дрэннай практыкай**. **Любое**
+іх выкарыстоўванне - прыкмета дрэнна напісанага кода, схільнага да памылак, і цяжага
+ў падтрымцы.
diff --git a/doc/by/function/this.md b/doc/by/function/this.md
new file mode 100644
index 00000000..0a85ef5f
--- /dev/null
+++ b/doc/by/function/this.md
@@ -0,0 +1,118 @@
+## Як працуе `this`
+
+У JavaScript `this` азначае канцэптуальна іншую рэч, чым у іншых мовах праграмавання.
+Існуе роўна **пяць** варыянтаў таго, да чаго можа быць прывязана `this`.
+
+### Глабальна зона бачнасці
+
+    this;
+
+Калі `this` выкарыстоўваецца ў глабальнай зоне бачнасці - яна спасылаецца на *глабальны* аб'ект
+
+
+### Выклік функцыі
+
+    foo();
+
+Тут, `this` усё яшчэ спасылаецца на *глабальны* аб'ект.
+
+> **Заўвага для ES5:** У строгім рэжыме, паняцця глабальнасці **больш не існуе**.
+> `this` у такім выпадку будзе мець значэнне `undefined`.
+
+### Выклік метада
+
+    test.foo();
+
+У гэтым выпадку, `this` будзе спасылацца на аб'ект `test`.
+
+### Выклік канструктара
+
+    new foo();
+
+Выклік функцыі, перад якім прысутнічае ключавое слова `new`, выступае ў якасці
+[канструктара](#function.constructors). Унутры функцыі, `this` будзе спасылацца
+на *новаствораны* аб'ект.
+
+### Яўная ўстаноўка `this`
+
+    function foo(a, b, c) {}
+
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // масіў разгорнецца ў ніжэйпрыведзенае
+    foo.call(bar, 1, 2, 3); // вынікам будзе a = 1, b = 2, c = 3
+
+Пры выкарыстоўванні метадаў `call` або `apply` з `Function.prototype`, значэнню
+`this` унутры выкліканай функцыі **яўна прысвойваецца** значэнне першага
+аргумента адпаведнага выкліка функцыі.
+
+Як вынік, у вышэйпрыведзеным прыкладзе *правіла метада* **не** працуе, і `this`
+унутры `foo` будзе мець значэнне `bar`.
+
+> **Заўвага:** `this` **не можа** быць выкарыстаны як спасылка ўнутры літэрала
+> `Object`. Таму ў кодзе `var obj = {me: this}` `me` **не** будзе спасылацца на
+> `obj`, бо `this` прывязваецца толькі па пяці вышэйапісаных правілах.
+
+### Магчымыя пасткі
+
+Не гледзячы на тое, што большасць гэтых прыкладаў лагічныя, першы можна лічыць
+яшчэ адным недаглядам мовы, бо ён **ніколі** не мае практычнага прымянення.
+
+    Foo.method = function() {
+        function test() {
+            // this спасылаецца на глабальны аб'ект
+        }
+        test();
+    };
+
+Памылковым меркаваннем будзе тое, што `this` унутры `test` будзе спасылацца на
+`Foo`; Але на самрэч **гэта не так**.
+
+Каб атрымаць доступ да `Foo` з цела `test`, вы можаце стварыць лакальную
+пераменную унутры `метада` што будзе спасылацца на `Foo`.
+
+    Foo.method = function() {
+        var self = this;
+        function test() {
+            // Тут выкарыстоўвайце self замест this
+        }
+        test();
+    };
+
+`self` гэта звычайнае імя пераменнай, але яно часта выкарыстоўваецца для спасылкі
+на знешні `this`. У камбінацыі з [замыканнямі](#function.closures), яно можа быць
+выкарыстана для перадачы `this` навокал.
+
+У ECMAScript 5 можна выкарыстаць метад `bind` у камбінацыі з ананімнай функцыяй,
+дзеля таго каб атрымаць аналагічны вынік.
+
+    Foo.method = function() {
+        var test = function() {
+            // this цяпер спасылаецца на Foo
+        }.bind(this);
+        test();
+    };
+
+### Прысвойванне метадаў
+
+Яшчэ адна рэч якая **не** працуе ў JavaScript - гэта стварэнне псэўданімаў функцый,
+то бок **прысвойванне** значэння метада пераменнай.
+
+    var test = someObject.methodTest;
+    test();
+
+Паводле першага правіла, `test` цяпер працуе як звычайны выклік функцыі;
+адпаведна, `this` унутры больш не будзе спасылацца на `someObject`.
+
+Поздняе звязванне `this` можа падацца дрэннай ідэяй, але насамрэч якраз дзякуючы
+гэтаму працуе [спадкаемства прататыпаў](#object.prototype).
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+Калі выклікаецца `method` новага экзэмпляра `Bar`, `this` будзе спасылацца на гэты
+экзэмпляр.
diff --git a/doc/by/index.json b/doc/by/index.json
new file mode 100644
index 00000000..1ed0abaa
--- /dev/null
+++ b/doc/by/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden па Беларуску",
+    "description": "Мануал па недахопаў і дзівосах JavaScript",
+    "sections": [
+        {
+            "title": "Уводзіны",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "Аб'екты",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Функцыі",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Масівы",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Тыпы",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Ядро",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "Рэшта",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/by/intro/index.md b/doc/by/intro/index.md
new file mode 100644
index 00000000..ea82a31e
--- /dev/null
+++ b/doc/by/intro/index.md
@@ -0,0 +1,56 @@
+## Уступ
+
+**JavaScript Garden** гэта растучы набор дакументацыі аб найбольш
+цікавых частках мовы праграмавання JavaScript. Ён дае парады аб тым як прадухіліць
+частыя і непрадказальныя памылкі, а таксама праблемы з хуткасцю выконвання і
+дрэннымі практыкамі, якія праграмісты, не з'яўляючыяся экспертамі у JavaScript
+маглі сустрэць падчас сваіх пошукаў у глыбіні мовы.
+
+JavaScript Garden **не** ставіць сваёй мэтай навучыць вас мове JavaScript. Былыя
+веды мовы рэкамендаваныя, каб вы змаглі зразумець пытанні разглядаемыя ў гэтым
+мануале. Каб зразумець базавыя рэчы мовы, калі ласка прачытайце цудоўны [мануал][1]
+у сетцы распрацоўшчыкаў Mozilla.
+
+## Аўтары
+
+Гэты мануал - праца двух выбітных карыстальнікаў [Stack Overflow][2] , [Ivo Wetzel][3]
+(Тэкст) і [Zhang Yi Jiang][4] (Дызайн).
+
+На дадзены момант падтрымліваецца [Tim Ruffles](http://truffles.me.uk).
+
+## Удзельнікі
+
+- Зашмат каб пералічыць тут, [паглядзіце спіс](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
+
+## Хостынг
+
+JavaScript Garden хосціцца на GitHub, але [Cramer Development][7] падтрымлівае нас
+люстэркам на [JavaScriptGarden.info][8]. У Беларускамоўнай версіі таксама ёсць
+сваё [люстэрка на GitHub][13]
+
+## Пераклад
+
+Перакладзена на Беларускую мову супольнасцю [it-mova][14].
+
+## Ліцэнзія
+
+JavaScript Garden апублікаваны пад [MIT ліцэнзіяй][9] і хосціцца на
+[GitHub][10]. Калі вы знойдзеце апячатку або памылку - [пазначце памылку][11] або
+адпраўце pull request у сховішча. Вы таксама можаце знайсці нас у
+[JavaScript room][12] на чаце Stack Overflow.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/it-na-move/JavaScript-Garden/
+[11]: https://github.com/it-na-move/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
+[13]: http://it-na-move.github.io/JavaScript-Garden/
+[14]: https://github.com/it-na-move
diff --git a/doc/by/object/forinloop.md b/doc/by/object/forinloop.md
new file mode 100644
index 00000000..fbe52f15
--- /dev/null
+++ b/doc/by/object/forinloop.md
@@ -0,0 +1,63 @@
+## Цыкл `for in`
+
+Як і аператар `in`, цыкл `for in` праходзіць па ўсім ланцужку прататыпаў
+пры ітэрацыі па ўласцівасцях аб'екта.
+
+> **Заўвага:** Цыкл `for in` **не** ітэруе па уласцівасцях, у якіх атрыбут
+> `enumerable` мае значэнне `false`; напрыклад, уласцівасць `length`
+> масіва (Array).
+
+    // Атруцім Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // вывядзе і bar і moo
+    }
+
+Праз тое, што немагчыма памяняць паводзіны самаго цыкла `for in`, неабходна фільтраваць
+непажаданыя ўласцівасці аб'екта ўнутры цыкла. У версіях ECMAScript 3 і пазней,
+гэта можна зрабіць праз метад [`hasOwnProperty`](#object.hasownproperty).
+
+Пачынаючы з ECMAScript 5, `Object.defineProperty` можа быць выкарыстана з
+`enumerable` роўным `false`, каб дадаць уласцівасці аб'екту такім чынам, што яны
+не будуць пералічаны. У такім выпадку было б справядлівым меркаваць, што любая
+`enumerable` уласціваць была дададзена адмыслова і прапусціць `hasOwnProperty`, бо
+гэта робіць код больш шматслоўным і цяжэйшым для чытання. У бібліятэчным кодзе
+`hasOwnProperty` мае быць усё роўна выкарыстаны, бо не варта рабіць здагадкі аб
+тым, якія `enumerable` уласцівасці могуць пражываць у ланцужку прататыпаў.
+
+> **Заўвага:** праз тое, што `for in` заўсёды праходзіць праз увесць ланцужок прататыпаў,
+> ён будзе працаваць усё марудней з кожным новым слоем спадкаемства.
+
+### Выкарыстоўванне `hasOwnProperty` для фільтрацыі
+
+    // возьмем foo з прыкладу
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Гэта адзіная правільная версія выкарыстоўвання цыкла. Дзякуючы выкарыстоўванню
+`hasOwnProperty`, быдзе выведзена **толькі** `moo`.
+Калі прыбраць `hasOwnProperty`, код будзе схільны да памылак у выпадку, калі
+натыўныя прататыпы — напрыклад, `Object.prototype` — былі змененыя.
+
+У новых версіях ECMAScript уласцівасці, пазначаныя як не enumerable, могуць быць
+вызначыныя праз `Object.defineProperty`, змяншаючы рызыку ітэрацыі праз іх без
+выкарыстання `hasOwnProperty`. Тым не менш, трэба быць уважлівым пры выкарыстанні
+старых бібліятэк, такіх як [Prototype][1], якая не выкарыстроўвае новымя магчымасці
+ECMAScript.
+Пры выкарыстоўванні гэтай бібліятэкі, цыклы `for in`, якія не выкарыстоўваюць
+`hasOwnProperty`, гарантавана не будуць працаваць.
+
+### У заключэнне
+
+Рэкамендавана **заўсёды** выкарыстоўваць `hasOwnProperty` як у ECMAScript 3 або
+ніжэй, так і ў бібліятэчным кодзе. У гэтых асяродках ніколі не варта рабіць
+здагадкі аб тым, быў зменены натыўны прататып ці не. Пачынаючы з ECMAScript 5,
+`Object.defineProperty` дазваляе пазначаць уласцівасці як не `enumerable` і прапускаць
+выкарыстоўванне `hasOwnProperty` у кодзе праграмы.
+
+[1]: http://www.prototypejs.org/
diff --git a/doc/by/object/general.md b/doc/by/object/general.md
new file mode 100644
index 00000000..6977d8a3
--- /dev/null
+++ b/doc/by/object/general.md
@@ -0,0 +1,98 @@
+## Выкарыстанне і ўласцівасці аб'ектаў
+
+Усё ў JavaScript дзейнічае як аб'ект, апроч двух выключэнняў — гэта
+[`null`](#core.undefined) і [`undefined`](#core.undefined).
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Часта распрацоўшчыкі думаюць, што лічбавыя літэралы не могуць быць выкарыстаны як
+аб'екты. Гэта праз тое, што сінтаксічны аналізатар JavaScript стараецца прывесці
+*натацыю кропка* пасля нумара да літэрала з плаваючай кропкай.
+
+    2.toString(); // уздымае SyntaxError
+
+Ёсць некалькі падыходаў, якія могуць дазволіць выкарыстаць лікавыя літэралы як
+аб'екты'.
+
+    2..toString(); // другая кропка распазнаецца слушна
+    2 .toString(); // заўважце прабел з лева ад кропкі
+    (2).toString(); // 2 распазнаецца першым чынам
+
+### Аб'ект як тып дадзеных
+
+Аб'екты ў JavaScript таксама могуць быць выкарыстаныя як [*хэш-табліцы*][1]; яны ў асноўным
+складаюцца з іменаваных уласцівасцяў з адпаведнымі значэннямі.
+
+Выкарыстоўваючы натацыю літэрала аб'екта — `{}` — магчыма стварыць
+просты аб'ект. Гэты новы аб'ект [пашырае](#object.prototype) `Object.prototype` і
+не мае [сваіх уласцівасцяў](#object.hasownproperty) якія былі б вызначыныя.
+
+    var foo = {}; // новы пусты аб'ект
+
+    // новы аб'ект з уласціваццю 'test', якая мае значэнне 12
+    var bar = {test: 12};
+
+### Доступ да ўласцівасцяў
+
+Доступ да ўласцівасцяў аб'екта можа быць здейснены двумя спосабамі, праз кропкавую
+натацыю або натацыю з квадратнымі дужкамі.
+
+    var foo = {name: 'кацяня'}
+    foo.name; // кацяня
+    foo['name']; // кацяня
+
+    var get = 'name';
+    foo[get]; // кацяня
+
+    foo.1234; // SyntaxError
+    foo['1234']; // працуе
+
+Натацыі працуюць амаль што ідэнтычна, з адзінай розніцай у тым, што
+натацыя з квадратнымі дужкамі дазваляе дынамічную устаноўку ўласцівасцяў і
+выкарыстанне імёнаў уласцівасцяў, якія інакш прывялі б да сінтаксічных памылак.
+
+### Выдаленне ўласцівасцяў
+
+Адзіны спосаб выдаліць уласціваць з аб'екта — гэта выкарыстаць аператар `delete`;
+пазначэнне уласціваці як `undefined` або `null` толькі прыбірае
+*значэнне* звязанае з уласцівацю, але не *ключ*.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+Вышэй прыведзены код вывядзе `bar undefined` і `foo null` — толькі `baz` быў
+выдалены і таму адсутнічае ў вывадзе.
+
+### Натацыя ключэй
+
+    var test = {
+        'case': 'Я ключавое слова, таму я павінна быць пазначана як радок',
+        delete: 'Я таксама ключавое слова, таму і я' // уздымае SyntaxError
+    };
+
+Уласцівасці аб'ектаў могуць быць пазначаныя як сімваламі, так і ў выглядзе радкоў.
+Праз яшчэ адну хібу сінтаксічнага аналізатара JavaScript, вышэй прыведзены код
+кіне `SyntaxError` у весіях ранейшых за ECMAScript 5.
+
+Гэта памылка ўздымаецца праз тое, што `delete` - гэта *ключавое слова*; такім чынам,
+яно мае быць пазначана як *літэрал радка* каб забяспечыць, што яно будзе какрэктна
+інтэрпрэтавана старымі рухавікамі JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
diff --git a/doc/by/object/hasownproperty.md b/doc/by/object/hasownproperty.md
new file mode 100644
index 00000000..730ce942
--- /dev/null
+++ b/doc/by/object/hasownproperty.md
@@ -0,0 +1,55 @@
+## Метад `hasOwnProperty`
+
+Каб праверыць, ці ёсць у аб'екта ўласцівасць, вызначаная ў *ім самім*, а не дзе-небудзь
+у яго [ланцужку прататыпаў](#object.prototype), неабходна выкарыстаць метад
+`hasOwnProperty`, які ўсе аб'екты ўспадкоўваюць ад `Object.prototype`.
+
+> **Заўвага:** **недастаткова** праверыць, ці значэнне уласцівасці — `undefined`.
+> Уласцівасць можа існаваць, але яе значэнне было пазначана як `undefined`.
+
+`hasOwnProperty` — адзіная функцыя ў JavaScript, якая дазваляе атрымаць уласцівасці
+аб'екта **без** зварота да ланцужка прататыпаў.
+
+    // Сапсуем Object.prototype
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+Толькі `hasOwnProperty` дасць правільны чаканы вынік. Паглядзіце секцыю аб
+[цыкле `for in`](#object.forinloop) для падрабязнейшых звестак аб тым, як
+выкарыстоўваць `hasOwnProperty` падчас ітэрацыі па ўласцівасцях аб'екта.
+
+### `hasOwnProperty` як уласцівасць
+
+JavaScript не абараняе ўласцівасць `hasOwnProperty`; такім чынам, ёсць верагоднасць
+што ў аб'екта можа быць уласцівасць з такім імем, неабходна выкарыстаць
+*знешні* `hasOwnProperty` для карэктнага выніку.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Тут жывуць драконы'
+    };
+
+    foo.hasOwnProperty('bar'); // заўсёды верне false
+
+    // выкарыстайце hasOwnProperty іншага аб'екта
+    // і перадайце foo у якасці this
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+    // Такасама магчыма выкарыстаць hasOwnProperty з Object.prototype
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+
+
+### Заключэнне
+
+Выкарыстоўванне `hasOwnProperty` ёсць **адзіным** надзейным спосабам, каб
+праверыць існаванне ўласцівасці ў аб'екце. Рэкамендуецца выкарыстоўваць
+`hasOwnProperty` пры ітэрацыі па ўласцівасцях аб'екта, як апісана ў секцыі
+[цыкла `for in` ](#object.forinloop).
diff --git a/doc/by/object/prototype.md b/doc/by/object/prototype.md
new file mode 100644
index 00000000..ec80e801
--- /dev/null
+++ b/doc/by/object/prototype.md
@@ -0,0 +1,115 @@
+## Прататып
+
+JavaScript не прадастаўляе класічную мадэль спадкаемства; замест гэтага, ён
+выкарыстоўвае *прататыпную* мадэль.
+
+Негледзячы на тое, што гэта лічыцца адной з слабасцяў JavaScript, мадэль
+прататыпнага спадкаемства больш эфэктыўная за класічную.
+Напрыклад, даволі трывіальна пабудаваць класічную мадэль паверх прататыпнай мадэлі,
+у той час як адваротнае было б значна больш складаным.
+
+JavaScript гэта адзіная шырока выкарыстоўваемая мова, якая падтрымлівае
+прататыпнае спадкаемства, таму можа спатрэбіцца час, каб прызвычаіцца да гэтай мадэлі.
+
+Першая вялікая розніца заключаецца ў тым, што JavaScript выкастроўвае *прататыпныя
+ланужкі*.
+
+> **Заўвага:** простае выкарыстоўванне `Bar.prototype = Foo.prototype` прывядзе
+> да таго, што абодва аб'екта будуць выкарыстоўваць **той жа** прататып.
+> Такім чынам, змены ў прататыпе любога з аб'ектаў паўплываюць на прататып іншага,
+> што звычайна не ёсць пажаданым эфэктам.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Пазначае прататыпам Bar новы асобнік Foo
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Упэнімся, што Bar з'яўляецца дзейсным канструктарам
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar(); // стварае новы асобнік Bar
+
+    // Выніковы ланцужок прататыпаў
+    test [instance of Bar]
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+              { toString: ... /* і г.д. */ }
+
+У вышэй прыведзеным кодзе аб'ект `test` атрымае спадчыну і ад `Bar.prototype`,
+і ад `Foo.prototype`; такім чынам, ён будзе мець доступ да функцыі `method`, якая
+вызначана ў `Foo`. А таксама доступ да ўласцівасці `value`
+**аднаго унікальнага асобніка** `Foo`, які з'яўляецца яго прататыпам. Важна заўважыць,
+што `new Bar()` **не** стварае новы асобнік `Foo`, але выкарыстоўвае функцыю,
+пазначаную яго прататыпам; такім чынам, усе асобнікі `Bar` будуць выкарыстоўваць
+**тую ж** уласціваць `value`.
+
+> **Заўвага:** **не** выкарыстоўвайце `Bar.prototype = Foo`, бо гэта будзе
+> ўказваць не на прататып `Foo`, а на аб'ект фукцыі `Foo`. Таму ланцужок
+> прататыпаў будзе праходзіць праз `Function.prototype`, а не `Foo.prototype`;
+> па гэтай прычыне `method` не будзе прысутнічаць у ланцужку прататыпаў.
+
+### Пошук уласцівасцяў
+
+Калі адбываецца зварот да ўласцівасці, JavaScript пройдзе па ўсім
+ланцужку прататыпаў **уверх** да таго моманту, як знойдзе ўласціваць з запытаным імем.
+
+У той момант, калі дасягнуты верх ланцужка - а менавіта `Object.prototype` - і ўсё яшчэ
+не знойдзена адпаведная ўласцівасць, будзе вернута значэнне [undefined](#core.undefined).
+
+### Уласцівасць prototype
+
+Нягледзячы на тое, што ўласцівасць prototype выкарыстоўваецца мовай, каб пабудаваць
+ланцужок прататыпаў, магчыма прызначыць яму **любое** значэнне. Аднак, прызначэнне
+прымітываў будузе праігнараваным.
+
+    function Foo() {}
+    Foo.prototype = 1; // без эфекту
+
+Прызначэнне аб'ектаў, як паказана ў прыкладзе вышэй, будзе працаваць, і дазволіць
+дынамічна ствараць ланцужкі прататыпаў.
+
+### Хуткасць выканання
+
+Пошук уласцівасцяў, якія знаходзяцца высока ў ланцужку прататыпаў, можа
+негатыўна адбіцца на хуткасці выканання, і гэта можа быць прыкметным у кодзе, у якім
+чыннік хуткасці крытычны. У выпадку спробы доступа да неіснуючых уласцівасцяў
+будзе пройдзены ўвесь ланцужок прататыпаў.
+
+У дадатак, пры [ітэрацыі](#object.forinloop) па ўласцівасцях аб'екта
+**кожная** уласціваць, што ёсць у ланцужку прататыпаў будзе апрацавана.
+
+### Расшырэнне ўбудаваных прататыпаў
+
+Адна з дрэнных магчымасцяў, што сустракаецца даволі часта — расшырэнне прататыпа
+`Object.prototype` або аднаго з іншых убудаваных тыпаў.
+
+Такая практыка называецца [monkey patching][1] і парушае *інкапсуляцыю*. Хаця
+папулярныя фрэймворкі, такія як [Prototype][2] шырока выкарыстоўваюць гэтую
+мачымасць, няма добрых матываў для нагрувашчвання ўбудаваных тыпаў дадатковай
+*нестандартнай* функцыянальнасцю.
+
+**Адзіным** добрым матывам расшырэння убудаваных прататыпаў — гэта дадаванне функцыянала,
+што з'явіўся у новых рухавіках JavaScript; напрыклад, [`Array.forEach`][3].
+
+### У завяршэнне
+
+**Вельмі важна** разумець, як працуе мадэль прататыпнага спадкаемства да таго, як
+пісаць код, які яе выкарыстоўвае. Таксама сачыце за даўжынёй ланцужка прататыпаў
+і драбіце іх, калі ёсць магчымасць, каб пазбегнуць праблем з прадукцыйнасцю.
+Таксама ўбудаваныя прататыпы **ніколі** не павінны расшырацца, акрамя як для
+таго, каб падтрымаць новыя магчымасці JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
diff --git a/doc/by/other/timeouts.md b/doc/by/other/timeouts.md
new file mode 100644
index 00000000..1ed49dc4
--- /dev/null
+++ b/doc/by/other/timeouts.md
@@ -0,0 +1,168 @@
+### `setTimeout` і `setInterval`
+
+Дзякуючы асінхроннасці JavaScript магчыма запланаваць выкананне функцыі з дапамогай 
+метадаў `setTimeout` і `setInterval`.
+
+> **Заўвага:** Таймаўты **не** з'яўляюцца часткай стандарта ECMAScript. Яны былі
+> распрацаваны ў [BOM, ці DOM Узровень 0][1], якія ніколі не былі аб'яўлены ці
+> задакументаваны фармальна. Да гэтага часу няма рэкамендацыйных спецыфікацый,
+> аднак, у дадзены момант яны стандартызаваны ў [HTML5][2]. У сувязі з гэтым 
+> рэалізацыя можа адрознівацца ў залежнасці ад браўзера і рухавіка
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // вяртае Number > 0
+
+Калі функцыя `setTimeout` выклікана, яна вяртае ID таймаўта і плануе выкананне 
+`foo` **прыблізна** праз тысячу мілісекунд. 
+`foo` будзе выканана **аднойчы**.
+
+Улічваючы вырашэнні таймера рухавіка Javascript, які выконвае код,
+аднапаточнасць JavaScript і тое, што іншы код, які выконваецца
+можа блакаваць паток, **нельга** быць упэўненым, што вы атрымаеце затрымку,
+пазначанаю ў выкліку `setTimeout`.
+
+Функцыя, якая была перададзена як першы параметр, будзе выклікана 
+*глабальным аб'ектам*, гэта азначае, што [`this`](#function.this) унутры выкліканай функцыі 
+спасылаецца на глабальны аб'ект.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this спасылаецца на глабальны аб'ект
+            console.log(this.value); // выведзе undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+
+> **Заўвага:** Так як `setTimeout` прымае **функцыю** як першы параметр,
+> распаўсюджанай з'яўляецца памылка выкарыстоўвання `setTimeout(foo(), 1000)`, у гэтым выпадку 
+> будзе выкарыстоўвацца **вернутае значэнне** выкліка `foo`, а **не** `foo`. Гэта, у большасці выпадкаў, 
+> маўклівая памылка, так як калі функцыя вяртае `undefined`, `setTimeout` 
+> **не** выклікае памылкі.
+
+### Паслядоўныя выклікі з дапамогай `setInterval`
+
+У той час калі `setTimeout` выконвае функцыю толькі адзін раз, `setInterval` - як бачна з назвы - 
+выконвае функцыю **кожныя** `X` milliseconds, але яе выкарыстанне не пажадана.
+
+Код, які выконваецца, блакуе выклік з таймаўтам, у той час `setInterval` будзе 
+планаваць выклікі зададзенай функцыі. Гэта можа, асабліва з маленькімі інтэрваламі,
+прывесці да стварэння чаргі выклікаў функцый.
+
+    function foo(){
+        // нешта, што блакуе на 1 секунду
+    }
+    setInterval(foo, 100);
+
+У прыведзеным кодзе `foo` будзе выклікана аднойчы і заблакуе выкананне на адну секунду.
+
+У той час калі `foo` блакуе код, `setInterval` будзе планаваць наступныя яе выклікі
+А калі выкананне `foo` скончана, ужо **дзесяць** наступных выклікаў будуць чакаць выканання.
+
+### Праца з магчыма блакуючым кодам
+
+Найбольш простае і кіруемае рашэнне гэта выкарыстоўваць `setTimeout` унутры самой функцыі.
+
+    function foo(){
+        // нешта, што блакуе на 1 секунду
+        setTimeout(foo, 100);
+    }
+    foo();
+
+Гэты падыход не толькі інкапсулюе выклік `setTimeout`, але таксама прадухіляе
+стварэнне чаргі выклікаў і дае дадатковы кантроль. Цяпер `foo` можа сама вырашыць 
+хоча яна выконвацца яшчэ раз ці не.
+
+### Ручная чыстка таймаўтаў
+
+Чыстка таймаўтаў і інтэрвалаў здзяйсняецца перадачай адпаведнага ID у
+`clearTimeout` або `clearInterval`, гледзячы якая `set` функцыя была выкарыстана
+да гэтага.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Чыстка ўсіх таймаўтаў
+
+Так як няма ўбудаванага метада для выдалення ўсіх таймаўтаў і/або інтэрвалаў, 
+для гэтага неабходна выкарыстоўваць брутфорс.
+
+    // выдаліць "усе" таймаўты
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+Але могуць быць таймаўты, якія не закрануты гэтым адвольным нумарам.
+Іншы шлях ажыццяўлення гэтага - прыняць, што ID таймаўта павялічваецца на
+адзін пасля кожнага выкліку `setTimeout`.
+
+    // выдаліць "усе" таймаўты
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+Не гледзячы на тое, што зараз гэта працуе на ўсіх асноўных браўзерах, тое, што ID
+павінны быць арганізаваны такім шляхам не пазначана ў спецыфікацыі і можа змяніцца. Таму 
+замест гэтага рэкамендуецца сачыць за ўсімі ID таймаўтаў, каб яны маглі быць выдалены паасобку.
+
+### Схаванае выкарыстанне `eval`
+
+`setTimeout` і `setInterval` таксама могуць прымаць радок у якасці першага параметра.
+Гэту магчымасць **ніколі** не трэба выкарыстоўваць, бо ўнутрана вызываецца `eval`.
+
+> **Заўвага:** Дакладны механізм работы пры перадачы радка можа адрозніваецца ў
+> розных JavaScript рэалізацыях. Напрыклад, JScript ад Microsoft выкарыстоўвае
+> канструктар `Function` замест `eval`.
+
+    function foo() {
+        // будзе выклікана
+    }
+
+    function bar() {
+        function foo() {
+            // ніколі не будзе выклікана
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Паколькі `eval` не выклікана [напрамую](#core.eval), радок, які перададзены 
+`setTimeout` будзе выкананы ў *глабальным скоўпе*; такім чынам, не будзе выкарыстана 
+лакальная пераменная `foo` са скоўпа `bar`.
+
+Адсюль вынікае рэкамендацыя **не** выкарыстоўваць радок для перадачы аргументаў у
+функцыю, якая будзе вызывацца адной з таймаўт функцый. 
+
+    function foo(a, b, c) {}
+    
+    // НІКОЛІ так не рабіце
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // Замест выкарыстоўвайце ананімныя функцыі
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **Заўвага:** Нягледзячы на тое, што сінтаксіс `setTimeout(foo, 1000, 1, 2, 3)` можна выкарыстоўваць,
+> гэта не рэкамендуецца, так як можа прывесці да 
+> непрыкметных памылак пры выкарыстанні з [метадамі](#function.this).
+> Больш таго, сінтаксіс можа не працаваць у некаторых рэалізацыях JavaScript.
+> Напрыклад, Internet Explorer ад Microsoft  [**не** перадае аргументы напрамую зваротнаму выкліку](3).
+
+### У заключэнне
+
+Радок **ніколі** не павінен быць выкарыстаны як параметр `setTimeout` ці 
+`setInterval`. Відавочны знак **сапраўды** благога кода гэта калі функцыя, якая будзе выклікана, 
+патрабуе аргументы. Трэба перадаваць *ананімную функцыю*, якая будзе адказваць за
+выклік патрэбнай функцыі.
+
+Больш таго, трэба пазбягаць выкарыстання `setInterval`, таму што яе планавальнік не блакуецца 
+выкананнем JavaScript.
+
+[1]: http://www.nczonline.net/blog/2009/09/29/web-definitions-dom-ajax-and-more/ "Web definitions: DOM, Ajax, and more"
+[2]: http://www.w3.org/TR/2014/WD-html5-20140617/webappapis.html#timers "6 Web application APIs - HTML5"
+[3]: http://msdn.microsoft.com/en-us/library/ie/ms536753(v=vs.85).aspx "setTimeout method (Internet Explorer)"
diff --git a/doc/by/types/casting.md b/doc/by/types/casting.md
new file mode 100644
index 00000000..763bf3a1
--- /dev/null
+++ b/doc/by/types/casting.md
@@ -0,0 +1,71 @@
+## Прывядзенне тыпаў
+
+JavaScript - *слаба тыпізаваная* мова, таму *прывядзенне тыпаў* адбываецца
+**паўсюль** дзе магчыма.
+
+    // Гэтыя равенствы - праўдзівыя
+    new Number(10) == 10; // аб'ект тыпа Number пераўтвараецца у
+                          // лікавы прымітыў, праз няяўны выклік
+                          // метада Number.prototype.valueOf
+
+    10 == '10';           // Strings пераўтвараецца ў Number
+    10 == '+10 ';         // Троху вар'яцтва з радкамі
+    10 == '010';          // і яшчэ
+    isNaN(null) == false; // null пераўтвараецца ў 0
+                          // які вядома ж не NaN
+
+    // Гэтыя равенствы - ілжывыя
+    10 == 010;
+    10 == '-10';
+
+> **Заўвага для ES5:** Лічбавыя літэралы, што пачынаюцца з `0` інтэрпрэтуюцца як
+> васьмірычныя (Base 8). Падтрымка васьмірычнай сістэмы была **прыбраная** у
+> ECMAScript 5 strict mode.
+
+Каб пазбегнуць вышэйпрыведзеных праблемаў, **настойліва** ракамендуецца выкарыстоўваць
+[аператар строгай роўнасці](#types.equality). Зрэшты, хоць гэта і пазбаўляе ад
+многіх распаўсюджаных праблемаў, існуе яшчэ шмат праблемаў, які ўзнікаюць праз
+слабую тыпізацыю JavaScript.
+
+### Канструктары ўбудаваных тыпаў
+
+Канструктары ўбудаваных тыпаў, напрыклад, `Number` і `String` паводзяць сябе
+па рознаму, у залежнасці ад таго, выклікаюцца яны з ключавым словам `new` або без яго.
+
+    new Number(10) === 10;     // False, Object і Number
+    Number(10) === 10;         // True, Number і Number
+    new Number(10) + 0 === 10; // True, праз неяўнае прывядзенне
+
+Выкарыстанне ўбудаванага тыпу, такога як `Number` у якасці канструкта створыць новы
+экзэмпляр аб'екта `Number`, але пры адсутнасці ключавога слова `new` функцыя
+`Number` будзе паводзіць сябе як канвертар.
+
+У дадатак, выкарытоўванне літэралаў, або значэнняў якія не з'яўляюцца аб'ектамі
+прывядзе да дадатковых прывядзенняў тыпаў.
+
+Лепшы варыянт - гэта **яўнае** прывядзенне да аднаго з трох магчымых тыпаў.
+
+### Прывядзенне да радка
+
+    '' + 10 === '10'; // true
+
+Праз даданне да значэння пустога радка, яно лёгка прыводзіцца да радка.
+
+### Прывядзенне да лікавага тыпу
+
+    +'10' === 10; // true
+
+Выкарыстоўваючы **унарны** аператар плюс, магчыма пераўтварыць значэнне ў нумар.
+
+### Прывядзенне да булевага тыпу
+
+Выкарыстоўваючы аператар **адмаўленне (!)** двойчы, значэнне можна прыведзена
+да лагічнага (булевага) тыпу.
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
diff --git a/doc/by/types/equality.md b/doc/by/types/equality.md
new file mode 100644
index 00000000..0859ce03
--- /dev/null
+++ b/doc/by/types/equality.md
@@ -0,0 +1,70 @@
+## Роўнасць і параўнанне
+
+У JavaScript роўнасць значэнняў аб'ектаў можна вызначыць двумя спосабамі.
+
+### Аператар роўнасці
+
+Аператар роўнасці складаецца з двух сімвалаў 'роўна': `==`
+
+JavaScript мае *слабую тыпізацыю*. Гэта значыць што аператар роўнасці
+**прыводзіць** тыпы аб'ектаў, каб параўнаць іх.
+
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+Вышэй прыведзеная табліца паказвае вынікі прывядзення тыпаў, і гэта галоўная прычына
+па якой выкаростоўванне `==` лічыцца дрэннай практыкай. Яно прыводзіць да памылак
+якія цяжка адсачыць праз складаны механізм прывядзення тыпаў.
+
+Акрамя гэтага, прывядзенне тыпаў таксама ўплывае на вытворчасць;
+напрыклад, радок мае быць ператвораны ў нумар, перад тым як быць параўнаным з
+іншым нумарам.
+
+### Аператар строгай роўнасці
+
+Аператар строгай роўнасці складаецца з **трох** сімвалаў 'роўна': `===`.
+
+Ён дзейнічае як звычайны аператар роўнасці, за выключэннем таго, што строгая
+роўнасць **не** прыводзіць аперанды да агульнага тыпу.
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+Вышэй прыведзеныя вынікі значна больш зразумелыя і даюць магчымасць хутчэй выявіць
+памылкі ў кодзе. Гэта паляпшае код, а таксама дае прырост вытворчасці, у выпадку
+калі аперанды розных тыпаў.
+
+### Параўнанне аб'ектаў
+
+Хоць абодва аператар `==` і `===` называюцца аператарамі **роўнасці**, яны паводзяць
+сабе па рознаму калі хоць адзін аперанд тыпа `Object`.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+Тут абодва аператанда параўноўваюцца на **ідэнтычнасць**, а **не** на роўнасць;
+то бок будзе праверана, ці з'яўляюцца яны адным **экзэмплярам** аб'екта. Гэтак жа,
+як `is` у Python, або параўнанне ўказальнікаў у C.
+
+### У заключэнне
+
+Настойліва рэкамендуецца выкарыстоўваць толькі аператар **строгай роўнасці**.
+У выпадку, калі тыпы маюць быць прыведзеныя, гэта варта рабіць [яўна](#types.casting),
+а не пакідаць іх на сумленні складаных правілаў прывядзення мовы праграмавання.
diff --git a/doc/by/types/instanceof.md b/doc/by/types/instanceof.md
new file mode 100644
index 00000000..220bc3c3
--- /dev/null
+++ b/doc/by/types/instanceof.md
@@ -0,0 +1,37 @@
+## Аператар `instanceof`
+
+Аператар `instanceof` параўноўвае канструктары двух аперандаў. Гэта карысна толькі
+для параўнання аб'ектаў не ўбудаваных тыпаў. Выкарыстоўванне на ўбудаваных тыпах не
+мае сэнсу, як і [аператар typeof](#types.typeof).
+
+### Параўнанне адвольных аб'ектаў
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // Калі толькі прысвоім Bar.prototype аб'ект функцыі Foo,
+    // але не самаго экзэмпляра Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### Выкарыстоўванне `instanceof` з убудаванымі тыпамі
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+Варта адзначыць, што `instanceof` не працуе на аб'ектах, якія паходзяць з розных
+кантэкстаў JavaScript (напрыклад, розных дакументаў у web-браузеры), бо іх канструктары
+насамрэч не будуць канструктарамі тых самых аб'ектаў.
+
+### У заключэнне
+
+Аператар `instanceof` мае быць выкарыстаны **толькі** для працы з аб'ектамі не
+ўбудаваных тыпаў якія паходзяць з аднаго кантэкста JavaScript. Як і ў выпадку з
+[аператарам `typeof`](#types.typeof), трэба **пазбягаць** любога іншага яго выкарыстання.
diff --git a/doc/by/types/typeof.md b/doc/by/types/typeof.md
new file mode 100644
index 00000000..7fb16ba9
--- /dev/null
+++ b/doc/by/types/typeof.md
@@ -0,0 +1,80 @@
+## Аператар `typeof`
+
+Аператар `typeof` (разам з [`instanceof`](#types.instanceof)) магчыма найбольшая
+хіба мовы JavaScript, таму што ён амаль што **цалкам зламаны**.
+
+Хаця `instanceof` усё яшчэ мае абмежаванае ўжыванне, `typeof` можа быць выкарыстаны
+толькі з адной мэтай, і гэта дарэчы **не** праверка тыпа.
+
+> **Заўвага:** Хаця для выкліка `typeof` можна выкарыстаць сінтаксіс функцыі, то бок
+> `typeof(obj)`, гэта не выклік функцыі. Дужкі будуць апрацоўвацца нармальна
+> і вернутае значэнне будзе выкарыстана як аперанд аператара `typeof`.
+> **Не існуе** функцыі `typeof`.
+
+### Табліца тыпаў JavaScript
+
+    Значэнне            Клас       Тып
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+У вышэй прыведзенай табыліцы, *Тып* паказвае значэнне вернутае аператарам `typeof`.
+Як можна пабачыць, гэта значэнне абсалютна не кансістэнтнае.
+
+*Клас* паказвае значэнне ўнутраннай уласцівасці `[[Class]]` аб'екта.
+
+> **З спецыфікацыі:** значэнне `[[Class]]` можа быць быць адным з наступных
+> радкоў. `Arguments`, `Array`, `Boolean`, `Date`, `Error`,
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+### Клас аб'екта
+
+Адзіны спосаб атрымаць значэнне `[[Class]]` аб'екта - выклікаць метад `Object.prototype.toString`.
+Ён верне радок у наступным фармаце: `'[object ' + valueOfClass + ']'`, напрыклад
+`[object String]` або `[object Array]`:
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+У вышэйпрыведзеным прыкладзе, `Object.prototype.toString` выклікаецца са значэннем
+[this](#function.this) пазначаным як аб'ект чыё значэнне `[[Class]]` мае быць
+атрыманым.
+
+> **Заўвага для ES5:** у ECMAScript 5, для зручнасці, значэнне `Object.prototype.toString`
+> для `null` і `undefined` было **зменена** з `Object` на `Null` і
+> `Undefined` адпаведна.
+
+### Праверка вызначанасці пераменных
+
+    typeof foo !== 'undefined'
+
+Вышэйпрыведзены код праверыць ці было вызначана `foo`; просты зварот да пераменнай
+прывядзе да `ReferenceError`. Гэта адзінае для чаго карысны `typeof`.
+
+### У заключэнне
+
+Каб праверыць тып аб'екта, настойліва рэкамендуецца выкарыстоўваць
+`Object.prototype.toString` - гэта адзіны надзейны спосаб.
+Як паказана ў вышэйпрыведзенай табліцы, некаторыя значэнні вернутыя аператарам
+`typeof` не вызначаныя ў спецыфікацыі; такім чынам, яны могуць быць рознымі ў
+розных рэалізацыях.
+
+Акрамя як для праверкі вызначанасці пераменнай, `typeof` мае быць пазбегнуты.
diff --git a/doc/de/intro/index.md b/doc/de/intro/index.md
index 94250e2f..01dca89b 100644
--- a/doc/de/intro/index.md
+++ b/doc/de/intro/index.md
@@ -1,4 +1,42 @@
 ## Einführung
 
-Demnächst.
+**JavaScript Garden** ist eine wachsende Sammlung von Erklärungen der verzwicktesten Teile von JavaScript. Es gibt 
+Hinweise um häufige Fehler, Performance Probleme und schlechten Stil zu vermeiden.
 
+JavaScript Garden ist **keine** Anleitung um JavaScript zu lernen. Ein grundlegendes Verständnis der Sprache wird 
+wärmstens empfohlen. Eine gute [Einführung][1] findet sich zum Beispiel im Mozilla Developer Network.
+
+## Die Autoren
+
+Dieses Dokument wurde von zwei liebenswerten [Stack Overflow][2] Benutzern geschrieben: [Ivo Wetzel][3]
+(Text) and [Zhang Yi Jiang][4] (Design).
+
+## Beitragende
+
+ - [Beitragende](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## Hosting
+
+JavaScript Garden wird von GitHub bereitgestellt, aber es wird auch von [Cramer Development][7] unterstützt durch 
+einen Mirror auf [JavaScriptGarden.info][8].
+
+## Lizenz
+
+JavaScript Garden wurde unter der [MIT Lizenz][9] veröffentlich und wird von [GitHub][10] veröffentlicht. Wenn du 
+Fehler findest mach bitte ein [Ticket][11] auf oder einen pull request ins repository. Du kannst uns auch im 
+[JavaScript Raum][12] des Stack Overflow Chats finden.
+
+Mehr demnächst.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.[stackoverflow.com/rooms/17/javascript
diff --git a/doc/en/array/constructor.md b/doc/en/array/constructor.md
index 763f55fb..408ec55c 100644
--- a/doc/en/array/constructor.md
+++ b/doc/en/array/constructor.md
@@ -1,7 +1,7 @@
 ## The `Array` Constructor
 
 Since the `Array` constructor is ambiguous in how it deals with its parameters,
-it is highly recommended to always use the array literals - `[]` notation - 
+it is highly recommended to use the array literal - `[]` notation - 
 when creating new arrays.
 
     [1, 2, 3]; // Result: [1, 2, 3]
@@ -11,25 +11,23 @@ when creating new arrays.
     new Array(3); // Result: []
     new Array('3') // Result: ['3']
 
-In cases when there is only one argument passed to the `Array` constructor,
-and that argument is a `Number`, the constructor will return a new *sparse* 
+In cases when there is only one argument passed to the `Array` constructor
+and when that argument is a `Number`, the constructor will return a new *sparse* 
 array with the `length` property set to the value of the argument. It should be 
-noted that **only** the `length` property of the new array will be set this way, 
+noted that **only** the `length` property of the new array will be set this way; 
 the actual indexes of the array will not be initialized. 
 
     var arr = new Array(3);
     arr[1]; // undefined
     1 in arr; // false, the index was not set
 
-The behavior of being able to set the length of the array upfront only comes in 
-handy in a few cases, like repeating a string, in which it avoids the use of a 
-`for loop` code.
+Being able to set the length of the array in advance is only useful in a few
+cases, like repeating a string, in which it avoids the use of a loop.
 
     new Array(count + 1).join(stringToRepeat);
 
 ### In Conclusion
 
-The use of the `Array` constructor should be avoided as much as possible. 
-Literals are definitely preferred. They are shorter and have a clearer syntax; 
-therefore, they also increase the readability of the code.
+Literals are preferred to the Array constructor. They are shorter, have a clearer syntax, and increase code
+readability.
 
diff --git a/doc/en/array/general.md b/doc/en/array/general.md
index 7c8f07ab..a78091d3 100644
--- a/doc/en/array/general.md
+++ b/doc/en/array/general.md
@@ -1,15 +1,15 @@
 ## Array Iteration and Properties
 
 Although arrays in JavaScript are objects, there are no good reasons to use
-the [`for in loop`](#object.forinloop) in for iteration on them. In fact there 
+the [`for in`](#object.forinloop) loop. In fact, there 
 are a number of good reasons **against** the use of `for in` on arrays.
 
 > **Note:** JavaScript arrays are **not** *associative arrays*. JavaScript only 
 > has [objects](#object.general) for mapping keys to values. And while associative 
 > arrays **preserve** order, objects **do not**.
 
-Since the `for in` loop enumerates all the properties that are on the prototype 
-chain and the only way to exclude those properties is to use 
+Because the `for in` loop enumerates all the properties that are on the prototype 
+chain and because the only way to exclude those properties is to use 
 [`hasOwnProperty`](#object.hasownproperty), it is already up to **twenty times** 
 slower than a normal `for` loop.
 
@@ -23,7 +23,7 @@ to use the classic `for` loop.
         console.log(list[i]);
     }
 
-There is one extra catch in the above example, that is the caching of the 
+There is one extra catch in the above example, which is the caching of the 
 length of the array via `l = list.length`.
 
 Although the `length` property is defined on the array itself, there is still an
@@ -40,19 +40,19 @@ While the *getter* of the `length` property simply returns the number of
 elements that are contained in the array, the *setter* can be used to 
 **truncate** the array.
 
-    var foo = [1, 2, 3, 4, 5, 6];
-    foo.length = 3;
-    foo; // [1, 2, 3]
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
 
-    foo.length = 6;
-    foo; // [1, 2, 3]
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
 
-Assigning a smaller length does truncate the array, but increasing the length 
-does not have any effect on the array.
+Assigning a smaller length truncates the array. Increasing it creates a sparse array.
 
 ### In Conclusion
 
-For the best performance it is recommended to always use the plain `for` loop
+For the best performance, it is recommended to always use the plain `for` loop
 and cache the `length` property. The use of `for in` on an array is a sign of
 badly written code that is prone to bugs and bad performance. 
 
diff --git a/doc/en/core/delete.md b/doc/en/core/delete.md
new file mode 100644
index 00000000..8e712412
--- /dev/null
+++ b/doc/en/core/delete.md
@@ -0,0 +1,85 @@
+## The `delete` Operator
+
+In short, it's *impossible* to delete global variables, functions and some other
+stuff in JavaScript which have a `DontDelete` attribute set.
+
+### Global code and Function code
+
+When a variable or a function is defined in a global or a [function
+scope](#function.scopes) it is a property of either the Activation object or
+the Global object. Such properties have a set of attributes, one of which is
+`DontDelete`. Variable and function declarations in global and function code
+always create properties with `DontDelete`, and therefore cannot be deleted.
+
+    // global variable:
+    var a = 1; // DontDelete is set
+    delete a; // false
+    a; // 1
+
+    // normal function:
+    function f() {} // DontDelete is set
+    delete f; // false
+    typeof f; // "function"
+
+    // reassigning doesn't help:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Explicit properties
+
+Explicitly set properties can be deleted normally.
+
+    // explicitly set property:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+In the example above, `obj.x` and `obj.y` can be deleted because they have no 
+`DontDelete` attribute. That's why the example below works too.
+
+    // this works fine, except for IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - just a global var
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Here we use a trick to delete `a`. [`this`](#function.this) here refers 
+to the Global object and we explicitly declare variable `a` as its property 
+which allows us to delete it.
+
+IE (at least 6-8) has some bugs, so the code above doesn't work.
+
+### Function arguments and built-ins
+
+Functions' normal arguments, [`arguments` objects](#function.arguments) 
+and built-in properties also have `DontDelete` set.
+
+    // function arguments and properties:
+    (function (x) {
+    
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Host objects
+    
+The behaviour of `delete` operator can be unpredictable for hosted objects. Due
+to the specification, host objects are allowed to implement any kind of behavior. 
+
+### In conclusion
+
+The `delete` operator often has unexpected behaviour and can only be safely
+used to delete explicitly set properties on normal objects.
diff --git a/doc/en/core/eval.md b/doc/en/core/eval.md
index ecf7ba90..6fa000f9 100644
--- a/doc/en/core/eval.md
+++ b/doc/en/core/eval.md
@@ -2,30 +2,30 @@
 
 The `eval` function will execute a string of JavaScript code in the local scope.
 
-    var foo = 1;
+    var number = 1;
     function test() {
-        var foo = 2;
-        eval('foo = 3');
-        return foo;
+        var number = 2;
+        eval('number = 3');
+        return number;
     }
     test(); // 3
-    foo; // 1
+    number; // 1
 
-But `eval` only executes in local scope when it is being called **directly** *and* 
-the name of the called function is actually `eval`.
+However, `eval` only executes in the local scope when it is being called
+directly *and* when the name of the called function is actually `eval`.
 
-    var foo = 1;
+    var number = 1;
     function test() {
-        var foo = 2;
-        var bar = eval;
-        bar('foo = 3');
-        return foo;
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
     }
     test(); // 2
-    foo; // 3
+    number; // 3
 
-The use of `eval` should be avoided at **all costs**. 99.9% of its "uses" can be
-achieved **without** it.
+The use of `eval` should be avoided. 99.9% of its "uses" can be achieved
+**without** it.
     
 ### `eval` in Disguise
 
@@ -35,14 +35,13 @@ in the global scope since `eval` is not being called directly in that case.
 
 ### Security Issues
 
-`eval` also is a security problem as it executes **any** code given to it,
-it should **never** be used with strings of unknown or untrusted origins.
+`eval` also is a security problem, because it executes **any** code given to it.
+It should **never** be used with strings of unknown or untrusted origins.
 
 ### In Conclusion
 
-`eval` should never be used, any code that makes use of it is to be questioned in
-its workings, performance and security. In case something requires `eval` in 
-order to work, its design is to be questioned and should **not** be used in the 
-first place, a *better design* should be used, that does not require the use of 
-`eval`. 
+`eval` should never be used. Any code that makes use of it should be questioned
+in its workings, performance and security. If something requires `eval` in
+order to work, it should **not** be used in the first place.  A *better design*
+should be used, that does not require the use of `eval`.
 
diff --git a/doc/en/core/semicolon.md b/doc/en/core/semicolon.md
index 61d74fd9..e6b2563d 100644
--- a/doc/en/core/semicolon.md
+++ b/doc/en/core/semicolon.md
@@ -1,10 +1,10 @@
 ## Automatic Semicolon Insertion
 
 Although JavaScript has C style syntax, it does **not** enforce the use of
-semicolons in the source code, it is possible to omit them.
+semicolons in the source code, so it is possible to omit them.
 
-But JavaScript is not a semicolon-less language, it in fact needs the 
-semicolons in order to understand the source code. Therefore the JavaScript
+JavaScript is not a semicolon-less language. In fact, it needs the 
+semicolons in order to understand the source code. Therefore, the JavaScript
 parser **automatically** inserts them whenever it encounters a parse
 error due to a missing semicolon.
 
@@ -19,7 +19,7 @@ Insertion happens, and the parser tries again.
     test()
 
 The automatic insertion of semicolon is considered to be one of **biggest**
-design flaws in the language, as it *can* change the behavior of code.
+design flaws in the language because it *can* change the behavior of code.
 
 ### How it Works
 
@@ -84,10 +84,10 @@ Below is the result of the parser's "guessing" game.
     })(window); //<- inserted
 
 > **Note:** The JavaScript parser does not "correctly" handle return statements 
-> which are followed by a new line, while this is not neccessarily the fault of 
+> that are followed by a new line. While this is not necessarily the fault of
 > the automatic semicolon insertion, it can still be an unwanted side-effect. 
 
-The parser drastically changed the behavior of the code above, in certain cases
+The parser drastically changed the behavior of the code above. In certain cases,
 it does the **wrong thing**.
 
 ### Leading Parenthesis
@@ -106,9 +106,9 @@ the above will yield a `TypeError` stating that `undefined is not a function`.
 
 ### In Conclusion
 
-It is highly recommended to **never** omit semicolons, it is also advocated to 
-keep braces on the same line with their corresponding statements and to never omit 
-them for one single-line `if` / `else` statements. Both of these measures will 
-not only improve the consistency of the code, they will also prevent the 
-JavaScript parser from changing its behavior.
+It is highly recommended to **never** omit semicolons. It is also recommended
+that braces be kept on the same line as their corresponding statements and to
+never omit them for single-line `if` / `else` statements. These measures will
+not only improve the consistency of the code, but they will also prevent the
+JavaScript parser from changing code behavior.
 
diff --git a/doc/en/core/undefined.md b/doc/en/core/undefined.md
index b29da3b4..1bea5411 100644
--- a/doc/en/core/undefined.md
+++ b/doc/en/core/undefined.md
@@ -1,29 +1,31 @@
 ## `undefined` and `null`
 
-JavaScript has two distinct values for `nothing`, the more useful of these two
-being `undefined`.
+JavaScript has two distinct values for nothing, `null` and `undefined`, with
+the latter being more useful.
 
 ### The Value `undefined`
 
 `undefined` is a type with exactly one value: `undefined`.
 
-The language also defines a global variable that has the value of `undefined`,
-this variable is also called `undefined`. But this variable is **not** a constant,
-nor is it a keyword of the language. This means that its *value* can be easily 
+The language also defines a global variable that has the value of `undefined`;
+this variable is also called `undefined`. However, this variable is **neither** a constant
+nor a keyword of the language. This means that its *value* can be easily 
 overwritten.
 
 > **ES5 Note:** `undefined` in ECMAScript 5 is **no longer** *writable* in strict
 > mode, but its name can still be shadowed by for example a function with the name 
 > `undefined`.
 
-Some examples for when the value `undefined` is returned:
+Here are some examples of when the value `undefined` is returned:
 
  - Accessing the (unmodified) global variable `undefined`.
+ - Accessing a declared *but not* yet initialized variable.
  - Implicit returns of functions due to missing `return` statements.
- - `return` statements which do not explicitly return anything.
+ - `return` statements that do not explicitly return anything.
  - Lookups of non-existent properties.
- - Function parameters which do not had any explicit value passed.
+ - Function parameters that do not have any explicit value passed.
  - Anything that has been set to the value of `undefined`.
+ - Any expression in the form of `void(expression)`
 
 ### Handling Changes to the Value of `undefined`
 
@@ -31,17 +33,17 @@ Since the global variable `undefined` only holds a copy of the actual *value* of
 `undefined`, assigning a new value to it does **not** change the value of the 
 *type* `undefined`.
 
-Still, in order to compare something against the value of `undefined` it is
+Still, in order to compare something against the value of `undefined`, it is
 necessary to retrieve the value of `undefined` first.
 
-In order to protect code against a possible overwritten `undefined` variable, a 
-common technique used is to add an additional parameter to an
-[anonymous wrapper](#function.scopes), that gets no argument passed to it.
+To protect code against a possible overwritten `undefined` variable, a common
+technique used is to add an additional parameter to an [anonymous
+wrapper](#function.scopes) that gets no argument passed to it.
 
     var undefined = 123;
     (function(something, foo, undefined) {
         // undefined in the local scope does 
-        // now again refer to the value
+        // now again refer to the value `undefined`
 
     })('Hello World', 42);
 
@@ -55,8 +57,8 @@ wrapper.
 
     })('Hello World', 42);
 
-The only difference being here, that this version results in 4 more bytes being
-used in case it is minified and there is no other `var` statement inside the
+The only difference here is that this version results in 4 more bytes being
+used in case it is minified, and there is no other `var` statement inside the
 anonymous wrapper.
 
 ### Uses of `null`
@@ -66,7 +68,7 @@ the sense of a traditional *null*, the actual `null` (both a literal and a type)
 is more or less just another data type.
 
 It is used in some JavaScript internals (like declaring the end of the
-prototype chain by setting `Foo.prototype = null`), but in almost all cases it
+prototype chain by setting `Foo.prototype = null`), but in almost all cases, it
 can be replaced by `undefined`.
 
 
diff --git a/doc/en/function/arguments.md b/doc/en/function/arguments.md
index 3d551ad5..fec3d8e4 100644
--- a/doc/en/function/arguments.md
+++ b/doc/en/function/arguments.md
@@ -23,8 +23,8 @@ The code below will return a new `Array` containing all the elements of the
 
     Array.prototype.slice.call(arguments);
 
-This conversion is **slow**, it is **not recommended** to use it in performance 
-critical sections of code.
+Because this conversion is **slow**, it is **not recommended** to use it in
+performance-critical sections of code.
 
 ### Passing Arguments
 
@@ -38,35 +38,49 @@ another.
         // do stuff here
     }
 
-Another trick is to use both `call` and `apply` together to create fast, unbound
-wrappers.
+Another trick is to use both `call` and `apply` together to turn methods - functions that use the
+value of `this` as well as their arguments - into normal functions which only use their arguments.
 
-    function Foo() {}
+    function Person(first, last) {
+      this.first = first;
+      this.last = last;
+    }
 
-    Foo.prototype.method = function(a, b, c) {
-        console.log(this, a, b, c);
+    Person.prototype.fullname = function(joiner, options) {
+      options = options || { order: "western" };
+      var first = options.order === "western" ? this.first : this.last;
+      var last =  options.order === "western" ? this.last  : this.first;
+      return first + (joiner || " ") + last;
     };
 
-    // Create an unbound version of "method" 
-    // It takes the parameters: this, arg1, arg2...argN
-    Foo.method = function() {
-
-        // Result: Foo.prototype.method.call(this, arg1, arg2... argN)
-        Function.call.apply(Foo.prototype.method, arguments);
+    // Create an unbound version of "fullname", usable on any object with 'first'
+    // and 'last' properties passed as the first argument. This wrapper will
+    // not need to change if fullname changes in number or order of arguments.
+    Person.fullname = function() {
+      // Result: Person.prototype.fullname.call(this, joiner, ..., argN);
+      return Function.call.apply(Person.prototype.fullname, arguments);
     };
 
+    var grace = new Person("Grace", "Hopper");
+
+    // 'Grace Hopper'
+    grace.fullname();
+
+    // 'Turing, Alan'
+    Person.fullname({ first: "Alan", last: "Turing" }, ", ", { order: "eastern" });
+
 
 ### Formal Parameters and Arguments Indices
 
 The `arguments` object creates *getter* and *setter* functions for both its 
-properties as well as the function's formal parameters.
+properties, as well as the function's formal parameters.
 
 As a result, changing the value of a formal parameter will also change the value
 of the corresponding property on the `arguments` object, and the other way around.
 
     function foo(a, b, c) {
         arguments[0] = 2;
-        a; // 2                                                           
+        a; // 2
 
         b = 4;
         arguments[1]; // 4
@@ -79,9 +93,9 @@ of the corresponding property on the `arguments` object, and the other way aroun
 
 ### Performance Myths and Truths
 
-The `arguments` object is always created with the only two exceptions being the 
-cases where it is declared as a name inside of a function or one of its formal 
-parameters. It does not matter whether it is used or not.
+The only time  the `arguments` object is not created is where it is declared as
+a name inside of a function or one of its formal parameters. It does not matter
+whether it is used or not.
 
 Both *getters* and *setters* are **always** created; thus, using it has nearly 
 no performance impact at all, especially not in real world code where there is 
@@ -105,11 +119,10 @@ modern JavaScript engines. That case is the use of `arguments.callee`.
 
 In the above code, `foo` can no longer be a subject to [inlining][1] since it 
 needs to know about both itself and its caller. This not only defeats possible 
-performance gains that would arise from inlining, it also breaks encapsulation
-since the function may now be dependent on a specific calling context.
+performance gains that would arise from inlining, but it also breaks encapsulation
+because the function may now be dependent on a specific calling context.
 
-It is **highly recommended** to **never** make use of `arguments.callee` or any of 
-its properties.
+Making use of `arguments.callee` or any of its properties is **highly discouraged**.
 
 > **ES5 Note:** In strict mode, `arguments.callee` will throw a `TypeError` since 
 > its use has been deprecated.
diff --git a/doc/en/function/closures.md b/doc/en/function/closures.md
index 17554dcb..aef633b9 100644
--- a/doc/en/function/closures.md
+++ b/doc/en/function/closures.md
@@ -1,8 +1,8 @@
 ## Closures and References
 
-One of JavaScript's most powerful features is the availability of *closures*,
-this means that scopes **always** keep access to the outer scope they were
-defined in. Since the only scoping that JavaScript has is 
+One of JavaScript's most powerful features is the availability of *closures*.
+With closures, scopes **always** keep access to the outer scope, in which they
+were defined. Since the only scoping that JavaScript has is 
 [function scope](#function.scopes), all functions, by default, act as closures.
 
 ### Emulating private variables
@@ -24,10 +24,10 @@ defined in. Since the only scoping that JavaScript has is
     foo.increment();
     foo.get(); // 5
 
-Here, `Counter` returns **two** closures. The function `increment` as well as 
+Here, `Counter` returns **two** closures: the function `increment` as well as 
 the function `get`. Both of these functions keep a **reference** to the scope of 
 `Counter` and, therefore, always keep access to the `count` variable that was 
-defined in that very scope.
+defined in that scope.
 
 ### Why Private Variables Work
 
@@ -36,18 +36,18 @@ Since it is not possible to reference or assign scopes in JavaScript, there is
 interact with it is via the two closures.
 
     var foo = new Counter(4);
-    foo.hack = function() {
+    foo.hackFail = function() {
         count = 1337;
     };
 
 The above code will **not** change the variable `count` in the scope of `Counter`, 
-since `foo.hack` was not defined in **that** scope. It will instead create - or 
+since `foo.hackFail` was not defined in **that** scope. It will instead create - or 
 override - the *global* variable `count`.
 
 ### Closures Inside Loops
 
 One often made mistake is to use closures inside of loops, as if they were
-copying the value of the loops index variable.
+copying the value of the loop's index variable.
 
     for(var i = 0; i < 10; i++) {
         setTimeout(function() {
@@ -58,9 +58,9 @@ copying the value of the loops index variable.
 The above will **not** output the numbers `0` through `9`, but will simply print
 the number `10` ten times.
 
-The *anonymous* function keeps a **reference** to `i` and at the time 
-`console.log` gets called, the `for loop` has already finished and the value of 
-`i` as been set to `10`.
+The *anonymous* function keeps a **reference** to `i`. At the time 
+`console.log` gets called, the `for loop` has already finished, and the value of 
+`i` has been set to `10`.
 
 In order to get the desired behavior, it is necessary to create a **copy** of 
 the value of `i`.
@@ -84,8 +84,8 @@ argument and will receive a copy of the **value** of `i` as its parameter `e`.
 The anonymous function that gets passed to `setTimeout` now has a reference to 
 `e`, whose value does **not** get changed by the loop.
 
-There is another possible way of achieving this; that is to return a function 
-from the anonymous wrapper, that will then have the same behavior as the code 
+There is another possible way of achieving this, which is to return a function 
+from the anonymous wrapper that will then have the same behavior as the code 
 above.
 
     for(var i = 0; i < 10; i++) {
@@ -96,3 +96,21 @@ above.
         })(i), 1000)
     }
 
+The other popular way to achieve this is to add an additional argument to
+the `setTimeout` function, which passes these arguments to the callback.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function(e) {
+            console.log(e);  
+        }, 1000, i);
+    }
+
+Some legacy JS environments (Internet Explorer 9 & below) do not support this.
+
+There's yet another way to accomplish this by using `.bind`, which can bind
+a `this` context and arguments to function. It behaves identically to the code
+above
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
diff --git a/doc/en/function/constructors.md b/doc/en/function/constructors.md
index ad90b028..e84a6cf8 100644
--- a/doc/en/function/constructors.md
+++ b/doc/en/function/constructors.md
@@ -4,52 +4,52 @@ Constructors in JavaScript are yet again different from many other languages. An
 function call that is preceded by the `new` keyword acts as a constructor.
 
 Inside the constructor - the called function - the value of `this` refers to a 
-newly created `Object`. The [`prototype`](#object.prototype) of this **new** 
+newly created object. The [prototype](#object.prototype) of this **new** 
 object is set to the `prototype` of the function object that was invoked as the
 constructor.
 
 If the function that was called has no explicit `return` statement, then it
 implicitly returns the value of `this` - the new object. 
 
-    function Foo() {
-        this.bla = 1;
+    function Person(name) {
+        this.name = name;
     }
 
-    Foo.prototype.test = function() {
-        console.log(this.bla);
+    Person.prototype.logName = function() {
+        console.log(this.name);
     };
 
-    var test = new Foo();
+    var sean = new Person();
 
-The above calls `Foo` as constructor and sets the `prototype` of the newly
-created object to `Foo.prototype`.
+The above calls `Person` as constructor and sets the `prototype` of the newly
+created object to `Person.prototype`.
 
-In case of an explicit `return` statement the function returns the value 
-specified that statement, **but only** if the return value is an `Object`.                                     
+In case of an explicit `return` statement, the function returns the value 
+specified by that statement, but **only** if the return value is an `Object`.
 
-    function Bar() {
-        return 2;
+    function Car() {
+        return 'ford';
     }
-    new Bar(); // a new object
+    new Car(); // a new object, not 'ford'
 
-    function Test() {
-        this.value = 2;
+    function Person() {
+        this.someValue = 2;
 
         return {
-            foo: 1
+            name: 'Charles'
         };
     }
-    new Test(); // the returned object
+    new Person(); // the returned object ({name:'Charles'}), not including someValue
 
 When the `new` keyword is omitted, the function will **not** return a new object. 
 
-    function Foo() {
-        this.bla = 1; // gets set on the global object
+    function Pirate() {
+        this.hasEyePatch = true; // gets set on the global object!
     }
-    Foo(); // undefined
+    var somePirate = Pirate(); // somePirate is undefined
 
-While the above example might still appear to work in some cases, due to the 
-workings of [`this`](#function.this) in JavaScript, it will use the 
+While the above example might still appear to work in some cases, due to the
+workings of [`this`](#function.this) in JavaScript, it will use the
 *global object* as the value of `this`.
 
 ### Factories
@@ -57,28 +57,25 @@ workings of [`this`](#function.this) in JavaScript, it will use the
 In order to be able to omit the `new` keyword, the constructor function has to 
 explicitly return a value.
 
-    function Bar() {
-        var value = 1;
+    function Robot() {
+        var color = 'gray';
         return {
-            method: function() {
-                return value;
+            getColor: function() {
+                return color;
             }
         }
     }
-    Bar.prototype = {
-        foo: function() {}
-    };
 
-    new Bar();
-    Bar();
+    new Robot();
+    Robot();
 
-Both calls to `Bar` return the exact same thing, a newly create object which
-has a property called `method` on it, that is a 
+Both calls to `Robot` return the same thing, a newly created object that
+has a property called `getColor`, which is a 
 [Closure](#function.closures).
 
-It is also to note that the call `new Bar()` does **not** affect the prototype 
-of the returned object. While the prototype will be set on the newly created 
-object, `Bar` never returns that new object.
+It should also be noted that the call `new Robot()` does **not** affect the
+prototype of the returned object. While the prototype will be set on the newly
+created object, `Robot` never returns that new object.
 
 In the above example, there is no functional difference between using and
 not using the `new` keyword.
@@ -86,25 +83,27 @@ not using the `new` keyword.
 
 ### Creating New Objects via Factories
 
-An often made recommendation is to **not** use `new` since forgetting its use
-may lead to bugs.
+It is often recommended to **not** use `new` because forgetting its use may
+lead to bugs.
 
-In order to create new object, one should rather use a factory and construct a 
+In order to create a new object, one should rather use a factory and construct a 
 new object inside of that factory.
 
-    function Foo() {
-        var obj = {};
-        obj.value = 'blub';
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
+
+        var milesPerGallon = 2;
 
-        var private = 2;
-        obj.someMethod = function(value) {
-            this.value = value;
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
         }
 
-        obj.getPrivate = function() {
-            return private;
+        car.getMPG = function() {
+            return milesPerGallon;
         }
-        return obj;
+
+        return car;
     }
 
 While the above is robust against a missing `new` keyword and certainly makes 
@@ -113,16 +112,16 @@ downsides.
 
  1. It uses more memory since the created objects do **not** share the methods
     on a prototype.
- 2. In order to inherit the factory needs to copy all the methods from another
+ 2. In order to inherit, the factory needs to copy all the methods from another
     object or put that object on the prototype of the new object.
  3. Dropping the prototype chain just because of a left out `new` keyword
-    somehow goes against the spirit of the language.
+    is contrary to the spirit of the language.
 
 ### In Conclusion
 
-While omitting the `new` keyword might lead to bugs, it is certainly **not** a 
-reason to drop the use of prototypes altogether. In the end it comes down to 
-which solution is better suited for the needs of the application, it is 
-especially important to choose a specific style of object creation **and stick** 
-with it.
+While omitting the `new` keyword might lead to bugs, it is certainly **not** a
+reason to drop the use of prototypes altogether. In the end it comes down to
+which solution is better suited for the needs of the application. It is
+especially important to choose a specific style of object creation and use it
+**consistently**.
 
diff --git a/doc/en/function/general.md b/doc/en/function/general.md
index 64c9e0c9..7e1c51c7 100644
--- a/doc/en/function/general.md
+++ b/doc/en/function/general.md
@@ -2,15 +2,15 @@
 
 Functions in JavaScript are first class objects. That means they can be 
 passed around like any other value. One common use of this feature is to pass
-an *anonymous function* as a callback to another, possibly asynchronous function.
+an *anonymous function* as a callback to another, possibly an asynchronous function.
 
 ### The `function` Declaration
 
     function foo() {}
 
-The above function gets [hoisted](#function.scopes) before the execution of the 
-program starts; thus, it is available *everywhere* in the scope it was *defined* 
-in, even if called before the actual definition in the source.
+The above function gets [hoisted](#function.scopes) before the execution of the
+program starts; thus, it is available *everywhere* in the scope it was
+*defined*, even if called before the actual definition in the source.
 
     foo(); // Works because foo was created before this code runs
     function foo() {}
@@ -25,8 +25,8 @@ This example assigns the unnamed and *anonymous* function to the variable `foo`.
     foo(); // this raises a TypeError
     var foo = function() {};
 
-Due to the fact that `var` is a declaration, that hoists the variable name `foo` 
-before the actual execution of the code starts, `foo` is already defined when 
+Due to the fact that `var` is a declaration that hoists the variable name `foo` 
+before the actual execution of the code starts, `foo` is already declared when 
 the script gets executed.
 
 But since assignments only happen at runtime, the value of `foo` will default
@@ -41,8 +41,8 @@ Another special case is the assignment of named functions.
     }
     bar(); // ReferenceError
 
-Here `bar` is not available in the outer scope, since the function only gets
-assigned to `foo`; however, inside of `bar` it is available. This is due to 
+Here, `bar` is not available in the outer scope, since the function only gets
+assigned to `foo`; however, inside of `bar`, it is available. This is due to 
 how [name resolution](#function.scopes) in JavaScript works, the name of the 
 function is *always* made available in the local scope of the function itself.
 
diff --git a/doc/en/function/scopes.md b/doc/en/function/scopes.md
index 7ae5e4f5..33d525e1 100644
--- a/doc/en/function/scopes.md
+++ b/doc/en/function/scopes.md
@@ -2,7 +2,7 @@
 
 Although JavaScript deals fine with the syntax of two matching curly
 braces for blocks, it does **not** support block scope; hence, all that is left 
-is in the language is *function scope*.
+in the language is *function scope*.
 
     function test() { // a scope
         for(var i = 0; i < 10; i++) { // not a scope
@@ -16,7 +16,7 @@ is in the language is *function scope*.
 > **not** as an object literal. This, in conjunction with 
 > [automatic insertion of semicolons](#core.semicolon), can lead to subtle errors.
 
-There are also no distinct namespaces in JavaScript, that means that everything 
+There are also no distinct namespaces in JavaScript, which means that everything 
 gets defined in one *globally shared* namespace.
 
 Each time a variable is referenced, JavaScript will traverse upwards through all 
@@ -32,10 +32,10 @@ still has not found the requested name, it will raise a `ReferenceError`.
     var foo = '42'
 
 The above two scripts do **not** have the same effect. Script A defines a 
-variable called `foo` in the *global* scope and script B defines a `foo` in the
+variable called `foo` in the *global* scope, and script B defines a `foo` in the
 *current* scope.
 
-Again, that is **not** at all the *same effect*, not using `var` can have major 
+Again, that is **not** at all the *same effect*: not using `var` can have major 
 implications.
 
     // global scope
@@ -49,8 +49,8 @@ implications.
 
 Leaving out the `var` statement inside the function `test` will override the 
 value of `foo`. While this might not seem like a big deal at first, having 
-thousands of lines of JavaScript and not using `var` will introduce horrible and 
-hard to track down bugs.
+thousands of lines of JavaScript and not using `var` will introduce horrible,
+hard-to-track-down bugs.
     
     // global scope
     var items = [/* some list */];
@@ -73,7 +73,7 @@ unless the *desired effect* is to affect the outer scope.
 ### Local Variables
 
 The only source for local variables in JavaScript are
-[function](#function.general) parameters and variables that were declared via the 
+[function](#function.general) parameters and variables declared via the 
 `var` statement.
 
     // global scope
@@ -115,14 +115,14 @@ JavaScript **hoists** declarations. This means that both `var` statements and
         }
     }
 
-The above code gets transformed before any execution is started. JavaScript moves
-the `var` statements as well as the `function` declarations to the top of the 
+The above code gets transformed before execution starts. JavaScript moves
+the `var` statements, as well as `function` declarations, to the top of the 
 nearest surrounding scope.
 
     // var statements got moved here
     var bar, someValue; // default to 'undefined'
 
-    // the function declartion got moved up too
+    // the function declaration got moved up too
     function test(data) {
         var goo, i, e; // missing block scope moves these here
         if (false) {
@@ -146,24 +146,24 @@ Missing block scoping will not only move `var` statements out of loops and
 their bodies, it will also make the results of certain `if` constructs 
 non-intuitive.
 
-In the original code the `if` statement seemed to modify the *global 
-variable* `goo`, while actually it modifies the *local variable* - after hoisting 
+In the original code, although the `if` statement seemed to modify the *global 
+variable* `goo`, it actually modifies the *local variable* - after hoisting 
 has been applied.
 
-Without the knowledge about *hoisting*, below code might seem to raise a 
+Without knowledge of *hoisting*, one might suspect the code below would raise a
 `ReferenceError`.
 
-    // check whether SomeImportantThing has been initiliazed
+    // check whether SomeImportantThing has been initialized
     if (!SomeImportantThing) {
         var SomeImportantThing = {};
     }
 
-But of course, the above works due to the fact that the `var` statement is being 
+But of course, this works due to the fact that the `var` statement is being 
 moved to the top of the *global scope*.
 
     var SomeImportantThing;
 
-    // other code might initiliaze SomeImportantThing here, or not
+    // other code might initialize SomeImportantThing here, or not
 
     // make sure it's there
     if (!SomeImportantThing) {
@@ -173,27 +173,27 @@ moved to the top of the *global scope*.
 ### Name Resolution Order
 
 All scopes in JavaScript, including the *global scope*, have the special name 
-[`this`](#function.this) defined in them, which refers to the *current object*. 
+[`this`](#function.this), defined in them, which refers to the *current object*. 
 
-Function scopes also have the name [`arguments`](#function.arguments) defined in
-them which contains the arguments that were passed to a function.
+Function scopes also have the name [`arguments`](#function.arguments), defined in
+them, which contains the arguments that were passed to the function.
 
 For example, when trying to access a variable named `foo` inside the scope of a 
-function, JavaScript will lookup the name in the following order:
+function, JavaScript will look up the name in the following order:
 
- 1. In case there is a `var foo` statement in the current scope use that.
- 2. If one of the function parameters is named `foo` use that.
- 3. If the function itself is called `foo` use that.
- 4. Go to the next outer scope and start with **#1** again.
+ 1. In case there is a `var foo` statement in the current scope, use that.
+ 2. If one of the function parameters is named `foo`, use that.
+ 3. If the function itself is called `foo`, use that.
+ 4. Go to the next outer scope, and start with **#1** again.
 
 > **Note:** Having a parameter called `arguments` will **prevent** the creation 
 > of the default `arguments` object.
 
 ### Namespaces
 
-A common problem of having only one global namespace is the likeliness of running
-into problems where variable names clash. In JavaScript, this problem can
-easily be avoided with the help of *anonymous wrappers*.
+A common problem associated with having only one global namespace is the
+likelihood of running into problems where variable names clash. In JavaScript,
+this problem can easily be avoided with the help of *anonymous wrappers*.
 
     (function() {
         // a self contained "namespace"
@@ -206,24 +206,27 @@ easily be avoided with the help of *anonymous wrappers*.
 
 
 Unnamed functions are considered [expressions](#function.general); so in order to
-being callable, they must first be evaluated.
+be callable, they must first be evaluated.
 
-    ( // evaluate the function inside the paranthesis
+    ( // evaluate the function inside the parentheses
     function() {}
     ) // and return the function object
     () // call the result of the evaluation
 
-There are other ways for evaluating and calling the function expression; which, 
-while different in syntax, do behave the exact same way.
+There are other ways to evaluate and directly call the function expression
+which, while different in syntax, behave the same way.
 
-    // Two other ways
-    +function(){}();
+    // A few other styles for directly invoking the 
+    !function(){}()
+    +function(){}()
     (function(){}());
+    void function(){}();
+    // and so on...
 
 ### In Conclusion
 
-It is recommended to always use an *anonymous wrapper* for encapsulating code in 
-its own namespace. This does not only protect code against name clashes, it 
+It is recommended to always use an *anonymous wrapper* to encapsulate code in 
+its own namespace. This does not only protect code against name clashes, but it 
 also allows for better modularization of programs.
 
 Additionally, the use of global variables is considered **bad practice**. **Any**
diff --git a/doc/en/function/this.md b/doc/en/function/this.md
index 85b11f0f..83abff00 100644
--- a/doc/en/function/this.md
+++ b/doc/en/function/this.md
@@ -1,7 +1,7 @@
 ## How `this` Works
 
 JavaScript has a different concept of what the special name `this` refers to 
-than most other programming languages do. There are exactly **five** different 
+than most other programming languages. There are exactly **five** different 
 ways in which the value of `this` can be bound in the language.
 
 ### The Global Scope
@@ -15,7 +15,7 @@ When using `this` in global scope, it will simply refer to the *global* object.
 
     foo();
 
-Here `this` will again refer to the *global* object.
+Here, `this` will again refer to the *global* object.
 
 > **ES5 Note:** In strict mode, the global case **no longer** exists.
 > `this` will instead have the value of `undefined` in that case.
@@ -24,14 +24,14 @@ Here `this` will again refer to the *global* object.
 
     test.foo(); 
 
-In this example `this` will refer to `test`.
+In this example, `this` will refer to `test`.
 
 ### Calling a Constructor
 
     new foo(); 
 
 A function call that is preceded by the `new` keyword acts as
-a [constructor](#function.constructors). Inside the function `this` will refer 
+a [constructor](#function.constructors). Inside the function, `this` will refer 
 to a *newly created* `Object`.
 
 ### Explicit Setting of `this`
@@ -46,7 +46,7 @@ When using the `call` or `apply` methods of `Function.prototype`, the value of
 `this` inside the called function gets **explicitly set** to the first argument 
 of the corresponding function call.
 
-As a result, the above example the *method case* does **not** apply, and `this` 
+As a result, in the above example the *method case* does **not** apply, and `this` 
 inside of `foo` will be set to `bar`.
 
 > **Note:** `this` **cannot** be used to refer to the object inside of an `Object`
@@ -55,47 +55,56 @@ inside of `foo` will be set to `bar`.
 
 ### Common Pitfalls
 
-While most of these cases make sense, the first one is to be considered another
-mis-design of the language, as it **never** has any practical use.
+While most of these cases make sense, the first can be considered another
+mis-design of the language because it **never** has any practical use.
 
     Foo.method = function() {
         function test() {
             // this is set to the global object
         }
         test();
-    }
+    };
 
-A common misconception is that `this` inside of `test` refers to `Foo`, while in
-fact it **does not**.
+A common misconception is that `this` inside of `test` refers to `Foo`; while in
+fact, it **does not**.
 
-In order to gain access to `Foo` from within `test` it is necessary to create a 
-local variable inside of `method` which refers to `Foo`.
+In order to gain access to `Foo` from within `test`, you can create a
+local variable inside of `method` that refers to `Foo`.
 
     Foo.method = function() {
-        var that = this;
+        var self = this;
         function test() {
-            // Use that instead of this here
+            // Use self instead of this here
         }
         test();
-    }
+    };
 
-`that` is just a normal variable name, but it is commonly used for the reference to an 
+`self` is just a normal variable name, but it is commonly used for the reference to an
 outer `this`. In combination with [closures](#function.closures), it can also 
 be used to pass `this` values around.
 
+As of ECMAScript 5 you can use the `bind` method combined with an anonymous function to achieve the same result. 
+
+    Foo.method = function() {
+        var test = function() {
+            // this now refers to Foo
+        }.bind(this);
+        test();
+    };
+
 ### Assigning Methods
 
-Another thing that does **not** work in JavaScript is function aliasing, that is,
+Another thing that does **not** work in JavaScript is function aliasing, which is
 **assigning** a method to a variable.
 
     var test = someObject.methodTest;
     test();
 
-Due to the first case `test` now acts like a plain function call; therefore,
+Due to the first case, `test` now acts like a plain function call; therefore,
 `this` inside it will no longer refer to `someObject`.
 
-While the late binding of `this` might seem like a bad idea at first, it is in 
-fact what makes [prototypal inheritance](#object.prototype) work. 
+While the late binding of `this` might seem like a bad idea at first, in 
+fact, it is what makes [prototypal inheritance](#object.prototype) work. 
 
     function Foo() {}
     Foo.prototype.method = function() {};
@@ -105,7 +114,7 @@ fact what makes [prototypal inheritance](#object.prototype) work.
 
     new Bar().method();
 
-When `method` gets called on a instance of `Bar`, `this` will now refer to that
+When `method` gets called on an instance of `Bar`, `this` will now refer to that
 very instance. 
 
 
diff --git a/doc/en/index.json b/doc/en/index.json
index d4012ed9..283e4b69 100644
--- a/doc/en/index.json
+++ b/doc/en/index.json
@@ -6,7 +6,7 @@
         {
             "title": "Intro",
             "dir": "intro",
-            "articles": []
+            "articles": ["index"]
         },
         {
             "title": "Objects",
@@ -54,7 +54,8 @@
             "articles": [
                 "eval",
                 "undefined",
-                "semicolon"
+                "semicolon",
+                "delete"
             ]
         },
         {
diff --git a/doc/en/intro/index.md b/doc/en/intro/index.md
index 6ddd7c71..411f8a7b 100644
--- a/doc/en/intro/index.md
+++ b/doc/en/intro/index.md
@@ -2,8 +2,8 @@
 
 **JavaScript Garden** is a growing collection of documentation about the most 
 quirky parts of the JavaScript programming language. It gives advice to 
-avoid common mistakes, subtle bugs, as well as performance issues and bad 
-practices that non-expert JavaScript programmers may encounter on their 
+avoid common mistakes and subtle bugs, as well as performance issues and bad 
+practices, that non-expert JavaScript programmers may encounter on their 
 endeavours into the depths of the language.
 
 JavaScript Garden does **not** aim to teach you JavaScript. Former knowledge
@@ -16,10 +16,12 @@ the excellent [guide][1] on the Mozilla Developer Network.
 This guide is the work of two lovely [Stack Overflow][2] users, [Ivo Wetzel][3]
 (Writing) and [Zhang Yi Jiang][4] (Design).
 
+It's currently maintained by [Tim Ruffles](http://truffles.me.uk).
+
 ## Contributors
 
- - [Caio Romão][5] (Spelling corrections)
- - [Andreas Blixt][6] (Language corrections)
+- Too many to list here, [see all contributors](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
 
 ## Hosting
 
@@ -31,7 +33,7 @@ with a mirror at [JavaScriptGarden.info][8].
 JavaScript Garden is published under the [MIT license][9] and hosted on
 [GitHub][10]. If you find errors or typos please [file an issue][11] or a pull 
 request on the repository. You can also find us in the [JavaScript room][12] on
-Stack Overflow chat. 
+Stack Overflow chat.
 
 [1]: https://developer.mozilla.org/en/JavaScript/Guide
 [2]: http://stackoverflow.com/
diff --git a/doc/en/object/forinloop.md b/doc/en/object/forinloop.md
index 30751ed9..28d586c4 100644
--- a/doc/en/object/forinloop.md
+++ b/doc/en/object/forinloop.md
@@ -1,12 +1,12 @@
 ## The `for in` Loop
 
-Just like the `in` operator, the `for in` loop also traverses the prototype
+Just like the `in` operator, the `for in` loop traverses the prototype
 chain when iterating over the properties of an object.
 
-> **Note:** The `for in` loop will **not** iterate over any properties that 
-> have their `enumerable` attribute set to `false`; for example, the `length` 
+> **Note:** The `for in` loop will **not** iterate over any properties that
+> have their `enumerable` attribute set to `false`; for example, the `length`
 > property of an array.
-    
+
     // Poisoning Object.prototype
     Object.prototype.bar = 1;
 
@@ -16,11 +16,20 @@ chain when iterating over the properties of an object.
     }
 
 Since it is not possible to change the behavior of the `for in` loop itself, it
-is necessary to filter out the unwanted properties inside the loop body , 
-this is done by using the [`hasOwnProperty`](#object.hasownproperty) method of 
-`Object.prototype`.
+is necessary to filter out the unwanted properties inside the loop body. In
+ECMAScript 3 and older, this is done using the [`hasOwnProperty`](#object.hasownproperty)
+method of `Object.prototype`.
+
+Since ECMAScript 5, `Object.defineProperty` can be used with
+`enumerable` set to `false` to add properties to objects (including `Object`)
+without these properties being enumerated. In this case it is reasonable
+to assume in application code that any enumerable properties have been added
+for a reason and to omit `hasOwnProperty`, since it makes code more verbose and less
+readable. In library code `hasOwnProperty` should still be used since
+assumptions cannot be made about which enumerable properties might reside
+on the prototype chain.
 
-> **Note:** Since the `for in` always traverses the complete prototype chain, it
+> **Note:** Since `for in` always traverses the complete prototype chain, it
 > will get slower with each additional layer of inheritance added to an object.
 
 ### Using `hasOwnProperty` for Filtering
@@ -32,20 +41,26 @@ this is done by using the [`hasOwnProperty`](#object.hasownproperty) method of
         }
     }
 
-This version is the only correct one to use. Due to the use of `hasOwnProperty` it
-will **only** print out `moo`. When `hasOwnProperty` is left out, the code is 
-prone to errors in cases where the native prototypes - e.g. `Object.prototype` - 
+This version is the only correct one to use with older versions of ECMAScript.
+Due to the use of `hasOwnProperty`, it will **only** print out `moo`.
+When `hasOwnProperty` is left out, the code is prone to errors in cases where
+the native prototypes - e.g. `Object.prototype` -
 have been extended.
 
-One widely used framework which does this is [Prototype][1]. When this 
-framework is included, `for in` loops that do not use `hasOwnProperty` are 
-guaranteed to break.
+In newer versions of ECMAScript, non-enumerable properties can be defined with
+`Object.defineProperty`, reducing the risk of iterating over properties without
+using `hasOwnProperty`. Nonetheless, care must be taken when using older
+libraries like [Prototype][1], which does not yet take advantage of new ECMAScript features.
+When this framework is included, `for in` loops that do not use
+`hasOwnProperty` are guaranteed to break.
 
 ### In Conclusion
 
-It is recommended to **always** use `hasOwnProperty`. Never should any 
-assumptions be made about the environment the code is running in, or whether the 
-native prototypes have been extended or not. 
+It is recommended to **always** use `hasOwnProperty` in ECMAScript 3 or lower, as well as
+in library code. Assumptions should never be made in these environments about whether
+the native prototypes have been extended or not. Since ECMAScript 5, `Object.defineProperty`
+makes it possible to define non-enumerable properties and to omit `hasOwnProperty` in
+application code.
 
 [1]: http://www.prototypejs.org/
 
diff --git a/doc/en/object/general.md b/doc/en/object/general.md
index cbad5f11..89589229 100644
--- a/doc/en/object/general.md
+++ b/doc/en/object/general.md
@@ -3,12 +3,12 @@
 Everything in JavaScript acts like an object, with the only two exceptions being 
 [`null`](#core.undefined) and [`undefined`](#core.undefined).
 
-    false.toString() // 'false'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
     
-    function Foo(){}
-    Foo.bar = 1;
-    Foo.bar; // 1
+    function sayHello(){}
+    sayHello.count = 1;
+    sayHello.count; // 1
 
 A common misconception is that number literals cannot be used as
 objects. That is because a flaw in JavaScript's parser tries to parse the *dot 
@@ -16,60 +16,60 @@ notation* on a number as a floating point literal.
 
     2.toString(); // raises SyntaxError
 
-There are a couple of workarounds which can be used in order make number 
-literals act as objects too.
+There are a couple of workarounds that can be used to make number literals act
+as objects too.
 
     2..toString(); // the second point is correctly recognized
-    2 .toString(); // note the space left to the dot
+    2 .toString(); // note the space left of the dot
     (2).toString(); // 2 is evaluated first
 
 ### Objects as a Data Type
 
-Objects in JavaScript can also be used as a [*Hashmap*][1], they mainly consist 
+Objects in JavaScript can also be used as [*Hashmaps*][1]; they mainly consist 
 of named properties mapping to values.
 
-Using a object literal - `{}` notation - it is possible to create a 
+Using an object literal - `{}` notation - it is possible to create a 
 plain object. This new object [inherits](#object.prototype) from `Object.prototype` and 
-has no [own properties](#object.hasownproperty) defined on it.
+does not have [own properties](#object.hasownproperty) defined.
 
-    var foo = {}; // a new empty object
+    var names = {}; // a new empty object
 
-    // a new object with a property called 'test' with value 12
-    var bar = {test: 12}; 
+    // a new object with a 'name' property with value 'Rob'
+    var rob = {name: 'Rob'}; 
 
 ### Accessing Properties
 
 The properties of an object can be accessed in two ways, via either the dot
-notation, or the square bracket notation.
+notation or the square bracket notation.
     
-    var foo = {name: 'Kitten'}
-    foo.name; // kitten
-    foo['name']; // kitten
+    var pet = {name: 'kitten'}
+    pet.name; // kitten
+    pet['name']; // kitten
     
     var get = 'name';
-    foo[get]; // kitten
+    pet[get]; // kitten
     
-    foo.1234; // SyntaxError
-    foo['1234']; // works
+    pet.1234; // SyntaxError
+    pet['1234']; // works
 
-Both notations are identical in their workings, with the only difference being that
-the square bracket notation allows for dynamic setting of properties, as well as
+The notations work almost identically, with the only difference being that the
+square bracket notation allows for dynamic setting of properties and
 the use of property names that would otherwise lead to a syntax error.
 
 ### Deleting Properties
 
-The only way to actually remove a property from an object is to use the `delete`
-operator; setting the property to `undefined` or `null` only remove the
+The only way to remove a property from an object is to use the `delete`
+operator; setting the property to `undefined` or `null` only removes the
 *value* associated with the property, but not the *key*.
 
     var obj = {
-        bar: 1,
-        foo: 2,
-        baz: 3
+        a: 1,
+        b: 2,
+        c: 3
     };
-    obj.bar = undefined;
-    obj.foo = null;
-    delete obj.baz;
+    obj.a = undefined;
+    obj.b = null;
+    delete obj.c;
 
     for(var i in obj) {
         if (obj.hasOwnProperty(i)) {
@@ -77,14 +77,14 @@ operator; setting the property to `undefined` or `null` only remove the
         }
     }
 
-The above outputs both `bar undefined` and `foo null` - only `baz` was
+The above outputs both `a undefined` and `b null` - only `c` was
 removed and is therefore missing from the output.
 
 ### Notation of Keys
 
     var test = {
-        'case': 'I am a keyword so I must be notated as a string',
-        delete: 'I am a keyword too so me' // raises SyntaxError
+        'case': 'I am a keyword, so I must be notated as a string',
+        delete: 'I am a keyword, so me too' // raises SyntaxError
     };
 
 Object properties can be both notated as plain characters and as strings. Due to
diff --git a/doc/en/object/hasownproperty.md b/doc/en/object/hasownproperty.md
index 319a8801..10423b00 100644
--- a/doc/en/object/hasownproperty.md
+++ b/doc/en/object/hasownproperty.md
@@ -1,36 +1,36 @@
 ## `hasOwnProperty`
 
-In order to check whether a object has a property defined on *itself* and **not** 
-somewhere on its [prototype chain](#object.prototype), it is necessary to use the 
+To check whether an object has a property defined on *itself* and not somewhere
+on its [prototype chain](#object.prototype), it is necessary to use the
 `hasOwnProperty` method which all objects inherit from `Object.prototype`.
 
 > **Note:** It is **not** enough to check whether a property is `undefined`. The
-> property might very well exist, but its value just happens to be set to 
+> property might very well exist, but its value just happens to be set to
 > `undefined`.
 
-`hasOwnProperty` is the only thing in JavaScript which deals with properties and 
+`hasOwnProperty` is the only thing in JavaScript which deals with properties and
 does **not** traverse the prototype chain.
 
     // Poisoning Object.prototype
-    Object.prototype.bar = 1; 
+    Object.prototype.bar = 1;
     var foo = {goo: undefined};
-    
+
     foo.bar; // 1
     'bar' in foo; // true
 
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-Only `hasOwnProperty` will give the correct and expected result, this is 
-essential when iterating over the properties of any object. There is **no** other 
-way to exclude properties that are not defined on the object *itself*, but 
-somewhere on its prototype chain.  
+Only `hasOwnProperty` will give the correct and expected result. See the section
+on [`for in` loops](#object.forinloop) for more details on when to use
+`hasOwnProperty` when iterating over object
+properties.
 
 ### `hasOwnProperty` as a Property
 
-JavaScript does **not** protect the property name `hasOwnProperty`; thus, if the
+JavaScript does not protect the property name `hasOwnProperty`; thus, if the
 possibility exists that an object might have a property with this name, it is
-necessary to use an *external* `hasOwnProperty` in order to get correct results.
+necessary to use an *external* `hasOwnProperty` to get correct results.
 
     var foo = {
         hasOwnProperty: function() {
@@ -44,10 +44,15 @@ necessary to use an *external* `hasOwnProperty` in order to get correct results.
     // Use another Object's hasOwnProperty and call it with 'this' set to foo
     ({}).hasOwnProperty.call(foo, 'bar'); // true
 
+    // It's also possible to use hasOwnProperty from the Object
+    // prototype for this purpose
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+
+
 ### In Conclusion
 
-When checking for the existence of a property on a object, `hasOwnProperty` is 
-the **only** method of doing so. It is also recommended to make `hasOwnProperty`
-part of **every** [`for in` loop](#object.forinloop), this will avoid errors from 
-extended native [prototypes](#object.prototype).
+Using `hasOwnProperty` is the **only** reliable method to check for the
+existence of a property on an object. It is recommended that `hasOwnProperty`
+be used in many cases when iterating over object properties as described
+in the section on [`for in` loops](#object.forinloop).
 
diff --git a/doc/en/object/prototype.md b/doc/en/object/prototype.md
index f780eba2..f63abaa9 100644
--- a/doc/en/object/prototype.md
+++ b/doc/en/object/prototype.md
@@ -1,23 +1,23 @@
 ## The Prototype
 
-JavaScript does not feature a classical inheritance model, instead it uses a 
-*prototypal* one. 
+JavaScript does not feature a classical inheritance model; instead, it uses a
+*prototypal* one.
 
-While this is often considered to be one of JavaScript's weaknesses, the 
-prototypal inheritance model is in fact more powerful than the classic model. 
-It is for example fairly trivial to build a classic model on top of it, while the
-other way around is a far more difficult task.
+While this is often considered to be one of JavaScript's weaknesses, the
+prototypal inheritance model is in fact more powerful than the classic model.
+It is, for example, fairly trivial to build a classic model on top of a
+prototypal model, while the other way around is a far more difficult task.
 
-Due to the fact that JavaScript is basically the only widely used language that
-features prototypal inheritance, it takes some time to adjust to the 
-differences between the two models. 
+JavaScript is the only widely used language that features prototypal
+inheritance, so it can take time to adjust to the differences between the two
+models.
 
-The first major difference is that inheritance in JavaScript is done by using so
-called *prototype chains*.
+The first major difference is that inheritance in JavaScript uses *prototype
+chains*.
 
 > **Note:** Simply using `Bar.prototype = Foo.prototype` will result in both objects
-> sharing the **same** prototype. Therefore, changes to either object's prototype 
-> will affect the prototype of the other as well, which in most cases is not the 
+> sharing the **same** prototype. Therefore, changes to either object's prototype
+> will affect the prototype of the other as well, which in most cases is not the
 > desired effect.
 
     function Foo() {
@@ -36,26 +36,26 @@ called *prototype chains*.
     // Make sure to list Bar as the actual constructor
     Bar.prototype.constructor = Bar;
 
-    var test = new Bar() // create a new bar instance
+    var test = new Bar(); // create a new bar instance
 
     // The resulting prototype chain
     test [instance of Bar]
-        Bar.prototype [instance of Foo] 
-            { foo: 'Hello World' }
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
             Foo.prototype
                 { method: ... }
                 Object.prototype
                     { toString: ... /* etc. */ }
 
-In the above, the object `test` will inherit from both `Bar.prototype` and
-`Foo.prototype`; hence, it will have access to the function `method` that was 
+In the code above, the object `test` will inherit from both `Bar.prototype` and
+`Foo.prototype`; hence, it will have access to the function `method` that was
 defined on `Foo`. It will also have access to the property `value` of the
 **one** `Foo` instance that is its prototype. It is important to note that `new
-Bar()` does **not** create a new `Foo` instance, but reuses the one assigned to 
+Bar()` does **not** create a new `Foo` instance, but reuses the one assigned to
 its prototype; thus, all `Bar` instances will share the **same** `value` property.
 
-> **Note:** Do **not** use `Bar.prototype = Foo`, since it will not point to 
-> the prototype of `Foo` but rather to the function object `Foo`. So the 
+> **Note:** Do **not** use `Bar.prototype = Foo`, since it will not point to
+> the prototype of `Foo` but rather to the function object `Foo`. So the
 > prototype chain will go over `Function.prototype` and not `Foo.prototype`;
 > therefore, `method` will not be on the prototype chain.
 
@@ -64,14 +64,14 @@ its prototype; thus, all `Bar` instances will share the **same** `value` propert
 When accessing the properties of an object, JavaScript will traverse the
 prototype chain **upwards** until it finds a property with the requested name.
 
-When it reaches the top of the chain - namely `Object.prototype` - and still
+If it reaches the top of the chain - namely `Object.prototype` - and still
 hasn't found the specified property, it will return the value
 [undefined](#core.undefined) instead.
 
 ### The Prototype Property
 
 While the prototype property is used by the language to build the prototype
-chains, it is still possible to assign **any** given value to it. Although 
+chains, it is still possible to assign **any** given value to it. However,
 primitives will simply get ignored when assigned as a prototype.
 
     function Foo() {}
@@ -82,33 +82,35 @@ creation of prototype chains.
 
 ### Performance
 
-The lookup time for properties that are high up on the prototype chain can have a
-negative impact on performance critical sections of code. Additionally, trying to 
-access non-existent properties will always traverse the full prototype chain. 
+The lookup time for properties that are high up on the prototype chain can have
+a negative impact on performance, and this may be significant in code where
+performance is critical. Additionally, trying to access non-existent properties
+will always traverse the full prototype chain.
 
-Also, when [iterating](#object.forinloop) over the properties of an object 
-**every** property that is on the prototype chain will get enumerated.
+Also, when [iterating](#object.forinloop) over the properties of an object
+**every** property that is on the prototype chain will be enumerated.
 
 ### Extension of Native Prototypes
 
 One mis-feature that is often used is to extend `Object.prototype` or one of the
 other built in prototypes.
 
-This technique is called [monkey patching][1] and breaks *encapsulation*. While 
-used by widely spread frameworks such as [Prototype][2], there is still no good 
+This technique is called [monkey patching][1] and breaks *encapsulation*. While
+used by popular frameworks such as [Prototype][2], there is still no good
 reason for cluttering built-in types with additional *non-standard* functionality.
 
-The **only** good reason for extending a built-in prototype is to backport 
-the features of newer JavaScript engines; for example, 
+The **only** good reason for extending a built-in prototype is to backport
+the features of newer JavaScript engines; for example,
 [`Array.forEach`][3].
 
 ### In Conclusion
 
-It is a **must** to understand the prototypal inheritance model completely 
-before writing complex code which makes use of it. Also, watch the length of 
-the prototype chains and break them up if necessary to avoid possible 
-performance issues. Further, the native prototypes should **never** be extended 
-unless it is for the sake of compatibility with newer JavaScript features.
+It is **essential** to understand the prototypal inheritance model before
+writing complex code that makes use of it. Also, be aware of the length of the
+prototype chains in your code and break them up if necessary to avoid possible
+performance problems. Further, the native prototypes should **never** be
+extended unless it is for the sake of compatibility with newer JavaScript
+features.
 
 [1]: http://en.wikipedia.org/wiki/Monkey_patch
 [2]: http://prototypejs.org/
diff --git a/doc/en/other/timeouts.md b/doc/en/other/timeouts.md
index d196a3b7..e27ccacf 100644
--- a/doc/en/other/timeouts.md
+++ b/doc/en/other/timeouts.md
@@ -1,26 +1,29 @@
 ### `setTimeout` and `setInterval`
 
 Since JavaScript is asynchronous, it is possible to schedule the execution of a 
-function by using the `setTimeout` and `setInterval` functions.
+function using the `setTimeout` and `setInterval` functions.
 
-> **Note:** Timeouts are **not** part of the ECMAScript Standard. They are
-> implemented as part of the [DOM][1].
+> **Note:** Timeouts are **not** part of the ECMAScript standard. They were
+> implemented in [BOM, or DOM Level 0][1], which are never defined nor
+> documented formally. No recommended specification has been published so far,
+> however, they are currently being standardized by [HTML5][2]. Due to this 
+> nature, the implementation may vary from browsers and engines.
 
     function foo() {}
     var id = setTimeout(foo, 1000); // returns a Number > 0
 
-When `setTimeout` gets called, it will return the ID of the timeout and schedule
-`foo` to run in **approximately** one thousand milliseconds in the future. 
-`foo` will then get executed exactly **once**.
+When `setTimeout` is called, it returns the ID of the timeout and schedule
+`foo` to run **approximately** one thousand milliseconds in the future. 
+`foo` will then be executed **once**.
 
-Depending on the timer resolution of the JavaScript engine that is running the 
-code, as well as the fact that JavaScript is single threaded and other code that 
-gets executed might block the thread, it is by **no means** a safe bet that one 
-will get the exact delay that was specified in the `setTimeout` call.
+Depending on the timer resolution of the JavaScript engine running the code, as
+well as the fact that JavaScript is single threaded and other code that gets
+executed might block the thread, it is by **no means** a safe bet that one will
+get the exact delay specified in the `setTimeout` call.
 
 The function that was passed as the first parameter will get called by the
-*global object*, that means, that [`this`](#function.this) inside the called function 
-refers to that very object.
+*global object*, which means that [`this`](#function.this) inside the called function 
+refers to the global object.
 
     function Foo() {
         this.value = 42;
@@ -33,8 +36,8 @@ refers to that very object.
     new Foo();
 
 
-> **Note:** As `setTimeout` takes a **function object** as its first parameter, an
-> often made mistake is to use `setTimeout(foo(), 1000)`, which will use the 
+> **Note:** As `setTimeout` takes a **function object** as its first parameter, a
+> common mistake is to use `setTimeout(foo(), 1000)`, which will use the 
 > **return value** of the call `foo` and **not** `foo`. This is, most of the time, 
 > a silent error, since when the function returns `undefined` `setTimeout` will 
 > **not** raise any error.
@@ -42,7 +45,7 @@ refers to that very object.
 ### Stacking Calls with `setInterval`
 
 While `setTimeout` only runs the function once, `setInterval` - as the name 
-suggests - will execute the function **every** `X` milliseconds. But its use is 
+suggests - will execute the function **every** `X` milliseconds, but its use is 
 discouraged. 
 
 When code that is being executed blocks the timeout call, `setInterval` will 
@@ -52,39 +55,39 @@ intervals, result in function calls stacking up.
     function foo(){
         // something that blocks for 1 second
     }
-    setInterval(foo, 100);
+    setInterval(foo, 1000);
 
-In the above code `foo` will get called once and will then block for one second.
+In the above code, `foo` will get called once and will then block for one second.
 
-While `foo` blocks the code `setInterval` will still schedule further calls to
+While `foo` blocks the code, `setInterval` will still schedule further calls to
 it. Now, when `foo` has finished, there will already be **ten** further calls to
 it waiting for execution.
 
 ### Dealing with Possible Blocking Code
 
-The easiest as well as most controllable solution, is to use `setTimeout` within
+The easiest solution, as well as most controllable solution, is to use `setTimeout` within
 the function itself.
 
     function foo(){
         // something that blocks for 1 second
-        setTimeout(foo, 100);
+        setTimeout(foo, 1000);
     }
     foo();
 
 Not only does this encapsulate the `setTimeout` call, but it also prevents the
-stacking of calls and it gives additional control.`foo` itself can now decide 
+stacking of calls and gives additional control. `foo` itself can now decide 
 whether it wants to run again or not.
 
 ### Manually Clearing Timeouts
 
 Clearing timeouts and intervals works by passing the respective ID to
-`clearTimeout` or `clearInterval`, depending which `set` function was used in
-the first place.
+`clearTimeout` or `clearInterval`, depending on which `set` function was used
+in the first place.
 
     var id = setTimeout(foo, 1000);
     clearTimeout(id);
 
-### Clearing all timeouts
+### Clearing All Timeouts
 
 As there is no built-in method for clearing all timeouts and/or intervals, 
 it is necessary to use brute force in order to achieve this functionality.
@@ -94,18 +97,29 @@ it is necessary to use brute force in order to achieve this functionality.
         clearTimeout(i);
     }
 
-There might still be timeouts that are unaffected by this arbitrary number;
-therefore, is is instead recommended to keep track of all the timeout IDs, so
-they can be cleared specifically.
+But there might still be timeouts that are unaffected by this arbitrary number.
+Another way of doing this is to consider that the ID given to a timeout is
+incremented by one every time you call `setTimeout`.
 
-### Hidden use of `eval`
+    // clear "all" timeouts
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+Even though this works on all major browsers today, it isn't specified that
+the IDs should be ordered that way and it may change. Therefore, it is instead
+recommended to keep track of all the timeout IDs, so they can be cleared
+specifically.
+
+### Hidden Use of `eval`
 
 `setTimeout` and `setInterval` can also take a string as their first parameter.
-This feature should **never** be used, since it internally makes use of `eval`.
+This feature should **never** be used because it internally makes use of `eval`.
 
-> **Note:** Since the timeout functions are **not** specified by the ECMAScript
-> standard, the exact workings when a string is passed to them might differ in
-> various JavaScript implementations. For example, Microsoft's JScript makes use of
+> **Note:** The exact workings when a string is passed to them might differ in
+> various JavaScript implementations. For example, Microsoft's JScript uses
 > the `Function` constructor in place of `eval`.
 
     function foo() {
@@ -121,35 +135,38 @@ This feature should **never** be used, since it internally makes use of `eval`.
     bar();
 
 Since `eval` is not getting called [directly](#core.eval) in this case, the string 
-passed to `setTimeout` will get executed in the *global scope*; thus, it will 
+passed to `setTimeout` will be executed in the *global scope*; thus, it will 
 not use the local variable `foo` from the scope of `bar`.
 
-It is further recommended to **not** use a string for passing arguments to the
+It is further recommended to **not** use a string to pass arguments to the
 function that will get called by either of the timeout functions. 
 
     function foo(a, b, c) {}
     
     // NEVER use this
-    setTimeout('foo(1,2, 3)', 1000)
+    setTimeout('foo(1, 2, 3)', 1000)
 
     // Instead use an anonymous function
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
-> **Note:** While it is also possible to use the syntax 
-> `setTimeout(foo, 1000, a, b, c)`, it is not recommended, as its use may lead
-> to subtle errors when used with [methods](#function.this). 
+> **Note:** While it is also possible to use `setTimeout(foo, 1000, 1, 2, 3)`
+> syntax, it is not recommended, as its use may lead
+> to subtle errors when used with [methods](#function.this).
+> Furthermore, the syntax might not work in some JavaScript implementations.
+> For example, Microsoft's Internet Explorer [does **not** pass the arguments directly to the callback](3).
 
 ### In Conclusion
 
-**Never** should a string be used as the parameter of `setTimeout` or 
+A string should **never** be used as the parameter of `setTimeout` or 
 `setInterval`. It is a clear sign of **really** bad code, when arguments need 
 to be supplied to the function that gets called. An *anonymous function* should
 be passed that then takes care of the actual call.
 
-Further, the use of `setInterval` should be avoided since its scheduler is not
+Furthermore, the use of `setInterval` should be avoided because its scheduler is not
 blocked by executing JavaScript.
 
-[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
-
+[1]: http://www.nczonline.net/blog/2009/09/29/web-definitions-dom-ajax-and-more/ "Web definitions: DOM, Ajax, and more"
+[2]: http://www.w3.org/TR/2014/WD-html5-20140617/webappapis.html#timers "6 Web application APIs - HTML5"
+[3]: http://msdn.microsoft.com/en-us/library/ie/ms536753(v=vs.85).aspx "setTimeout method (Internet Explorer)"
diff --git a/doc/en/types/casting.md b/doc/en/types/casting.md
index 15d84e74..f12aa811 100644
--- a/doc/en/types/casting.md
+++ b/doc/en/types/casting.md
@@ -4,8 +4,9 @@ JavaScript is a *weakly typed* language, so it will apply *type coercion*
 **wherever** possible.
 
     // These are true
-    new Number(10) == 10; // Number.toString() is converted
-                          // back to a number
+    new Number(10) == 10; // Number object is converted
+                          // to a number primitive via implicit call of
+                          // Number.prototype.valueOf method
 
     10 == '10';           // Strings gets converted to Number
     10 == '+10 ';         // More string madness
@@ -21,7 +22,7 @@ JavaScript is a *weakly typed* language, so it will apply *type coercion*
 > (Base 8). Octal support for these has been **removed** in ECMAScript 5 strict 
 > mode.
 
-In order to avoid the above, use of the [strict equal operator](#types.equality) 
+To avoid the issues above, use of the [strict equal operator](#types.equality) 
 is **highly** recommended. Although this avoids a lot of common pitfalls, there 
 are still many further issues that arise from JavaScript's weak typing system.
 
@@ -38,8 +39,8 @@ Using a built-in type like `Number` as a constructor will create a new `Number`
 object, but leaving out the `new` keyword will make the `Number` function behave
 like a converter.
 
-In addition, having literals or non-object values in there will result in even
-more type coercion.
+In addition, passing literals or non-object values will result in even more
+type coercion.
 
 The best option is to cast to one of the three possible types **explicitly**.
 
@@ -47,17 +48,17 @@ The best option is to cast to one of the three possible types **explicitly**.
 
     '' + 10 === '10'; // true
 
-By prepending a empty string a value can easily be casted to a string.
+By prepending an empty string, a value can easily be cast to a string.
 
 ### Casting to a Number
 
     +'10' === 10; // true
 
-Using the **unary** plus operator it is possible to cast to a number.
+Using the **unary** plus operator, it is possible to cast to a number.
 
 ### Casting to a Boolean
 
-By using the **not** operator twice, a value can be converted a boolean.
+By using the **not** operator twice, a value can be converted to a boolean.
 
     !!'foo';   // true
     !!'';      // false
diff --git a/doc/en/types/equality.md b/doc/en/types/equality.md
index a578b19c..e47752a4 100644
--- a/doc/en/types/equality.md
+++ b/doc/en/types/equality.md
@@ -19,19 +19,19 @@ JavaScript features *weak typing*. This means that the equality operator
     null         ==   undefined     // true
     " \t\r\n"    ==   0             // true
 
-The above table shows the results of the type coercion and it is the main reason 
-why the use of `==` is widely regarded as bad practice, it introduces hard to 
-track down bugs due to its complicated conversion rules.
+The above table shows the results of the type coercion, and it is the main reason 
+why the use of `==` is widely regarded as bad practice. It introduces
+hard-to-track-down bugs due to its complicated conversion rules.
 
-Additionally there is also a performance impact when type coercion is in play;
+Additionally, there is also a performance impact when type coercion is in play;
 for example, a string has to be converted to a number before it can be compared
 to another number.
 
 ### The Strict Equality Operator
 
-The strict equality operator consists of **three** equal signs: `===`
+The strict equality operator consists of **three** equal signs: `===`.
 
-It works exactly like the normal equality operator, except that strict equality 
+It works like the normal equality operator, except that strict equality 
 operator does **not** perform type coercion between its operands.
 
     ""           ===   "0"           // false
@@ -50,8 +50,8 @@ the operands are of different types.
 
 ### Comparing Objects
 
-While both `==` and `===` are stated as **equality** operators, they behave 
-different when at least one of their operands happens to be an `Object`.
+While both `==` and `===` are called **equality** operators, they behave 
+differently when at least one of their operands is an `Object`.
 
     {} === {};                   // false
     new String('foo') === 'foo'; // false
@@ -59,7 +59,7 @@ different when at least one of their operands happens to be an `Object`.
     var foo = {};
     foo === foo;                 // true
 
-Here both operators compare for **identity** and **not** equality; that is, they
+Here, both operators compare for **identity** and **not** equality; that is, they
 will compare for the same **instance** of the object, much like `is` in Python 
 and pointer comparison in C.
 
diff --git a/doc/en/types/instanceof.md b/doc/en/types/instanceof.md
index 8711331a..2fe41064 100644
--- a/doc/en/types/instanceof.md
+++ b/doc/en/types/instanceof.md
@@ -13,8 +13,8 @@ nearly as useless as the [typeof operator](#types.typeof).
     new Bar() instanceof Bar; // true
     new Bar() instanceof Foo; // true
 
-    // This just sets Bar.prototype to the function object Foo
-    // But not to an actual instance of Foo
+    // This just sets Bar.prototype to the function object Foo,
+    // but not to an actual instance of Foo
     Bar.prototype = Foo;
     new Bar() instanceof Foo; // false
 
@@ -26,13 +26,13 @@ nearly as useless as the [typeof operator](#types.typeof).
     'foo' instanceof String; // false
     'foo' instanceof Object; // false
 
-One important thing to note here is, that `instanceof` does not work on objects 
-that origin from different JavaScript contexts (e.g. different documents
+One important thing to note here is that `instanceof` does not work on objects 
+that originate from different JavaScript contexts (e.g. different documents
 in a web browser), since their constructors will not be the exact same object.
 
 ### In Conclusion
 
 The `instanceof` operator should **only** be used when dealing with custom made 
-objects that origin from the same JavaScript context. Just like the
+objects that originate from the same JavaScript context. Just like the
 [`typeof`](#types.typeof) operator, every other use of it should be **avoided**.
 
diff --git a/doc/en/types/typeof.md b/doc/en/types/typeof.md
index e4b28d7f..9eb3fbdc 100644
--- a/doc/en/types/typeof.md
+++ b/doc/en/types/typeof.md
@@ -2,16 +2,16 @@
 
 The `typeof` operator (together with 
 [`instanceof`](#types.instanceof)) is probably the biggest 
-design flaw of JavaScript, as it is near of being **completely broken**.
+design flaw of JavaScript, as it is almost **completely broken**.
 
-Although `instanceof` still has its limited uses, `typeof` really has only one
+Although `instanceof` still has limited uses, `typeof` really has only one
 practical use case, which does **not** happen to be checking the type of an 
 object. 
 
-> **Note:** While `typeof` can also be called with a function like syntax
-> i.e. `typeof(obj)`, this is not a function call. The two parenthesis will
-> behave like normal and the return value will be used as the operand of the
-> `typeof` operator. There is **no** `typeof` function.
+> **Note:** While `typeof` can also be called with a function like syntax, i.e.
+> `typeof(obj)`, this is not a function call. The parentheses behave as normal
+> and the return value will be used as the operand of the `typeof` operator.
+> There is **no** `typeof` function.
 
 ### The JavaScript Type Table
 
@@ -33,7 +33,7 @@ object.
     {}                  Object     object
     new Object()        Object     object
 
-In the above table *Type* refers to the value, that the `typeof` operator returns.
+In the above table, *Type* refers to the value that the `typeof` operator returns.
 As can be clearly seen, this value is anything but consistent.
 
 The *Class* refers to the value of the internal `[[Class]]` property of an object.
@@ -42,13 +42,11 @@ The *Class* refers to the value of the internal `[[Class]]` property of an objec
 > following strings. `Arguments`, `Array`, `Boolean`, `Date`, `Error`, 
 > `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
 
-In order to retrieve the value of `[[Class]]` one has to make use of the
-`toString` method of `Object.prototype`.
-
 ### The Class of an Object
 
-The specification gives exactly one way of accessing the `[[Class]]` value,
-with the use of `Object.prototype.toString`. 
+The only way to determine an object's `[[Class]]` value is using `Object.prototype.toString`. It
+returns a string in the following format: `'[object ' + valueOfClass + ']'`, e.g `[object String]` or
+`[object Array]`:
 
     function is(type, obj) {
         var clas = Object.prototype.toString.call(obj).slice(8, -1);
@@ -77,11 +75,10 @@ referencing it would result in a `ReferenceError`. This is the only thing
 ### In Conclusion
 
 In order to check the type of an object, it is highly recommended to use 
-`Object.prototype.toString`; as this is the only reliable way of doing so. 
+`Object.prototype.toString` because this is the only reliable way of doing so. 
 As shown in the above type table, some return values of `typeof` are not defined 
-in the specification; thus, they can differ across various implementations.
+in the specification; thus, they can differ between implementations.
 
-Unless checking whether a variable is defined, `typeof` should be avoided at
-**all costs**.
+Unless checking whether a variable is defined, `typeof` should be avoided.
 
 
diff --git a/doc/es/array/constructor.md b/doc/es/array/constructor.md
new file mode 100644
index 00000000..46c5c16f
--- /dev/null
+++ b/doc/es/array/constructor.md
@@ -0,0 +1,35 @@
+## El constructor `Array`
+
+Desde el constructor `Array` es ambiguo en la forma en que ocupa sus párametros,
+es recomendable siempre el uso de arrays literales - la notación `[]` - 
+cuando se crean nuevos arrays.
+
+    [1, 2, 3]; // Resultado: [1, 2, 3]
+    new Array(1, 2, 3); // Resultado: [1, 2, 3]
+
+    [3]; // Resultado: [3]
+    new Array(3); // Resultado: []
+    new Array('3') // Resultado: ['3']
+
+En casos cuando sólo hay un argumento pasado al constructor del `Array`,
+y que el argumento es un `Número`, el contructor devolverá un array *disperso* 
+con la propiedad `length` establecida al valor del argumento. Esto debe señalarse
+que la propiedad `length` **sólo** del nuevo array se establecerá de esa manera, 
+los índices reales de la matriz no se iniciará. 
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // falso, el índice no se ha establecido
+
+El comportamiento de poder establecer la longitud de un array inicial sólo es útil
+en algunos casos array, como la repetición de una cadena, en la que se evita el uso 
+del código de `bucle for`.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### En conclusión
+
+El uso de un constructor `Array` debe ser devuelto como sea posible. 
+Los literales son definitivamente preferidos. Estos son más cortos y tienen una
+sintaxis más limpia; por lo tanto, también se incrementa la legibilidad del código.
+
diff --git a/doc/es/array/general.md b/doc/es/array/general.md
new file mode 100644
index 00000000..3de582bb
--- /dev/null
+++ b/doc/es/array/general.md
@@ -0,0 +1,58 @@
+## Iteración de un Array y sus propiedades
+
+A pesar que los arrays en JavaScript son objetos, no existe un buena razón para
+usarlo en un [`bucle for`](#object.forinloop) para una interación de este. De 
+hecho, hay un número de buenas razones **contra** el uso de `for in` en arrays.
+
+> **Nota:** Los arrays de JavaScript **no** son *arrays asociativos*. JavaScript sólo 
+> tiene [objetos](#object.general) para el mapeo de keys a valores. Y mientras
+> que los arrays asociativos **preservan** el orden, los objetos **no**.
+
+Dado que el bucle `for in` enumera todas las propiedades que están en una cadena
+de prototipo y la única manera para excluir estas propiedades es el uso de
+[`hasOwnProperty`](#object.hasownproperty), ya que es **veinte veces** más
+lento que un bucle `for` normal.
+
+### Iteración
+
+Con el fin de obtener el mejor rendimiento cuando se repite la interación de arrays, 
+es lo mejor hacer uso del clásico bucle `for`.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Hay una captura adicional en el ejemplo anterior, que es el almacenamiento de la
+caché de longitud del array vía `l = list.length`.
+
+Aunque la propiedad `length` es definida en el mismo array, todavía posee una sobrecarga
+para realizar la búsqueda en cada interación del bucle. Y mientras que los últimos 
+motores de JavaScript **pueden** aplicar optimizaciones en este caso, no hay manera 
+de saber si el ćodigo se ejecutará en uno de estos nuevos motores nuevos o no.
+
+De hecho, dejando de lado el almacenamiento en caché puede resultar que el bucle
+inicie sólo la **mitad de rápido** que con la longitud de la caché.
+
+### La propiedad `length`
+
+Mientras que *getter* de la propiedad `length` simplemente retorne el número de
+elementos son contenidos en un array, el *setter* puede ser usado para 
+**truncar** el array.
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo; // [1, 2, 3]
+
+La asignación de un menor número de longitud trunca al array, pero incrementando la
+longitud no tiene ningún efecto sobre el array.
+
+### En conclusión
+
+Para obtener el mejor rendimiento es recomendable siempre usar el bucle `for`
+y alamacenar en caché la propiedad `length`. El uso del bucle `for in` en un array 
+es señal de un código mal escrito propenso a errores y un mal desempeño. 
+
diff --git a/doc/es/core/delete.md b/doc/es/core/delete.md
new file mode 100644
index 00000000..1d0d198a
--- /dev/null
+++ b/doc/es/core/delete.md
@@ -0,0 +1,87 @@
+## The `delete` Operator
+
+In short, it's *impossible* to delete global variables, functions and some other
+stuff in JavaScript which have a `DontDelete` attribute set.
+
+### Global code and Function code
+
+When a variable or a function is defined in a global 
+or a [function scope](#function.scopes) it is a property of either 
+Activation object or Global object. Such properties have a set of attributes, 
+one of these is `DontDelete`. Variable and function declarations in global 
+and function code always create properties with `DontDelete`, therefore 
+cannot be deleted.
+
+    // global variable:
+    var a = 1; // DontDelete is set
+    delete a; // false
+    a; // 1
+
+    // normal function:
+    function f() {} // DontDelete is set
+    delete f; // false
+    typeof f; // "function"
+
+    // reassigning doesn't help:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Explicit properties
+
+There are things which can be deleted normally: these are explicitly set 
+properties.
+
+    // explicitly set property:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+In the example above `obj.x` and `obj.y` can be deleted because they have no 
+`DontDelete` atribute. That's why an example below works too.
+
+    // this works fine, except for IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - just a global var
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Here we use a trick to delete `a`. [`this`](#function.this) here refers 
+to the Global object and we explicitly declare variable `a` as it's property 
+which allows us to delete it.
+
+IE (at least 6-8) has some bugs, so code above doesn't work.
+
+### Function arguments and built-ins
+
+Functions' normal arguments, [`arguments` object](#function.arguments) 
+and built-in properties also have `DontDelete` set.
+
+    // function arguments and properties:
+    (function (x) {
+    
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Host objects
+    
+Behaviour of `delete` operator can be unpredictable for hosted objects. Due to 
+specification, host objects are allowed to implement any kind of behavior. 
+
+### In conclusion
+
+`delete` operator often has an unexpected behaviour and can be safely used 
+only for dealing with explicitly set properties on normal objects.
diff --git a/doc/es/core/eval.md b/doc/es/core/eval.md
new file mode 100644
index 00000000..208bd280
--- /dev/null
+++ b/doc/es/core/eval.md
@@ -0,0 +1,47 @@
+## ¿Por qué no usar `eval`?
+
+La función `eval` ejecuta un string como código JavaScript en el ámbito local.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+
+Pero `eval` sólo ejecutará en ámbito local cuando es llamado **directamente** *y* 
+el nombre de la función llamada es `eval`.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+El uso de `eval` debe evitarse **a toda costa**. El 99.9% de su "uso" puede 
+lograrse **sin** su uso..
+    
+### `eval` disfrazado
+
+Las funciones de [tiempo de espera](#other.timeouts) `setTimeout` y `setInterval` pueden
+tomar un string como primer argumento. En este caso, el string **siempre** se ejecutará en
+el ámbito global ya que `eval` no ha sido llamado directamente.
+
+### Problemas de seguridad
+
+`eval` es también un problema de seguridad ya que ejecuta **cualquier** código enviado,
+y **nunca** debe usarse con strings que no se conozcan o tengan un origen no confiable.
+
+### En conclusión
+
+`eval` nunca debe ser usado, cualquier código que haga uso del mismo debe ser cuestionado
+en su funcionamiento, rendimiento y seguridad. En caso de que se necesite trabajar con
+`eval`, el diseño ha de ser cuestionado y **no** debe  utilizarse en primer lugar, se
+debe usar un *mejor diseño*, que no requiera el uso de `eval`. 
+
diff --git a/doc/es/core/semicolon.md b/doc/es/core/semicolon.md
new file mode 100644
index 00000000..f03f7d82
--- /dev/null
+++ b/doc/es/core/semicolon.md
@@ -0,0 +1,114 @@
+## Automatic Semicolon Insertion
+
+Although JavaScript has C style syntax, it does **not** enforce the use of
+semicolons in the source code, so it is possible to omit them.
+
+JavaScript is not a semicolon-less language. In fact, it needs the 
+semicolons in order to understand the source code. Therefore, the JavaScript
+parser **automatically** inserts them whenever it encounters a parse
+error due to a missing semicolon.
+
+    var foo = function() {
+    } // parse error, semicolon expected
+    test()
+
+Insertion happens, and the parser tries again.
+
+    var foo = function() {
+    }; // no error, parser continues
+    test()
+
+The automatic insertion of semicolon is considered to be one of **biggest**
+design flaws in the language because it *can* change the behavior of code.
+
+### How it Works
+
+The code below has no semicolons in it, so it is up to the parser to decide where
+to insert them.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Below is the result of the parser's "guessing" game.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Not inserted, lines got merged
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- inserted
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- inserted
+
+            return; // <- inserted, breaks the return statement
+            { // treated as a block
+
+                // a label and a single expression statement
+                foo: function() {} 
+            }; // <- inserted
+        }
+        window.test = test; // <- inserted
+
+    // The lines got merged again
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- inserted
+
+    })(window); //<- inserted
+
+> **Note:** The JavaScript parser does not "correctly" handle return statements 
+> which are followed by a new line, while this is not neccessarily the fault of 
+> the automatic semicolon insertion, it can still be an unwanted side-effect. 
+
+The parser drastically changed the behavior of the code above. In certain cases,
+it does the **wrong thing**.
+
+### Leading Parenthesis
+
+In case of a leading parenthesis, the parser will **not** insert a semicolon.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+This code gets transformed into one line.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+Chances are **very** high that `log` does **not** return a function; therefore,
+the above will yield a `TypeError` stating that `undefined is not a function`.
+
+### In Conclusion
+
+It is highly recommended to **never** omit semicolons; it is also advocated to 
+keep braces on the same line with their corresponding statements and to never omit 
+them for one single-line `if` / `else` statements. Both of these measures will 
+not only improve the consistency of the code, but they will also prevent the 
+JavaScript parser from changing its behavior.
+
diff --git a/doc/es/core/undefined.md b/doc/es/core/undefined.md
new file mode 100644
index 00000000..41dde82b
--- /dev/null
+++ b/doc/es/core/undefined.md
@@ -0,0 +1,74 @@
+## `undefined` y `null`
+
+JavaScript tiene dos valores distintos para `nothing`, el más útil de estos dos
+es `undefined`.
+
+### El valor `undefined`
+
+`undefined` es un tipo de dato con exactamente el mismo valor: `undefined`.
+
+El lenguaje también define una variable global que tiene el valor de `undefined`,
+Esta variable es también llamada `undefined`. Sin embargo, esta variable **no** es una 
+constante, ni es una palabra reservada del lenguaje. Esto significa que el *valor* 
+puede ser sobreescrito fácilmente.
+
+> **Nota ES5:** `undefined` en ECMAScript 5 **ya no es** *modificable* en modo esstricto,
+> pero su nombre todavía puede por ejemplo establecer una función con el nombre
+> `undefined`.
+
+Algunos ejemplos cuando el valor retorna `undefined`:
+
+ - Acceso a la variable global (sin modificar) `undefined`.
+ - Retorna implícitamente las funciones que no posean la sentencia `return`.
+ - Sentencia `return` que no retorna nada de forma explicíta.
+ - Búsquedas de propiedades inexistentes.
+ - Párametros de la función que no tienen ningún valor explicíto pasado.
+ - Cualquier valor que se estable en `undefined`.
+
+### Manejar los cambios en el valor deChanges `undefined`
+
+Dado que la variable `undefined` sólo tiene una copia del *value* de  
+`undefined`, assigna un nuevo valor que **no** cambie el valor del 
+*tipo* `undefined`.
+
+
+Aún con el fin de comparar con el valor de `undefined` es necesario
+recuperar el valor de `undefined` primero.
+
+Con el fin de proteger una posible sobreescritura en la variable `undefined`,
+una técnica común es agregar un párametro adicional a un 
+[wrapper anónimo](#function.scopes), que consiga ningún párametro que se le pase.
+
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // undefined en el ámbito local
+        // ahora hace referencia al valor
+
+    })('Hello World', 42);
+
+Otra forma de lograrlo un mismo efecto es declarar dentro un
+wrapper.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+La única diferencia, es que está versión es de 4 bytes más que utiliza, y en
+caso se comprima y no hay otra declaración de 'var' dentro del
+wrapper anónimo.
+
+
+### Uso de `null`
+
+Mientras que `undefined` en el contexto del lenguaje JavaScript es muy usado
+en el sentido tradicional como *null*, el actual `null` (ambos literal y de un tipo)
+es más o menos que otro tipo de datos.
+
+Es utilizado en algunos detalles internos de JavaScript (como declarar al final de un
+cadena de prototipo estableciendo `Foo.prototype = null`), pero en casi todos los
+casos, puede ser reemplazado por `undefined`.
+
diff --git a/doc/es/function/arguments.md b/doc/es/function/arguments.md
new file mode 100644
index 00000000..0eff8daf
--- /dev/null
+++ b/doc/es/function/arguments.md
@@ -0,0 +1,119 @@
+## El objeto `arguments`
+
+Cada ámbito de la función de JavaScript puede acceder a la variable especial `arguments`.
+Está variable contiene una lista de todos los argumentos que se pasan a la función.
+
+> **Nota:** En este caso `arguments` ya se ha definido dentro del ámbito de la
+> función ya sea através de la sentencia `var` o como un parámetro formal,
+> el objeto `arguments` no se creará.
+
+El objeto `arguments` **no** es un `Array`. Si bien cuenta con la semántica
+de un array - concretamente la propiedad `length` - no hereda de 
+`Array.prototype` y es de hecho un `Objeto`.
+
+Debido a esto, **no** es posible usar los métodos estándar de los arrays como `push`,
+`pop` o `slice` en `arguments`. Mientras que la iteración es un simple bucle `for` que 
+funciona muy bien, esto se convierte necesariamente en un `Array` real con el
+fin de utilizar los métodos de un `Array`.
+
+### Conversión de un Array
+
+El siguiente código devuelve un nuevo `Array` que contiene todos los elementos del
+objeto `arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Esta conversión es **lenta**, **no es recomendable** usarlo en puntos criticos que
+afecten el rendimiento del código.
+
+### Pasar Argumentos
+
+El siguiente método es recomendado para pasar argumentos desde una función a 
+otra.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // do stuff here
+    }
+
+Otro truco es utilizar tanto `call` y `apply` juntos para crear contenedores rápidos y
+consolidados.
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Crea una versión sin consolidar de "method" 
+    // Se toma los parámetros: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // Resultado: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### Los parámetros formales y argumentos de índices
+
+El objeto `arguments` crea las funciones de *getter* y *setter* para sus
+propiedades, así como parámetros formales de la función.
+
+Como resultado, se ha cambiado el valor formal del parámetro también se cambio el 
+valor de la propiedad correspondiente del objeto `arguments`, y al revés.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2                                                           
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Mitos y verdades sobre el rendimiento
+
+El objeto `arguments` es siempre creado con las dos únicas excepciones cuando es
+el caso en que declarado como un nombre dentro de la función o uno de los 
+parámetros formales. No importa si se utiliza o no.
+
+Ambos *getters* y *setters* son **siempre** creados; por lo tanto, con que casi no se
+tiene un impacto en el rendimiento en todo, especialemente no en el código real donde no 
+es más que un simple acceso a las propiedades del objeto `arguments`.
+
+> **Nota ES5:** Estos *getters* y *setters* no son creados en modo estricto.
+
+Sin embargo, hay casos en que se reducirá drásticamente el rendimiento en los motores
+modernos de JavaScript. Este es el caso del uso de `arguments.callee`.
+
+    function foo() {
+        arguments.callee; // realiza algo con la función del objeto
+        arguments.callee.caller; // y llama a la función del objeto
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Debería ser normalmente entre líneas...
+        }
+    }
+
+El código anterior, `foo` no puede estar sujeto a la [expansión en línea][1] ya que se 
+necesita saber acerca de sí mismo y la llamada. Esto no sólo denota los posibles beneficios
+de rendimiento que surgen con la expansión en línea, ya que también interrumpe la encapsulación
+ya que la función ahora puede ser dependiente de un contexto específico de llamada.
+
+Es **muy recomendable**  **nunca** hacer uso de `arguments.callee` o de cualquier
+de sus propiedades.
+
+> **Nota ES5:** En modo estricto, `arguments.callee` generará una excepción de `TypeError` ya que 
+> su uso ha quedado obsoleto.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
+
diff --git a/doc/es/function/closures.md b/doc/es/function/closures.md
new file mode 100644
index 00000000..40a77215
--- /dev/null
+++ b/doc/es/function/closures.md
@@ -0,0 +1,98 @@
+## Closures y referencias
+
+Una de las características más poderosas de JavaScript es la disponibilidad de *closures* (cerraduras),
+esto significa que los ámbitos **siempre** podrán ser accedidos por ámbitos externos donde
+fueron definidos. Dado que sólo el alcance es único en JavaScript en el 
+[ámbito de la función](#function.scopes), todas las funciones, por omisión, actúan como closures.
+
+### Emulando variables privadas
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+En este caso, `Counter` retorna **dos** closures. La función `increment` y la
+función `get`. Ambas funciones mantienen el ámbito de la **referencia** de  
+`Counter` y, por lo tanto, siempre accede a la variable `count` que fue definido
+en el ámbito.
+
+### ¿Por qué las variables privadas trabajan?
+
+Dado que no es posible referenciar o asignar ámbitos en JavaScript, **no** hay
+manera de acceder a la variable `count` desde fuera. Sólo existe una forma para
+interactuar con estos vía los dos closures.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+El código anterior **no** ha cambiado la variable `count` en el ámbito de `Counter`, 
+desde `foo.hack` no es definido en **ese** ámbito. En su lugar se creará - o 
+se anulará - la variable *global* `count`.
+
+### Closures dentro de bucles
+
+Un error frecuente en el uso de closures dentro de bucles, es como si se tratará
+de copiar el valor del índice de la variable del bucle.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+El código anterior **no** tendrá como salida los números del `0` al `9`, sino 
+simplementemente se imprimirá el número `10` diez veces.
+
+La función *anónima* hace **referencia** a `i` y se llama a
+`console.log`, el `bucle for` ya ha terminado y finalizo el valor de 
+`i` a `10`.
+
+Con el fin de obtener el comportamiento deseado, es necesario crear una **copia**
+del valor de `i`.
+
+### Evitando el problema de referencia
+
+Con el fin de copiar el valor de la variable índice del bucle, lo mejor es utilizar
+un [contenedor anónimo](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+La función anónima externa llamará inmediatamente a `i` como su primer 
+argumento y recibirá la copia del **valor** de `i` como parámetro de `e`.
+
+La función anónima que se pasa a `setTimeout` ahora es una referencia a 
+`e`, cuyo valor **no** han sido cambiados por el bucle.
+
+No hay otra manera de lograr esto; se debe retornar una función desde
+el contenedor anónimo, que tendrá el mismo comportamiento que el código 
+anterior.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
diff --git a/doc/es/function/constructors.md b/doc/es/function/constructors.md
new file mode 100644
index 00000000..9c4e2946
--- /dev/null
+++ b/doc/es/function/constructors.md
@@ -0,0 +1,129 @@
+## Constructores 
+
+Los constructores en JavaScript todavía son diferentes a los de otros lenguajes.
+Cualquier llamada que es precedida por la palabra `new` actua como un constructor.
+
+Dentro del constructor - la función llama - el valor de `this` se refiere a un
+`Objeto` recién creado. El [`prototipo`](#object.prototype) de este **nuevo** 
+objeto se establece en el `prototipo` de la funcióno que es invocado como el
+constructor.
+
+Si la función que se llama no tiene una sentencia `return` explícita, entonces
+implícitamente devuelve el valor de `this` - el nuevo objeto.  
+
+    function Foo() {
+        this.bla = 1;
+    }
+
+    Foo.prototype.test = function() {
+        console.log(this.bla);
+    };
+
+    var test = new Foo();
+
+La llamada de `Foo` por encima del constructor y establece el `prototipo` del objeto
+recién creado a `Foo.prototype`.
+
+En caso explícito de la sentencia `return` de la función devuelva el valor especificado
+que la declaración, **pero sólo** si el valor devuelto es un `Object`.                                     
+
+    function Bar() {
+        return 2;
+    }
+    new Bar(); // a new object
+
+    function Test() {
+        this.value = 2;
+
+        return {
+            foo: 1
+        };
+    }
+    new Test(); // the returned object
+
+Cuando una `nueva` keyword es omitidad, la función **no** devuelve un nuevo objeto. 
+
+    function Foo() {
+        this.bla = 1; // se establece en el objeto global
+    }
+    Foo(); // undefined
+
+Aunque el ejemplo anterior puede parecer que trabaja en algunos casos, debido
+a los trabajos de [`this`](#function.this) en JavaScript, que usará el
+*objeto global* como valor de `this`.
+
+### Fábricas
+
+Con el fin de ser capaz de omitir un `nuevo` keyword, la función del tiene 
+explícitamente devolver un valor.
+
+    function Bar() {
+        var value = 1;
+        return {
+            method: function() {
+                return value;
+            }
+        }
+    }
+    Bar.prototype = {
+        foo: function() {}
+    };
+
+    new Bar();
+    Bar();
+
+Ambos llamadas a `Bar` devuelven exactamente lo mismo, un reciente objeto creado que
+tiene como propiedad llamada el `method`, esto es un 
+[Closure](#function.closures).
+
+También hay que notar que la llamada `new Bar()` **no** afecta al prototipo
+del objeto devuelto. Mientras que el prototipo se establece en el objeto recién creado,
+ `Bar` nunca devuelve un nuevo objeto.
+
+En el ejemplo anterior, no hay diferencia funcional entre usar y no usar
+el keyword `new`.
+
+
+### Creación de nuevos objetos vía Factorias
+
+Una recomendación a menudo es **no** utilizar `new` ya que su uso puede
+conducir a errores.
+
+Con el fin de crear un nuevo objeto, uno bien debe utilizar una fábrica y un 
+constructor para crear un nuevo objeto dentro de la fábrica.
+
+    function Foo() {
+        var obj = {};
+        obj.value = 'blub';
+
+        var private = 2;
+        obj.someMethod = function(value) {
+            this.value = value;
+        }
+
+        obj.getPrivate = function() {
+            return private;
+        }
+        return obj;
+    }
+
+Aunque lo anterior es robuesto frente a la keyword `new` y, ciertamente hace
+que el uso de [variables privadas](#function.closures) sea fácil, esto viene con
+algunas desventajas.
+
+ 1. Se utiliza más memoria, ya que los objetos creados **no** comparten los métodos de
+    un prototipo.
+ 2. Con el fin de heredar de una fábrica se necesita copiar todos los métodos a otro
+    objeto o poner todo en un prototipo de nuevo objeto.
+ 3. La eliminación de una cadena de prototipo sólo por dejar la keyword `new` de
+    alguna manera va en contra del espíritu del lenguaje.
+
+### En conclusión
+
+Mientras que se omite el keyword `new` podría dar a errores,  **no** es ciertamente 
+una razón para abandonar el uso de prototipos por completo. Al final todo se reduce a 
+la solución que se adapta mejor a las necesidades de la aplicación, especialmente si es 
+importante elegir un estilo específico en la creación de objetos 
+**y resistirse**.
+
+
diff --git a/doc/es/function/general.md b/doc/es/function/general.md
new file mode 100644
index 00000000..c051373a
--- /dev/null
+++ b/doc/es/function/general.md
@@ -0,0 +1,48 @@
+## La declaración de funciones y expresiones
+
+Las funciones en JavaScript son funciones de primera clase `(first class functions)`.
+Esto significa que se pueden tratar como objetos. Un uso común de esta característica es pasar de
+una *función anónima* a otra, posiblemente una función asíncrona. Esto se conoce como `callback`.
+
+### La declaración `function`
+
+    function foo() {}
+
+La función anterior se [carga](#function.scopes) así mismo antes de iniciar la ejecución del
+programa; por lo tanto, está disponible en *todo* el scope (ámbito) de la aplicación
+donde se ha *definido*, aunque hubiera sido llamado antes de definirse en el código.
+
+    foo(); // Funciona porque foo ha sido creado antes que este código se ejecute
+    function foo() {}
+
+### La expresión `function`
+
+    var foo = function() {};
+
+Este ejemplo asigna una función sin nombre y anónima a la variable `foo`. 
+
+    foo; // 'undefined'
+    foo(); // Lanza TypeError
+    var foo = function() {};
+
+Debido a la declaración de `var`, que carga el nombre de la variable `foo` antes
+de la ejecución real del inicio del código, `foo` ya estará definidido cuando se
+ejecute el script.
+
+Pero se asigna sólo si ocurre en tiempo de ejecución, el valor de `foo` de forma 
+predetermina es [undefined](#core.undefined) antes de que el código se ejecute.
+
+### Expresión nombre de función
+
+Otro caso especial de asignación de nombre de funciones.
+
+    var foo = function bar() {
+        bar(); // Funciona
+    }
+    bar(); // ReferenceError
+
+Aquí `bar` no está disponible en el ámbito externo (scope), ya que la función sólo es 
+asignada a `foo`; Sin embargo, dentro de `bar` si está disponible. Esto se debe a la forma
+en como trabaja la [resolución de nombres](#function.scopes) en JavaScript, el nombre de 
+la función esta *siempre* disponible en el ámbito local de la propia función.
+
diff --git a/doc/es/function/scopes.md b/doc/es/function/scopes.md
new file mode 100644
index 00000000..00ed940c
--- /dev/null
+++ b/doc/es/function/scopes.md
@@ -0,0 +1,231 @@
+## Ámbitos y Namespaces
+
+A pesar que JavaScript tiene una muy buena sintaxis de dos llaves para los bloques,
+está **no** es compatible con el soporte de ámbito de bloques; por lo que todo se deja
+al lenguaje con el *ámbito de la función*.
+
+    function test() { // un ámbito
+        for(var i = 0; i < 10; i++) { // no es un ámbito
+            // cuenta
+        }
+        console.log(i); // 10
+    }
+
+> **Nota:** Cuando no use una instrucción, de retorno o una función como
+> argumento, la notación de `{...}` serán interpretadas como una declaración de bloques y
+> **no** como un objeto literal. Esto, en conjunto con la
+> [inserción automática de punto y coma](#core.semicolon), puede conducir a errores sutiles.
+
+Tampoco hay distintos namespaces en JavaScript, lo que significa que todo se define
+en un namespace *global y compartido*.
+
+Cada vez que una variable es referenciada, JavaScript recorre hacia arriba a través de todos
+los ámbitos hasta encontrarlo. En este caso que llegue al ámbito global y todavía no ha
+encontrado el nombre solicitado, se generará un error `ReferenceError`.
+
+### El terror de las variables globales
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+Estos dos scripts **no** tienen el mismo efecto. El script A define una variable
+llamada `foo` en el ámbito *global* y el script B define `foo` en el 
+*actual* ámbito.
+
+Una vez más, esto **no** tiene el *mismo efecto* para todo, no usar `var` puede tener
+mayor implicación.
+
+    // ámbito global
+    var foo = 42;
+    function test() {
+        // ámbito local
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+Dejando de lado la sentencia `var` dentro de la función `test` sobre escribiría el
+valor de `foo`. Si bien al principio puede parecer un gran cambio, se tiene
+miles de líneas de código en JavaScript y no se usaría `var` introduciendose en un
+horrible y difícil detección de errores.
+    
+    // ámbito global
+    var items = [/* some list */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // ámbito de subLoop
+        for(i = 0; i < 10; i++) { // falta la sentencia var
+            // ¡realizar cosas asombrosas!
+        }
+    }
+    
+El bucle externo terminará después de la primera llamada a `subLoop`,  desde `subLoop`
+sobreescribe el valor global de `i`. Usando `var` para el segundo bucle `for` se hace
+fácil evitar este error. La sentencia `var` no debe **nunca** dejarse a menos que
+el *efecto deseado* es afectado por el ámbito exterior.
+
+### Variables locales
+
+La única fuente para las variables locales en JavaScript son los parámetros de la
+[función](#function.general) y variables que fueron declaradas vía la sentencia
+`var`.
+
+    // ámbito global
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // ámbito local de la función test
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+Mientras `foo` y `i` son variables locales dentro del ámbitor de la función `test`,
+ela asignación de `bar` sobreescribe la variable global con el mismo nombre.
+
+### Hoisting
+
+La declaración de **hoists** en JavaScript. Esto significa que tanto la declaración de `var` y
+la `función` declarada se translada a la parte superior de su ámbito que lo contiene.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+El código anterior transforma antes de ejecutarse. JavaScript mueve
+la declaracione `var` aspi como las declaraciones de la `función` a la parte superior a
+lo más cercano del ámbito circundante.
+
+    // declaraciones var movidas aquí
+    var bar, someValue; // por omisión 'undefined'
+
+    // la función declarada es movida aquí también
+    function test(data) {
+        var goo, i, e; // se pierde el ámbito del bloque movido aquí
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // falla con TypeError desde bar sigue en 'undefined'
+    someValue = 42; // las asignaciones no se ven afectadas por hoisting
+    bar = function() {};
+
+    test();
+
+La falta de alcance del bloque no sólo moverá la declaración `var` fuera de los bucles y
+su contenido, sino también hará que los resultados de ciertos constructores `if`
+no sean intuitivas.
+
+En el código original la declaración de `if` si parecía modificar la *variable 
+global* `goo`, mientras actualmente este modifica la *variable local* - después hoisting 
+ha sido aplicado.
+
+Sin el conocimiento acerca de *hoisting*, a continuación el código puede parecer
+un `ReferenceError`.
+
+    // comprueba si SomeImportantThing ha iniciado
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Pero, por supuesto, lo anterior funciona debido a que la declaración `var` es movida
+a la parte superior del *ámbito global*.
+
+    var SomeImportantThing;
+
+    // otro código podría iniciar SomeImportantThing aqui, o no
+
+    // asegúrese de que está ahí
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Name Resolution Order
+
+All scopes in JavaScript, including the *global scope*, have the special name 
+[`this`](#function.this), defined in them, which refers to the *current object*. 
+
+Function scopes also have the name [`arguments`](#function.arguments), defined in
+them, which contains the arguments that were passed to a function.
+
+For example, when trying to access a variable named `foo` inside the scope of a 
+function, JavaScript will lookup the name in the following order:
+
+ 1. In case there is a `var foo` statement in the current scope, use that.
+ 2. If one of the function parameters is named `foo`, use that.
+ 3. If the function itself is called `foo`, use that.
+ 4. Go to the next outer scope, and start with **#1** again.
+
+> **Note:** Having a parameter called `arguments` will **prevent** the creation 
+> of the default `arguments` object.
+
+### Namespaces
+
+A common problem of having only one global namespace is the likeliness of running
+into problems where variable names clash. In JavaScript, this problem can
+easily be avoided with the help of *anonymous wrappers*.
+
+    (function() {
+        // a self contained "namespace"
+        
+        window.foo = function() {
+            // an exposed closure
+        };
+
+    })(); // execute the function immediately
+
+
+Unnamed functions are considered [expressions](#function.general); so in order to
+being callable, they must first be evaluated.
+
+    ( // evaluate the function inside the paranthesis
+    function() {}
+    ) // and return the function object
+    () // call the result of the evaluation
+
+There are other ways for evaluating and calling the function expression; which, 
+while different in syntax, do behave the exact same way.
+
+    // Two other ways
+    +function(){}();
+    (function(){}());
+
+### In Conclusion
+
+It is recommended to always use an *anonymous wrapper* for encapsulating code in 
+its own namespace. This does not only protect code against name clashes, but it 
+also allows for better modularization of programs.
+
+Additionally, the use of global variables is considered **bad practice**. **Any**
+use of them indicates badly written code that is prone to errors and hard to maintain.
+
diff --git a/doc/es/function/this.md b/doc/es/function/this.md
new file mode 100644
index 00000000..4fed1e35
--- /dev/null
+++ b/doc/es/function/this.md
@@ -0,0 +1,111 @@
+## Cómo trabaja `this`
+
+JavaScript tiene un concepto diferente sobre el nombre especial `this` referido a la 
+mayoría de lenguajes de programación. Hay exactamente **cinco** formas distintas en donde 
+es posible ver el valor de `this` dentro de lo posible en el lenguaje.
+
+### El ámbito global (Global Scope)
+
+    this;
+
+Cuando se utiliza `this` en el ámbito global, simplemente se refiere al objeto *global*.
+
+
+### Llamar a una función
+
+    foo();
+
+Aquí `this` se refiere al objeto *global*.
+
+> **Nota ES5:** En modo estricto (strict mode), el objeto global **ya no** es accesible a través de this.
+> `this` tendrá el valor de `undefined` en este caso.
+
+### Llamar a un método
+
+    test.foo(); 
+
+En este ejemplo `this` se referiere a `test`.
+
+### Llamar a un constructor
+
+    new foo(); 
+
+Llamar a una función que esta precedida por la palabra clave `new` actúa como
+un [constructor](#function.constructors). Dentro de la función, `this` se refiere 
+al `Objeto` *recién creado*.
+
+### Ajuste explícito de `this`
+
+    function foo(a, b, c) {}
+                          
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // array que se apilará
+    foo.call(bar, 1, 2, 3); // resultados a = 1, b = 2, c = 3
+
+Cuando se utiliza los métodos `call` o `apply` en `Function.prototype`, el valor de
+`this` dentro de la función llamada se ajustará **explícitamente** al primer argumento
+correspondiente a la llamada de la función.
+
+Como resultado, el ejemplo anterior sobre los *casos de métodos* estos **no** se aplican, y `this` 
+dentro de `foo` puede establecerse en `bar`.
+
+> **Nota:** `this` **no puede** ser usado para referirse a un objeto dentro de un `Objeto`
+> literal. Así `var obj = {me: this}` **no**  dará ninǵun resultado en `me` refiriendose a
+> `obj`, ya que `this` sólo será obtenido por uno de los cincos casos enumerados.
+
+### Errores comunes
+
+Si bien en la mayoría de los casos esto tiene sentido, el primero puede cosiderarse como otro
+mal diseño del lenguaje, ya que **nunca** tiene un uso práctico.
+
+    Foo.method = function() {
+        function test() {
+            // this es establecido como un objeto global
+        }
+        test();
+    };
+
+Un error común es que `this` dentro de `test` haga referencia a `Foo`, mientras que en
+realidad esto **no es así**.
+
+Con el fin de acceder a `Foo` desde dentro de `test` es necesario crear una variable local
+dentro del `método` para referirse a `Foo`.
+
+    Foo.method = function() {
+        var that = this;
+        function test() {
+            // Use that instead of this here
+        }
+        test();
+    };
+
+`that` es justo un nombre normal, pero es comúnmente usado para referenciar a `this`
+de forma externa. En combinación con [closures](#function.closures), esto puede ser
+también usado para pasar `this` como valor.
+
+### Asignación de métodos
+
+Otra cosa que **no** funciona en JavaScript son los alias en las funciones, es decir,
+**asignar** un método a una variable.
+
+    var test = someObject.methodTest;
+    test();
+
+Debido al primer caso, `test` actúa como una función de llamada; por lo que 
+`this` dentro de este no estará referido a `someObject`.
+
+Mientras que la unión de `this` puede parecer una mala idea en un principio, esto es en
+realidad lo que hace trabajar a la [herencia de prototipo](#object.prototype). 
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+Cuando los `métodos` son llamados desde una instancia de `Bar`, `this` se referirá a una
+instancia.
+
+
diff --git a/doc/es/index.json b/doc/es/index.json
new file mode 100644
index 00000000..1367f527
--- /dev/null
+++ b/doc/es/index.json
@@ -0,0 +1,68 @@
+{
+    "title": "Jardín de JavaScript",
+    "langTitle": "JavaScript Garden es Español",
+    "description": "Una guía sobre lo peculiar y defectos de JavaScript.",
+    "sections": [
+        {
+            "title": "Introducción",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "Objetos",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Funciones",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Arrays",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Tipos",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Núcleo",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon"
+            ]
+        },
+        {
+            "title": "Otros",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/es/intro/index.md b/doc/es/intro/index.md
new file mode 100644
index 00000000..fb2a288b
--- /dev/null
+++ b/doc/es/intro/index.md
@@ -0,0 +1,46 @@
+## Introducción
+
+**El Jardín de JavaScript** es una guía de documentación acerca de las
+partes más peculiares de este lenguaje de programación. Brinda consejos para evitar
+los errores más comunes y sutiles, así como problemas de rendimiento y de malas 
+prácticas que los programadores menos experimentados en JavaScript pueden resolver 
+en sus esfuerzos por profundizar en el lenguaje.
+
+El Jardín de JavaScript **no** prentende enseñar JavaScript.
+Se recomienda un conocimiento sobre el lenguaje para entender los temas tratados en
+esta guía. Con el fin de aprender los conceptos básicos del lenguaje, por favor 
+diríjase a la excelente [guía][1] de los desarrolladores de Mozilla.
+
+## Los autores
+
+Esta guía es el trabajo de dos encantadores usuarios del foro Stack Overflow, 
+[Ivo Wetzel][3] (Escrito) y [Zhang Yi Jiang][4] (Diseño).
+
+## Colaboradores
+
+- [Colaboradores](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## Hosting
+
+JavaScript Garden es hospedado en GitHub, además [Cramer Development][7] nos apoya
+con un sitio espejo en [JavaScriptGarden.info][8].
+
+## Licencia
+
+El Jardín de JavaScript es publicado bajo la [licencia MIT][9] y es hospedado en
+[GitHub][10]. Si encuentra algún error o errata por favor publique [una incidencia][11] o 
+envie un pull request a nuestro repositorio. También nos puede encontrar en la 
+[sala de chat de JavaScript][12] en Stack Overflow.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/es/object/forinloop.md b/doc/es/object/forinloop.md
new file mode 100644
index 00000000..48058682
--- /dev/null
+++ b/doc/es/object/forinloop.md
@@ -0,0 +1,51 @@
+## El bucle `for in`
+
+Al igual que el operador `in`, el bucle `for in` también recorre sobre la 
+cadena de prototipo cuando este se repite en una iteración en las propiedades de un objeto.
+
+> **Nota:** El bucle `for in` **no** se repetirá en cualquier propiedad que 
+> tenga atributos `enumerables` asignados a `false`; por ejemplo, la propiedad 
+> `length` de un array.
+    
+    // Envenenamiento en Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // Imprime ambos bar y moo
+    }
+
+Dado que no es posible cambiar el comportamiento del bucle `for in` en sí mismo, es
+necesario filtrar las propiedades internas no deseadas dentro del bucle, 
+esto se hace mediante el uso del método [`hasOwnProperty`](#object.hasownproperty) del 
+`Object.prototype`.
+
+> **Nota:** Dado que `for in` siempre recorre por completo la cadena de prototipo, 
+> este se pondrá más lento con cada capa adicional que un objeto herede.
+
+### Usando `hasOwnProperty` para filtrado
+
+    // Aún es el foo del código de arriba
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Está versión es la única forma correcta de uso. Esto se debe **sólo** al uso de 
+`hasOwnProperty` que imprimirá `moo`. Cuando `hasOwnProperty` se omita, el código es 
+propenso a errores  en los casos de prototipos nativos - ej. `Object.prototype` - 
+se ha extendedido.
+
+Uno de los frameworks más usado que implementa estas funcionalidades es [Prototype][1]. Cuando el 
+framework es incluido, el bucle `for in` que no utilicen `hasOwnProperty` no podrá garantizar que 
+se interrumpa.
+
+### En conclusión
+
+Se recomienda utilizar **siempre** el uso de `hasOwnProperty`. Nunca debe suponer  
+ningún entorno donde el código se ejecute, o si los prototipos
+nativos han sido extendidos o no. 
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/es/object/general.md b/doc/es/object/general.md
new file mode 100644
index 00000000..da48e138
--- /dev/null
+++ b/doc/es/object/general.md
@@ -0,0 +1,99 @@
+## Uso de objetos y propiedades
+
+Todo en JavaScript actúa como un objeto, con las dos únicas excepciones de
+[`null`](#core.undefined) y [`undefined`](#core.undefined).
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Un error muy común es el uso de literales númericos como objetos.
+Esto se debe a un error en el parser de JavaScript que intenta analizar la
+*notación de puntos* como un literal de punto flotante.
+
+    2.toString(); // lanza SyntaxError
+
+Existe un par de soluciones que pueden utilizarse para hacer que los
+literales númericos actúen como objetos.
+
+    2..toString(); // el segundo punto es reconocido correctamente
+    2 .toString(); // observe el espacio a la izquierda del punto
+    (2).toString(); // el número 2 se evalúa primero
+
+### Objetos como un tipo de datos
+
+Los objetos en JavaScript también pueden ser utilizados como una Tabla Hash o conocido como [*Hashmap*][1] en inglés, consisten
+principalmente en nombres de propiedades, y asignándoles valores a éstas.
+
+El uso de un objeto literal - con notación `{}` - puede crear un
+objeto plano. Este nuevo objeto [heredado](#object.prototype) desde `Object.prototype`
+no posee [propiedades propias](#object.hasownproperty) definidas.
+
+    var foo = {}; // un nuevo objeto vacío
+
+    // un nuevo objeto con la propiedad llamada 'test' con el valor 12
+    var bar = {test: 12};
+
+### Acceso a las propiedades
+
+Se puede acceder a las propiedades de un objeto de dos maneras, ya sea a través de la
+notación de punto o desde la notación de corchetes.
+
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+
+    var get = 'name';
+    foo[get]; // kitten
+
+    foo.1234; // SyntaxError
+    foo['1234']; // ¡funciona!
+
+Ambas notaciones son idénticas en su funcionamiento, la única diferencia es la
+notación de corchetes permite el ajuste dinámico de las propiedades, así como
+el uso de propiedades que de otro modo daría lugar a error de sintaxis.
+
+### Eliminando propiedades
+
+La única manera de eliminar una propiedad desde un objeto es usando el
+operador `delete`; establecer la propiedad a `undefined` o `null` solamente
+elimina el *valor* asociado a la propiedad, pero no la *key* (valor clave).
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+Los resultados de la salida son `bar undefined` y `foo null` - sólo `baz` ha
+sido removido y por lo tanto no aparece en la salida.
+
+### Notación de Keys
+
+    var test = {
+        'case': 'Soy una palabra clave y debo ser anotado como string',
+        delete: 'Soy una palabra clave también' // lanza SyntaxError
+    };
+
+Las propiedades de los objetos puede ser simbolizados como caracteres planos y como *strings*. Debido
+a otro mal diseño del parser de JavaScript, lo anterior es una excepción
+de `SyntaxError` antes de ECMAScript 5.
+
+Este error se produce porque `delete` es una *keyword*; por lo tanto, debe ser
+anotado como un *string literal* para asegurarse que será interpretado correctamente
+por diversos motores de JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/es/object/hasownproperty.md b/doc/es/object/hasownproperty.md
new file mode 100644
index 00000000..feb44ae9
--- /dev/null
+++ b/doc/es/object/hasownproperty.md
@@ -0,0 +1,53 @@
+## `hasOwnProperty`
+
+Con el fin de comprobar si un objeto posee una propiedad definida *en sí* mismo y **no**
+en algún lugar de su [cadena de prototipo](#object.prototype), es necesario utilizar
+el método `hasOwnProperty` ya que todos los objetos herendan de `Object.prototype`.
+
+> **Nota:** **No** es suficiente con comprobar si una propiedad está `definida`.
+> La propiedad bien podría existir, pero su valor sólo pasa a ser definido como 
+> `undefined`.
+
+`hasOwnProperty` es la única utilidad en JavaScript que se ocupa de las propiedades
+y **no** las salta en la cadena de prototipo.
+
+    // Envenenamiento en Object.prototype
+    Object.prototype.bar = 1; 
+    var foo = {goo: undefined};
+    
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+Sólo `hasOwnProperty` retornará el resultado correcto y esperado, esto es
+ensencial cuando se repite una iteración en las propiedades de cualquier objeto. No hay
+otra maner de excluir las propiedades que no están definidas en el mismo objeto, pero 
+en alguna parte de su cadena de prototipo si.
+
+### `hasOwnProperty` como propiedad
+
+JavaScript **no** protege el nombre de la propiedad `hasOwnProperty`; de este modo, si existe
+la posibilidad de que un objeto tenga una propiedad con el mismo nombre, es necesario utilizar
+`hasOwnProperty` como propiedad *externa* con el fin de obtener resultados correctos.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // siempre devolverá false
+
+    // Utilice otro objeto con hasOwnProperty y llamelo con 'this' para asignarlo a foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+### En conclusión
+
+Cuando se necesite comprobar la existencia de una propiedad en un objeto, `hasOwnProperty` es
+el **único** método para hacerlo. También se recomienda el uso de `hasOwnProperty` como
+parte de un [bucle `for in`](#object.forinloop), esto evitará errores desde
+extenciones de [prototipos](#object.prototype) nativos.
+
diff --git a/doc/es/object/prototype.md b/doc/es/object/prototype.md
new file mode 100644
index 00000000..0461d1ff
--- /dev/null
+++ b/doc/es/object/prototype.md
@@ -0,0 +1,116 @@
+## Prototipo
+
+JavaScript no posee en sus características un sistema clásico de herencia, sino que 
+utiliza un *prototipo* para esto. 
+
+Si bien a menudo se considera uno de los puntos débiles de JavaScript, el
+modelo de herencia prototipado es de hecho más poderoso que el modelo clásico.
+Por ejemplo, es bastante trivial construir un modelo clásico a partir del modelo prototipado,
+mientras que al contrario es una tarea mucho más difícil.
+
+Debido al hecho que JavaScript es básicamente el único lenguaje que utiliza
+ampliamente la herencia prototipada, se necesita algo de tiempo para adaptarse a
+las diferencias entre los dos modelos.
+
+La primera gran diferencia es que la herencia en JavaScript se realiza usando
+llamadas de *cadenas de prototipo* (*prototype chains*).
+
+> **Nota:** Simplemente usando `Bar.prototype = Foo.prototype` dará lugar a dos objetos 
+ > que comparten el **mismo** prototipo. Por lo tanto, los cambios que se realicen en un 
+> objeto afectará al otro objeto, así, en la mayoría de los casos no es el efecto 
+> deseado.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Asigna el prototipo de Bar como una nueva instancia de Foo
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Asegura que el constructor sea Bar
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar() // crea una nueva instancia de Bar
+
+    // Resultado de cadena de prototipos (prototype chain)
+    test [instance of Bar]
+        Bar.prototype [instance of Foo] 
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* etc. */ }
+
+En el código anterior, el objeto `test` hereda de `Bar.prototype` y `Foo.prototype`; 
+por lo tanto, tendrá acceso a la función `method` que se ha definido en `Foo`. 
+También se tendrá acceso a a la propiedad `value` de la **única** instancia de `Foo` 
+que compone su prototipo. Es importante tomar en cuenta que `new Bar()` **no** creará una nueva 
+instancia de `Foo`, pero retornará lo asignado en su prototipo; de este modo, todas las instancias 
+de `Bar` tendrán que compartir el **mismo** `valor` de la propiedad.
+
+> **Nota:** **No** utilice `Bar.prototype = Foo`, ya que no apunta al prototipo
+> de `Foo`, sino al objeto de la función `Foo`. Así la cadena de prototipo
+> cambiará a `Function.prototype` y no a `Foo.prototype`;
+> Por lo tanto, el `método` no estará disponible en la cadena de prototipo.
+
+### Búsqueda de propiedades
+
+Cuando se accede a las propiedades de un objeto, JavaScript recorre la cadena de
+prototipo hacia **arriba** hasta encontrar la propiedad con el nombre solicitado.
+
+Cuando se llega al final de la cadena - concretamente `Object.prototype` - y aún
+no se ha encontrado la propiedad especificada, se retornará un valor
+[undefined](#core.undefined) en su lugar.
+
+### La propiedad prototype
+
+Aunque la propiedad prototype es usada por el lenguaje para construir la cadena
+de prototipos, es posible asignar **cualquier** valor. Aunque los tipos primitivos 
+serán ignorados cuando se asigne en prototype.
+
+    function Foo() {}
+    Foo.prototype = 1; // no tendrá efecto
+
+La asignación de objetos, como se muestra en el ejemplo anterior, funcionará, y permitirá
+la creación dinámica de cadena de prototipos.
+
+### Rendimiento
+
+El tiempo tomado en la búsqueda de propiedades es alta y la cadena de prototipo puede
+presentar un impacto negativo crítico en el rendimiento en partes del código. Además, 
+si ha tratado de acceder a propiedades que no existen, esto provoca que se recorra la cadena de prototipo completa.
+
+Además, al recorrer en [iteración](#object.forinloop) las propiedades de un objeto
+, **cada** propiedad encontrada en la cadena de prototipo será enumerada.
+ 
+### Extensión de prototipos nativos
+
+Una mala característica que se suele utilizar para extender `Object.prototype` o cualquier
+otro prototipo construido.
+
+Esta técnica es conocida en inglés como [monkey patching][1] y rompe la *encapsulación* del código.
+Si bien es utilizado en frameworks como [Prototype][2], todavía no existen buenas razones para adoptarlo o integrarlo
+como tipos de dato o como funcionalidad no estándar.
+
+La **única** razón coherente para extender un prototipo es para adaptarle nuevas
+características de los motores JavaScript más modernos; por ejemplo, 
+[`Array.forEach`][3].
+
+### En conclusión
+
+Se **debe** entender por completo el módelo de herencia prototipado antes de 
+escribir código complejo que lo utilice. Además, observe la longitud de la
+cadena de prototipo y modifíquela si es necesario para evitar posibles problemas de 
+rendimiento. Con relación a los prototipos nativos, estos **nunca** deben ser extendidos a 
+menos que sea para mantener la compatibilidad con nuevas características de JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/es/other/timeouts.md b/doc/es/other/timeouts.md
new file mode 100644
index 00000000..c714645f
--- /dev/null
+++ b/doc/es/other/timeouts.md
@@ -0,0 +1,155 @@
+### `setTimeout` and `setInterval`
+
+Since JavaScript is asynchronous, it is possible to schedule the execution of a 
+function by using the `setTimeout` and `setInterval` functions.
+
+> **Note:** Timeouts are **not** part of the ECMAScript Standard. They are
+> implemented as part of the [DOM][1].
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // returns a Number > 0
+
+When `setTimeout` gets called, it will return the ID of the timeout and schedule
+`foo` to run in **approximately** one thousand milliseconds in the future. 
+`foo` will then get executed exactly **once**.
+
+Depending on the timer resolution of the JavaScript engine that is running the 
+code, as well as the fact that JavaScript is single threaded and other code that 
+gets executed might block the thread, it is by **no means** a safe bet that one 
+will get the exact delay that was specified in the `setTimeout` call.
+
+The function that was passed as the first parameter will get called by the
+*global object*, which means that [`this`](#function.this) inside the called function 
+refers to that very object.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this refers to the global object
+            console.log(this.value); // will log undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+
+> **Note:** As `setTimeout` takes a **function object** as its first parameter, an
+> often made mistake is to use `setTimeout(foo(), 1000)`, which will use the 
+> **return value** of the call `foo` and **not** `foo`. This is, most of the time, 
+> a silent error, since when the function returns `undefined` `setTimeout` will 
+> **not** raise any error.
+
+### Stacking Calls with `setInterval`
+
+While `setTimeout` only runs the function once, `setInterval` - as the name 
+suggests - will execute the function **every** `X` milliseconds, but its use is 
+discouraged. 
+
+When code that is being executed blocks the timeout call, `setInterval` will 
+still issue more calls to the specified function. This can, especially with small
+intervals, result in function calls stacking up.
+
+    function foo(){
+        // something that blocks for 1 second
+    }
+    setInterval(foo, 100);
+
+In the above code, `foo` will get called once and will then block for one second.
+
+While `foo` blocks the code, `setInterval` will still schedule further calls to
+it. Now, when `foo` has finished, there will already be **ten** further calls to
+it waiting for execution.
+
+### Dealing with Possible Blocking Code
+
+The easiest solution, as well as most controllable solution, is to use `setTimeout` within
+the function itself.
+
+    function foo(){
+        // something that blocks for 1 second
+        setTimeout(foo, 100);
+    }
+    foo();
+
+Not only does this encapsulate the `setTimeout` call, but it also prevents the
+stacking of calls and it gives additional control. `foo` itself can now decide 
+whether it wants to run again or not.
+
+### Manually Clearing Timeouts
+
+Clearing timeouts and intervals works by passing the respective ID to
+`clearTimeout` or `clearInterval`, depending which `set` function was used in
+the first place.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Clearing all timeouts
+
+Because there is no built-in method for clearing all timeouts and/or intervals, 
+it is necessary to use brute force in order to achieve this functionality.
+
+    // clear "all" timeouts
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+There might still be timeouts that are unaffected by this arbitrary number;
+therefore, is is instead recommended to keep track of all the timeout IDs, so
+they can be cleared specifically.
+
+### Hidden use of `eval`
+
+`setTimeout` and `setInterval` can also take a string as their first parameter.
+This feature should **never** be used because it internally makes use of `eval`.
+
+> **Note:** Since the timeout functions are **not** specified by the ECMAScript
+> standard, the exact workings when a string is passed to them might differ in
+> various JavaScript implementations. For example, Microsoft's JScript makes use of
+> the `Function` constructor in place of `eval`.
+
+    function foo() {
+        // will get called
+    }
+
+    function bar() {
+        function foo() {
+            // never gets called
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Since `eval` is not getting called [directly](#core.eval) in this case, the string 
+passed to `setTimeout` will get executed in the *global scope*; thus, it will 
+not use the local variable `foo` from the scope of `bar`.
+
+It is further recommended to **not** use a string for passing arguments to the
+function that will get called by either of the timeout functions. 
+
+    function foo(a, b, c) {}
+    
+    // NEVER use this
+    setTimeout('foo(1,2, 3)', 1000)
+
+    // Instead use an anonymous function
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **Note:** While it is also possible to use the syntax 
+> `setTimeout(foo, 1000, 1, 2, 3)`, it is not recommended, as its use may lead
+> to subtle errors when used with [methods](#function.this). 
+
+### In Conclusion
+
+**Never** should a string be used as the parameter of `setTimeout` or 
+`setInterval`. It is a clear sign of **really** bad code, when arguments need 
+to be supplied to the function that gets called. An *anonymous function* should
+be passed that then takes care of the actual call.
+
+Furthermore, the use of `setInterval` should be avoided because its scheduler is not
+blocked by executing JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
+
diff --git a/doc/es/types/casting.md b/doc/es/types/casting.md
new file mode 100644
index 00000000..34d6fd78
--- /dev/null
+++ b/doc/es/types/casting.md
@@ -0,0 +1,70 @@
+## Type Casting
+
+JavaScript is a *weakly typed* language, so it will apply *type coercion*
+**wherever** possible.
+
+    // These are true
+    new Number(10) == 10; // Number.toString() is converted
+                          // back to a number
+
+    10 == '10';           // Strings gets converted to Number
+    10 == '+10 ';         // More string madness
+    10 == '010';          // And more 
+    isNaN(null) == false; // null converts to 0
+                          // which of course is not NaN
+    
+    // These are false
+    10 == 010;
+    10 == '-10';
+
+> **ES5 Note:** Number literals that start with a `0` are interpreted as octal 
+> (Base 8). Octal support for these has been **removed** in ECMAScript 5 strict 
+> mode.
+
+In order to avoid the above, use of the [strict equal operator](#types.equality) 
+is **highly** recommended. Although this avoids a lot of common pitfalls, there 
+are still many further issues that arise from JavaScript's weak typing system.
+
+### Constructors of Built-In Types
+
+The constructors of the built in types like `Number` and `String` behave
+differently when being used with the `new` keyword and without it.
+
+    new Number(10) === 10;     // False, Object and Number
+    Number(10) === 10;         // True, Number and Number
+    new Number(10) + 0 === 10; // True, due to implicit conversion
+
+Using a built-in type like `Number` as a constructor will create a new `Number` 
+object, but leaving out the `new` keyword will make the `Number` function behave
+like a converter.
+
+In addition, having literals or non-object values in there will result in even
+more type coercion.
+
+The best option is to cast to one of the three possible types **explicitly**.
+
+### Casting to a String
+
+    '' + 10 === '10'; // true
+
+By prepending an empty string, a value can easily be casted to a string.
+
+### Casting to a Number
+
+    +'10' === 10; // true
+
+Using the **unary** plus operator, it is possible to cast to a number.
+
+### Casting to a Boolean
+
+By using the **not** operator twice, a value can be converted a boolean.
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
+
+
diff --git a/doc/es/types/equality.md b/doc/es/types/equality.md
new file mode 100644
index 00000000..f933d495
--- /dev/null
+++ b/doc/es/types/equality.md
@@ -0,0 +1,71 @@
+## Igualdad y Comparación
+
+JavaScript posee 2 maneras diferentes para comparar valores entre objetos para comprobar igualdad.
+
+### El Operador de Igualdad
+
+El operador de igualdad consiste en 2 signos es igual: `==`
+
+JavaScript utiliza *tipado débil*. Esto significa que el operador de igualdad 
+**obliga** una conversión de tipos para poder compararlos.
+    
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+La tabla anterior muestra los resultados de la conversión de tipos, éste es el motivo principal
+de por qué el uso de `==` es ampliamente considerado una mala práctica. Introduce errores
+difíciles de identificar debido a la complejidad de sus reglas de conversión.
+
+Además, existe un impacto en el rendimiento cuando entra en juego la conversión de tipos;
+por ejemplo, una cadena debe ser convertida a número antes de poder ser comparada
+con otro número.
+
+### El Operador de Igualdad Estricto
+
+El operador de igualdad estricto consiste en **tres** signos es igual: `===`:
+
+Funciona exactamente  igual que el operador de igualdad, excepto que el operador de igualdad
+estricto **no** utiliza conversión de tipos entre sus operandos.
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+Los resultados anteriores son mucho más claros y permiten una detección de errores temprana.
+Esto permite un código más sólido en cierto grado y también mejora el rendimiento
+en el caso que los operandos sean de tipos diferentes.
+
+### Comparando Objetos
+
+Aunque `==` como `===` son considerados operadores de **igualdad**, se comportan
+de maneras diferentes cuando al menos uno de sus operandos es `Object`.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+En este caso, los dos operadores comparan por **referencia** y **no** por igualdad; esto es,
+comparan por la misma **instancia** del objeto, parecido 
+al operador `is` en Python y la comparación entre punteros en C.
+
+### En Conclusión
+
+Es altamente recomendable usar sólo el operador de **igualdad estricta**. En los casos
+donde los tipos de datos necesitan ser convertidos, debe hacerse [explícitamente](#types.casting)
+y no dejárselo a las complicadas reglas de conversión del lenguaje.
+
diff --git a/doc/es/types/instanceof.md b/doc/es/types/instanceof.md
new file mode 100644
index 00000000..84251128
--- /dev/null
+++ b/doc/es/types/instanceof.md
@@ -0,0 +1,38 @@
+## The `instanceof` Operator
+
+The `instanceof` operator compares the constructors of its two operands. It is 
+only useful when comparing custom made objects. Used on built-in types, it is
+nearly as useless as the [typeof operator](#types.typeof).
+
+### Comparing Custom Objects
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // This just sets Bar.prototype to the function object Foo
+    // But not to an actual instance of Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### Using `instanceof` with Native Types
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+One important thing to note here is that `instanceof` does not work on objects 
+that originate from different JavaScript contexts (e.g. different documents
+in a web browser), since their constructors will not be the exact same object.
+
+### In Conclusion
+
+The `instanceof` operator should **only** be used when dealing with custom made 
+objects that originate from the same JavaScript context. Just like the
+[`typeof`](#types.typeof) operator, every other use of it should be **avoided**.
+
diff --git a/doc/es/types/typeof.md b/doc/es/types/typeof.md
new file mode 100644
index 00000000..00377db4
--- /dev/null
+++ b/doc/es/types/typeof.md
@@ -0,0 +1,87 @@
+## The `typeof` Operator
+
+The `typeof` operator (together with 
+[`instanceof`](#types.instanceof)) is probably the biggest 
+design flaw of JavaScript, as it is near of being **completely broken**.
+
+Although `instanceof` still has its limited uses, `typeof` really has only one
+practical use case, which does **not** happen to be checking the type of an 
+object. 
+
+> **Note:** While `typeof` can also be called with a function like syntax
+> i.e. `typeof(obj)`, this is not a function call. The two parenthesis will
+> behave like normal and the return value will be used as the operand of the
+> `typeof` operator. There is **no** `typeof` function.
+
+### The JavaScript Type Table
+
+    Value               Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+In the above table, *Type* refers to the value that the `typeof` operator returns.
+As can be clearly seen, this value is anything but consistent.
+
+The *Class* refers to the value of the internal `[[Class]]` property of an object.
+
+> **From the Specification:** The value of `[[Class]]` can be one of the
+> following strings. `Arguments`, `Array`, `Boolean`, `Date`, `Error`, 
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+In order to retrieve the value of `[[Class]]`, one has to make use of the
+`toString` method of `Object.prototype`.
+
+### The Class of an Object
+
+The specification gives exactly one way of accessing the `[[Class]]` value,
+with the use of `Object.prototype.toString`. 
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+In the above example, `Object.prototype.toString` gets called with the value of
+[this](#function.this) being set to the object whose `[[Class]]` value should be 
+retrieved.
+
+> **ES5 Note:** For convenience the return value of `Object.prototype.toString` 
+> for both `null` and `undefined` was **changed** from `Object` to `Null` and 
+> `Undefined` in ECMAScript 5.
+
+### Testing for Undefined Variables
+
+    typeof foo !== 'undefined'
+
+The above will check whether `foo` was actually declared or not; just 
+referencing it would result in a `ReferenceError`. This is the only thing
+`typeof` is actually useful for.
+
+### In Conclusion
+
+In order to check the type of an object, it is highly recommended to use 
+`Object.prototype.toString` because this is the only reliable way of doing so. 
+As shown in the above type table, some return values of `typeof` are not defined 
+in the specification; thus, they can differ across various implementations.
+
+Unless checking whether a variable is defined, `typeof` should be avoided at
+**all costs**.
+
+
diff --git a/doc/fi/function/arguments.md b/doc/fi/function/arguments.md
index 153dad34..af70618e 100644
--- a/doc/fi/function/arguments.md
+++ b/doc/fi/function/arguments.md
@@ -52,7 +52,7 @@ Tästä seuraa, että muodollisen parametrin arvon muuttaminen muuttaa myös `ar
 
     function foo(a, b, c) {
         arguments[0] = 2;
-        a; // 2                                                           
+        a; // 2
 
         b = 4;
         arguments[1]; // 4
diff --git a/doc/fi/function/this.md b/doc/fi/function/this.md
index 3ebf0a7b..3e2b09d2 100644
--- a/doc/fi/function/this.md
+++ b/doc/fi/function/this.md
@@ -51,7 +51,7 @@ Useimmat näistä tapauksista ovat järkeviä. Ensimmäistä niistä tosin voida
             // this asettuu globaaliin olioon
         }
         test();
-    }
+    };
 
 Yleisesti luullaan, että test-funktion sisältämä `this` viittaa tässä tapauksessa `Foo`-olioon. Todellisuudessa se **ei** kuitenkaan tee näin.
 
@@ -63,7 +63,7 @@ Jotta `Foo`-olioon voidaan päästä käsiksi `test`-funktion sisällä, tulee m
             // Käytä thatia thissin sijasta
         }
         test();
-    }
+    };
 
 `that` on normaali nimi, jota käytetään yleisesti viittaamaan ulompaan `this`-muuttujaan. [Sulkeumia](#function.closures) käytettäessä `this`-arvoa voidaan myös välittää edelleen.
 
diff --git a/doc/fi/intro/contributors.md b/doc/fi/intro/contributors.md
index 7147d319..cda4a6fd 100644
--- a/doc/fi/intro/contributors.md
+++ b/doc/fi/intro/contributors.md
@@ -1,8 +1,3 @@
 ## Osallistujat
 
- - [Caio Romão][1] (oikeinkirjoituskorjauksia)
- - [Andreas Blixt][2] (kielikorjauksia)
-
-[1]: https://github.com/caio
-[2]: https://github.com/blixt
-
+- [Osallistujat](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
diff --git a/doc/fi/object/general.md b/doc/fi/object/general.md
index c169117f..6a0e613b 100644
--- a/doc/fi/object/general.md
+++ b/doc/fi/object/general.md
@@ -2,7 +2,7 @@
 
 Kaikki muuttujat, kahta poikkeusta lukuunottamatta, käyttäytyvät JavaScriptissä oliomaisesti. Nämä poikkeukset ovat [`null`](#core.undefined) sekä [`undefined`](#core.undefined).
 
-    false.toString() // epätosi
+    false.toString(); // epätosi
     [1, 2, 3].toString(); // '1,2,3'
     
     function Foo(){}
@@ -34,7 +34,7 @@ Olioliteraalinotaatiota - `{}` - käyttäen voidaan luoda tyhjä olio. Tämä ol
 
 Olion ominaisuuksiin voidaan päästä käsiksi kahta eri tapaa käyttäen. Siihen voidaan käyttää joko piste- tai hakasulkunotaatiota.
 
-    var foo = {name: 'Kitten'}
+    var foo = {name: 'kitten'}
     foo.name; // kitten
     foo['name']; // kitten
     
diff --git a/doc/fi/object/prototype.md b/doc/fi/object/prototype.md
index 4ecdae89..f2497e05 100644
--- a/doc/fi/object/prototype.md
+++ b/doc/fi/object/prototype.md
@@ -31,7 +31,7 @@ Ensimmäinen suuri ero liittyy siihen, kuinka perintä toimii. JavaScriptissä s
     // Prototyyppiketju
     test [Bar-olio]
         Bar.prototype [Foo-olio] 
-            { foo: 'Terve maailma' }
+            { foo: 'Terve maailma', value: 42 }
             Foo.prototype
                 { method: ... }
                 Object.prototype
diff --git a/doc/fi/other/timeouts.md b/doc/fi/other/timeouts.md
index ba361f54..fd6cc8f1 100644
--- a/doc/fi/other/timeouts.md
+++ b/doc/fi/other/timeouts.md
@@ -99,10 +99,10 @@ Tämän lisäksi on suositeltavaa olla **käyttämättä** merkkijonoja parametr
 
     // Käytä nimetöntä funktiota sen sijaan
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
-> **Huomio:** Vaikka syntaksi `setTimeout(foo, 1000, a, b, c)` onkin mahdollinen, ei sen käyttöä suositella. Tämä johtuu siitä, että sen käyttö voi johtaa virheisiin erityisesti [metodien](#function.this) kanssa.
+> **Huomio:** Vaikka syntaksi `setTimeout(foo, 1000, 1, 2, 3)` onkin mahdollinen, ei sen käyttöä suositella. Tämä johtuu siitä, että sen käyttö voi johtaa virheisiin erityisesti [metodien](#function.this) kanssa.
 
 ### Yhteenveto
 
diff --git a/doc/fr/array/constructor.md b/doc/fr/array/constructor.md
new file mode 100644
index 00000000..76f9eda0
--- /dev/null
+++ b/doc/fr/array/constructor.md
@@ -0,0 +1,27 @@
+## Le constructeur `Array`
+
+Le constructeur `Array` traite ses paramètres de façon ambigu.
+Il est fortement recommandé d'utiliser le littéral de tableau  - notation `[]` - pour créer de nouveaux tableaux.
+
+    [1, 2, 3]; // Résultat: [1, 2, 3]
+    new Array(1, 2, 3); // Résultat: [1, 2, 3]
+    
+    [3]; // Résultat: [3]
+    new Array(3); // Résultat: []
+    new Array('3') // Résultat: ['3']
+
+Dans les cas où il n'y a qu'un seul argument passé au constructeur `Array`, et quand cet argument est un nombre `Number`, le constructeur va retourner un nouveau tableau *clairsemé* avec la propriété `length` (longueur) fixée à la valeur de l'argument.
+Il faut noter que de cette façon, **seulement** la propriété `length` du nouveau tableau sera mise en place, les indices réels du tableau ne seront pas initialisés.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // faux, l'indice n'existe pas
+
+Être en mesure de régler la longueur du tableau à l'avance n'est utile que dans quelques cas, comme la répétition d'une chaîne de caractères, dans lequel on évite l'utilisation d'une boucle.
+
+    new Array(count + 1).join(chaineARepeter);
+
+### En conclusion
+
+Les littéraux sont préférés au constructeur `Array`. Ils sont plus courts, ont une syntaxe plus claire, et augmente la lisibilité du code.
+
diff --git a/doc/fr/array/general.md b/doc/fr/array/general.md
new file mode 100644
index 00000000..aecec798
--- /dev/null
+++ b/doc/fr/array/general.md
@@ -0,0 +1,46 @@
+## Tableaux: iteration et propriétés
+
+Bien que les tableaux soient des objets en JavaScript, il n'y a pas de bonnes raisons d'utiliser la boucle [`for in`](#object.forinloop).
+En fait, il y a un certain nombre de bonnes raisons **contre** l'utilisation de `for in` sur les tableaux.
+
+**Remarque:** Les tableaux JavaScript ne sont **pas** *associatifs*. JavaScript n'offre que les [objets](#object.general) pour associer des clés à des valeurs. Contrairement aux tableaux associatifs, les objets ne préservent **pas** l'ordre.
+
+La boucle `for in` énumère toutes les propriétés qui sont sur la chaîne de prototypes, et le seul moyen d'exclure ces propriétés consiste à utiliser
+[`hasOwnProperty`](#object.hasownproperty), par conséquent la boucle `for in ` est **vingt fois** plus lente qu'une boucle `for` classique.
+
+### Itération
+
+Pour itérer sur les tableaux de façon performante, il est préférable d'utiliser la boucle `for` classique.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Notez l'optimization supplémentaire dans l'exemple ci-dessus: la longueur du tableau est mise en mémoire "cached" via `l = list.length`.
+
+La propriété `length` est définie sur le tableau lui-même, mais la rechercher à chaque itération de la boucle à un coût.
+Bien que les moteurs JavaScript récents **peuvent** appliquer l'optimisation, il n'y a aucun moyen de savoir si le code s'exécutera sur un de ces nouveaux moteurs.
+
+En effet, mettre la longueur du tableau en mémoire cache peut **doubler** la vitesse d'execution de la boucle.
+
+### La propriété `length`
+
+Le *getter* de la propriété `length` (longueur) renvoie simplement le nombre d'éléments contenus dans le tableau, mais le *setter* peut être utilisé pour
+tronquer le tableau.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+    
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Attribuer une longueur inférieure tronque le tableau. Accroître la longueur crée un tableau clairsemé.
+
+### En conclusion
+
+Pour de meilleures performances, il est recommandé de toujours utiliser la boucle `for` classique et de mettre en mémoire la propriété `length`.
+L'utilisation de la boucle `for in` sur un tableau est un signe de code mal écrit, de mauvaise performance, et sujet à des bogues.
+
diff --git a/doc/fr/core/delete.md b/doc/fr/core/delete.md
new file mode 100644
index 00000000..5ef0b16b
--- /dev/null
+++ b/doc/fr/core/delete.md
@@ -0,0 +1,76 @@
+## L'opérateur `delete`
+
+Il est *impossible* de supprimer les variables globales, fonctions et autres choses qui ont l'attribut `DontDelete` en JavaScript.
+
+### Le code global et le code de fonction
+
+Quand une variable ou une fonction est définie dans la portée globale ou une [portée de fonction](#function.scopes), c'est une propriété soit de l'objet d'activation, soit de l'objet global.
+Ces propriétés ont un ensemble d'attributs, dont l'un est `DontDelete`. Les déclarations de variables et de fonctions dans le code global et le code de fonction vont toujours créer des propriétés avec `DontDelete`, elle ne peuvent donc pas être supprimées.
+
+    // global variable:
+    var a = 1; // DontDelete est mis
+    delete a; // faux
+    a; // 1
+    
+    // normal function:
+    function f() {} // DontDelete is mis
+    delete f; // faux
+    typeof f; // "function"
+    
+    // reassigner n'aide pas:
+    f = 1;
+    delete f; // faux
+    f; // 1
+
+### Propriétés explicites
+
+Les propriétés crées explicitement peuvent être supprimées normalement.
+
+    // propriété crée explicitement:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // vrai
+    delete obj.y; // vrai
+    obj.x; // undefined
+    obj.y; // undefined
+
+Dans l'exemple ci-dessus, les propriétés `obj.x` et `obj.y` peuvent être supprimées parce qu'elles n'ont pas l'attribut `DontDelete`. C'est aussi pourquoi l'exemple ci-dessous fonctionne également.
+
+    // ceci fonctionne, sauf sur IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // vrai - juste une var globale
+    delete GLOBAL_OBJECT.a; // vrai
+    GLOBAL_OBJECT.a; // undefined
+
+Ici, nous utilisons une astuce pour supprimer `a`. [`this`](#function.this) se réfère ici à l'objet global et nous déclarons explicitement la variable `a` comme sa propriété, ce qui nous permet de la supprimer.
+
+IE (au moins 6-8) a quelques bogues, le code ci-dessus n'y fonctionne pas.
+
+### Les arguments de fonction et built-ins
+
+Les arguments normaux de fonctions, [objets `arguments`](#Function.arguments) et les propriétés intégrées "built-in" ont aussi l'attribut `DontDelete`.
+
+    // les arguments de fonction et les propriétés:
+    (function (x) {
+    
+      delete arguments; // faux
+      typeof arguments; // "object"
+      
+      delete x; // faux
+      x; // 1
+      
+      function f(){}
+      delete f.length; // faux
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Objets hôtes
+
+Le comportement de l'opérateur `delete` peut être imprévisible pour les objets hébergés "hosted". Dû à la spécification, les objets hôte sont autorisés à mettre en œuvre tout type de comportement.
+    
+### En conclusion
+
+L'opérateur `delete` a souvent un comportement inattendu et ne peut être utilisé que pour supprimer les propriétés explicitement définies sur des objets normaux.
+
diff --git a/doc/fr/core/eval.md b/doc/fr/core/eval.md
new file mode 100644
index 00000000..5b2cdcd1
--- /dev/null
+++ b/doc/fr/core/eval.md
@@ -0,0 +1,42 @@
+## Il ne faut pas utiliser `eval`
+
+La fonction `eval` exécute une chaîne de caractères représentant du code JavaScript dans la portée locale.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+Cependant, `eval` n'exécute dans la portée locale que quand il est appelé directement *et* quand le nom de la fonction appelée est en fait `eval`.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+L'utilisation de la fonction `eval` doit être évitée. 99,9% de ses "cas d'utilisation" peuvent être obtenues **sans** elle.
+    
+### `eval` déguisé
+
+Les [fonctions timeout](#other.timeouts) `setTimeout` et `setInterval` acceptent une chaîne comme premier argument.
+Cette chaîne sera **toujours** exécutée dans la portée globale car dans ce cas, `eval` n'est pas appelé directement.
+
+### Problèmes de sécurité
+
+`eval` est aussi un problème de sécurité, car il exécute **n'importe quel** code qu'on lui donne.
+Il devrait **jamais** être utilisé avec des chaînes d'origines inconnues ou douteuses.
+
+### En conclusion
+
+`eval` ne devrait jamais être utilisé. Sa presence met en doute le fonctionnement, la performance, et la sécurité du code qui l'utilise.
+Si quelque chose a besoin d'`eval` pour pouvoir fonctionner, il ne doit **pas** être utilisé en premier lieu. Un *meilleur design* qui n'utilise pas `eval` doit être trouvé et implementé.
+
diff --git a/doc/fr/core/semicolon.md b/doc/fr/core/semicolon.md
new file mode 100644
index 00000000..75e4ac11
--- /dev/null
+++ b/doc/fr/core/semicolon.md
@@ -0,0 +1,100 @@
+## Insertion automatique du point-virgule
+
+Bien que JavaScript a une syntaxe de style C, il n'impose **pas** les points-virgules dans le code source. Il est donc possible de les omettre.
+
+JavaScript n'est pas un langage sans points-virgules. En fait, les points-virgules sont necessaires pour comprendre le code source. Par conséquent, l'analyseur JavaScript les insère **automatiquement** chaque fois qu'il rencontre une erreur d'analyse due à un point-virgule manquant.
+
+    var foo = function() {
+    } // erreur d'analyse, point-virgule attendu
+    test()
+
+L'analyseur insère un point-virgule, puis tente à nouveau.
+
+    var foo = function() {
+    }; // plus d'error, l'analyse continue
+    test()
+
+L'insertion automatique du point-virgule est considérée comme l'un des **plus gros** défauts de conception dans le langage parce que cela *peut* changer le comportement du code.
+
+### Comment cela marche
+
+Le code ci-dessous n'a pas de points-virgules, l'analyseur va donc décider où les insérer.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+    
+            (options.list || []).forEach(function(i) {
+    
+            })
+    
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+    
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+    
+    })(window)
+    
+    (function(window) {
+        window.someLibrary = {}
+    
+    })(window)
+
+Voici le résultat du jeu de devinette de l'analyseur.
+
+    (function(window, undefined) {
+        function test(options) {
+    
+            // pas inséré, les lignes ont fusionné
+            log('testing!')(options.list || []).forEach(function(i) {
+    
+            }); // <- inséré
+    
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- inséré
+    
+            return; // <- inséré, casse la déclaration return
+            { // traité comme un bloc
+    
+                // un label et une déclaration d'expression
+                foo: function() {} 
+            }; // <- inséré
+        }
+        window.test = test; // <- inséré
+    
+    // les lignes ont fusionné ici encore
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- inséré
+    
+    })(window); //<- inséré
+
+> **Remarque:** L'analyseur JavaScript ne manipule pas "correctement" les déclarations return suivies par une nouvelle ligne.
+
+L'analyseur a radicalement changé le comportement du code ci-dessus. Dans certains cas, il fait la **mauvaise chose**.
+
+### Parenthèse en tête
+
+En cas de parenthèse en tête, l'analyseur ne va **pas** insérer de point-virgule.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Ce code fusionne en une ligne.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+Il y a de **très** fortes chances que `log` ne retourne **pas** de fonction; par conséquent, le programme ci-dessus va produire une erreur de type `TypeError` indiquant que undefined n'est pas un function `undefined is not a function`.
+
+### En conclusion
+
+Il est fortement recommandé de ne **jamais** omettre les points-virgules. Il est également recommandé de garder les accolades sur la même ligne que leurs déclarations correspondantes et de ne jamais les omettre pour les déclaration en une ligne `if` / `else`. Ces mesures vont non seulement améliorer la cohérence du code, mais elles empêcheront également l'analyseur JavaScript de changer le comportement du code.
+
diff --git a/doc/fr/core/undefined.md b/doc/fr/core/undefined.md
new file mode 100644
index 00000000..4736b5dc
--- /dev/null
+++ b/doc/fr/core/undefined.md
@@ -0,0 +1,55 @@
+## `undefined` et `null`
+
+JavaScript a deux valeurs distinctes pour "rien": `null` et `undefined`, `undefined` étant la plus utile.
+
+### La valeur `undefined`
+
+`undefined` est un type avec exactement une valeur:` undefined`.
+
+Le langage définit également une variable globale qui a la valeur `undefined`. Cette variable est aussi appelée `undefined`. Cependant, cette variable n'est ni une constante, ni un mot clé du langage, ce que signifie que sa *valeur* peut être facilement écrasée.
+
+> **Remarque ES5:** `undefined` dans ECMAScript 5 n'est **plus** inscriptible dans le mode stricte, mais son nom peut toujours être outrepassé, par example par une fonction avec le nom `undefined`.
+
+Voici quelques exemples de cas où la valeur `undefined` est retournée:
+
+ - Accès à la variable globale (non modifié) `undefined`.
+ - Accès à une variable déclarée, mais *pas encore* initialisée.
+ - Retours implicites de fonctions sans déclaration `return`.
+ - Déclarations `return` vides, qui ne renvoient rien.
+ - Recherches de propriétés inexistantes.
+ - Paramètres de fonction qui ne ont pas de valeur explicite passée.
+ - Tout ce qui a été mis à la valeur de `undefined`.
+ - Toute expression sous forme de `void(expression)`.
+
+### Changements à la valeur de `undefined`
+
+Puisque la variable globale `undefined` contient uniquement une copie de la *valeur* réelle `undefined`, l'attribution d'une nouvelle valeur à la variable ne modifie **pas** la valeur du *type* `undefined`.
+
+Pourtant, pour pouvoir comparer quelque chose contre la valeur de `undefined`, il est d'abord nécessaire pour récupérer la valeur de `undefined`.
+
+Afin de protéger le code contre une éventuelle variable `undefined` écrasée, une technique commune utilisée consiste à ajouter un paramètre supplémentaire à une [enveloppe anonyme](#function.scopes) et de lui passer aucun argument.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // undefined dans la portée locale 
+        // réfère bien à la valeur `undefined`
+
+    })('Hello World', 42);
+
+Une autre façon d'obtenir le même effet est d'utiliser une déclaration à l'intérieur de l'enveloppe.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+La seule différence étant quelques caractères de plus pour écrire "var".
+
+### Utilisation de `null`
+
+Alors que `undefined` dans le contexte du langage JavaScript est utilisé dans la plupart des cas dans le d'un *null* traditionnel, le `null` réel (un littéral et un type) est juste un autre type de données.
+
+`null` est utilisé par JavaScript (comme signaler la fin de la chaîne de prototypes avec `Foo.prototype = null`), mais dans presque tous les cas, il peut être remplacé par `undefined`.
+
diff --git a/doc/fr/function/arguments.md b/doc/fr/function/arguments.md
new file mode 100644
index 00000000..84a09ea1
--- /dev/null
+++ b/doc/fr/function/arguments.md
@@ -0,0 +1,118 @@
+## L'objet `arguments`
+
+Chaque portée "scope" de fonction en JavaScript peut accéder à la variable spéciale `arguments`.
+Cette variable contient une liste de tous les arguments qui ont été passés à la fonction.
+
+> **Remarque:** Si `arguments` a déjà été définie soit par une déclaration `var`
+> à l'intérieur de la fonction ou par un paramètre de fonction, l'objet `arguments` ne sera pas créé.
+
+L'objet `arguments` n'est **pas** un tableau `Array`. Même s'il a la sémantique d'un tableau - à savoir la propriété `length` (longueur) - il n'hérite pas de
+`Array.prototype` mais est en fait un `Object`.
+
+Pour cette raison, il n'est **pas** possible d'utiliser les méthodes de tableau standards comme `push`, `pop` ou `slice` sur `arguments`.
+Bien qu'itérer avec une boucle `for` fonctionne, il est nécessaire de convertir la variable `arguments` en un véritable `Array` pour pouvoir lui appliquer les fonctions de tableau `Array` standards.
+
+### Conversion à Array
+
+Le code ci-dessous va retourner un nouveau tableau `Array` contenant tous les éléments de l'objet `arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Cette conversion est **lente**, il n'est donc **pas** recommandé de l'utiliser dans des sections de code où la performance est critique.
+
+### Passage d'arguments
+
+Voici la méthode recommandée pour passer des arguments d'une fonction à une autre.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // faire qqch ici
+    }
+
+Une autre astuce consiste à utiliser à la fois `call` et `apply` pour transformer des méthodes - fonctions qui utilisent la
+valeur de `this` ainsi que leurs arguments - en des fonctions normales qui n'utilisent que leurs arguments.
+
+    function Person(first, last) {
+      this.first = first;
+      this.last = last;
+    }
+    
+    Person.prototype.fullname = function(joiner, options) {
+      options = options || { order: "western" };
+      var first = options.order === "western" ? this.first : this.last;
+      var last =  options.order === "western" ? this.last  : this.first;
+      return first + (joiner || " ") + last;
+    };
+    
+	// Créer une version non liée de "fullname", utilisable sur n'importe quel
+    // objet avec les propriétés 'first' et 'last' passées comme premier
+    // argument. Cette enveloppe n'aura pas besoin de changer si fullname
+    // change le nombre ou l'ordre des ses arguments.
+    Person.fullname = function() {
+      // résultat: Person.prototype.fullname.call(this, joiner, ..., argN);
+      return Function.call.apply(Person.prototype.fullname, arguments);
+    };
+    
+    var grace = new Person("Grace", "Hopper");
+    
+    // 'Grace Hopper'
+    grace.fullname();
+    
+    // 'Turing, Alan'
+    Person.fullname({ first: "Alan", last: "Turing" }, ", ", { order: "eastern" });
+
+
+### Paramètres formels et arguments indexés
+
+L'objet `arguments` crée des fonctions *getter* et *setter* à la fois pour ses propriétés et les paramètres formels de la fonction.
+
+Par conséquent, changer la valeur d'un paramètre formel va également modifier la valeur de la propriété correspondante sur l'objet `arguments`, et vice-versa.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+    
+        b = 4;
+        arguments[1]; // 4
+    
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Mythes et faits sur la performance
+
+Le seul moment où l'objet `arguments` n'est pas créé est quand il est déclaré comme un nom à l'intérieur d'une fonction ou l'un de ses paramètres formels. Le fait qu'il soit utilisé ou non n'est pas important.
+
+Les deux *getter* et *setter* sont toujours créé; et donc l'utilisation d'`arguments` n'a aucune incidence sur la performance.
+
+> **Remarque ES5:** Ces *getters* et *setters* ne sont pas créés en mode strict.
+
+Cependant, un cas va considérablement réduire la performance des moteurs JavaScript modernes.
+C'est le cas de l'utilisation de `arguments.callee`.
+
+    function foo() {
+        arguments.callee; // faire quelque chose avec cet objet de fonction
+        arguments.callee.caller; // et la fonction appelante
+    }
+    
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Seraient normalement inline...
+        }
+    }
+
+Dans le code ci-dessus, `foo` ne peut plus être [inline][1] car il a besoin de se connaitre lui-même et connaitre son appelant.
+Cela défait les gains possibles de performance qui découleraient d'inline, mais cela casse également l'encapsulation
+car la fonction peut maintenant être dépendante d'un contexte d'appel spécifique.
+
+Utiliser `arguments.callee` ou l'une de ses propriétés est **fortement déconseillé**.
+
+> **Remarque ES5:** En mode strict, `arguments.callee` jettera une erreur de type `TypeError`
+> car son utilisation est marquée comme obsolète "deprecated".
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
diff --git a/doc/fr/function/closures.md b/doc/fr/function/closures.md
new file mode 100644
index 00000000..50983db3
--- /dev/null
+++ b/doc/fr/function/closures.md
@@ -0,0 +1,97 @@
+## Fermetures et réferences
+
+Les *fermetures* "closures" sont une des fonctionnalités les plus puissantes de JavaScript.
+Avec les fermetures, les portées gardent **toujours** l'accès à la portée externe, dans laquelle elles ont été définies.
+Puisque la seule portée que JavaScript a est la [portée de fonction](#function.scopes), toutes les fonctions, par défaut, agissent comme des fermetures.
+
+### Simuler les variables privées
+
+    function Counter(start) { // compteur
+        var count = start; // compte
+        return {
+            increment: function() {
+                count++;
+            },
+            
+            get: function() {
+                return count;
+            }
+        }
+    }
+    
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+Ici, `Counter` retourne **deux** fermetures: la fonction` increment` ainsi que la fonction `get`. Ces deux fonctions conservent une **référence** à la portée de `Counter` et, par conséquent, gardent toujours l'accès à la variable `count` qui a été définie dans cette portée.
+
+### Comment marchent les variables privées
+
+Comme il ne est pas possible de référencer ou assigner des portées en JavaScript, il n'y a **aucun** moyen d'accéder à la variable `count` de l'extérieur.
+La seule façon d'interagir avec elle est par l'intermédiaire des deux fermetures.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+Le code ci-dessus ne va **pas** changer la variable `count` dans la portée de `Counter`, car `foo.hack` n'a pas été défini dans cette portée. En fait, une nouvelle variable va etre crée - ou va remplacer - la variable *globale* `count`.
+
+### Fermetures dans les boucles
+
+Une erreur souvent commise est d'utiliser les fermetures à l'intérieur de boucles comme si elles copiaient la valeur de la variable d'indice de la boucle.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+La programme ci-dessus ne vas **pas** produire les numéros `0` à `9`, il imprimera `10` dix fois.
+
+La fonction *anonyme* garde une **référence** à `i`. Au moment où `console.log` est appelée, la `boucle for` est déjà achevée, et donc la valeur de `i` est à `10`.
+
+Afin d'obtenir le comportement souhaité, il est nécessaire de créer une **copie** de la valeur de `i`.
+
+### Eviter le problème de référence
+
+Pour copier la valeur de la variable d'index de la boucle, il est préférable d'utiliser une [enveloppe anonyme](#function.scopes) "wrapper".
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+La fonction externe anonyme est appelée immédiatement avec `i` en tant que premier argument, et donc le paramètre `e` recevra une copie de la **valeur** de `i`.
+
+La fonction anonyme qui est passé à `setTimeout` a maintenant une référence à `e`, dont la valeur ne peut **pas** être changée par la boucle.
+
+Une autre façon de faire est de retourner une fonction de l'enveloppe anonyme qui aura alors le même comportement que le code ci-dessus.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+Une autre façon populaire d'achever le même comportement est d'ajouter un argument supplémentaire à la fonction `setTimeout`. La fonction passera ces arguments à la fonction de rappel "callback".
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function(e) {
+            console.log(e);  
+        }, 1000, i);
+    }
+
+Sachez que certains environnements JS (Internet Explorer 9 et avant) ne supportent pas cette dernière approche.
+
+Enfin, une dernière façon de faire et d'utiliser `bind`, qui peut lier le contexte `this` et les arguments pour la fonction.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
+
diff --git a/doc/fr/function/constructors.md b/doc/fr/function/constructors.md
new file mode 100644
index 00000000..e92dea93
--- /dev/null
+++ b/doc/fr/function/constructors.md
@@ -0,0 +1,109 @@
+## Constructeurs 
+
+Les constructeurs en JavaScript diffèrent de beaucoup d'autres langages.
+Tout appel de fonction précédé par le mot clé `new` agit comme un constructeur.
+
+Dans le constructeur - la fonction appelée - la valeur de `this` se réfère à un objet nouvellement créé.
+Le [prototype](#Object.prototype) de ce **nouvel** objet pointe sur le `prototype` de l'objet de fonction qui a été invoqué comme constructeur.
+
+Si la fonction qui a été appelée n'a pas de déclaration `return` explicite, elle renvoira implicitement la valeur de `this` - le nouvel objet.
+
+    function Person(name) {
+        this.name = name;
+    }
+    
+    Person.prototype.logName = function() {
+        console.log(this.name);
+    };
+    
+    var sean = new Person();
+
+Le code ci-dessus appelle `Person` en tant que constructeur et définit le `prototype` du nouvel objet créé à `Person.prototype`.
+
+En cas d'une déclaration `return` explicite, la fonction renvoie la valeur spécifiée par cette déclaration, mais **seulement** si cette valeur est un objet `Object`.
+
+    function Car() {
+        return 'ford';
+    }
+    new Car(); // un nouvel objet, pas 'ford'
+    
+    function Person() {
+        this.someValue = 2;
+    
+        return {
+            name: 'Charles'
+        };
+    }
+    new Test(); // l'objet retourné ({name:'Charles'}) n'inclue pas someValue
+
+Lorsque le mot clé `new` est omis, la fonction ne retournera **pas** un nouvel objet.
+
+    function Pirate() {
+        this.hasEyePatch = true; // this est l'object global!
+    }
+    var somePirate = Pirate(); // somePirate est undefined
+
+Bien que l'exemple ci-dessus a l'air de marcher, il utilisera l'*objet global* pour la valeur de `this`, en raison du fonctionnement particulier de [`this`](#function.this) en JavaScript.
+
+### Fabriques
+
+Pour pouvoir omettre le mot clé `new`, la fonction constructeur doit retourner explicitement une valeur.
+
+    function Robot() {
+        var color = 'gray';
+        return {
+            getColor: function() {
+                return color;
+            }
+        }
+    }
+    Robot.prototype = {
+        someFunction: function() {}
+    };
+    
+    new Robot();
+    Robot();
+
+Les deux appels à `Robot` retournent la même chose, un objet nouvellement créé qui possède une propriété appelée `getColor`, qui est une [fermeture](#function.closures) "closure".
+
+Il convient également de noter que l'appel `new Robot()` n'affecte **pas** le prototype de l'objet retourné.
+Bien que le prototype sera mis sur le nouvel objet créé, `Robot` ne retourne jamais cet objet.
+
+Dans l'exemple ci-dessus, il n'y a pas de différence fonctionnelle entre l'utilisation et la non-utilisation du mot clé `new`.
+
+### Creation de nouvels objects via fabriques
+
+Il est souvent recommandé de ne **pas** utiliser `new` car l'oublier peut conduire à des bugs.
+
+Pour créer un nouvel objet, il faut plutôt utiliser une fabrique qui va construire un nouvel objet.
+
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
+    
+        var milesPerGallon = 2;
+    
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
+        }
+    
+        car.getMPG = function() {
+            return milesPerGallon;
+        }
+    
+        return car;
+    }
+
+Bien que le code qui précède est robuste contre un mot clé `new` manquant et rend certainement
+l'utilisation de [variables privées](#function.closures) plus facile, il y a des inconvénients.
+
+ 1. Il utilise plus de mémoire car les objets créés ne partagent **pas** leurs méthodes avec un prototype.
+ 2. Pour hériter, la fabrique a besoin de copier toutes les méthodes de l'autre objet ou mettre l'autre objet sur le prototype du nouvel objet.
+ 3. Abandonner la chaîne de prototype à cause d'un mot clé `new` laissé de côté est contraire à l'esprit du langage.
+
+### En Conclusion
+
+Omettre le mot clé `new` peut conduire à des bugs, mais ce n'est certainement **pas** une raison d'abandonner l'utilisation des prototypes.
+En fin de compte il s'agit de savoir quelle solution est la mieux adaptée pour les besoins de l'application.
+Il est particulièrement important de choisir un style spécifique de création d'objet et toujours l'utiliser afin de rester *cohérent*.
+
diff --git a/doc/fr/function/general.md b/doc/fr/function/general.md
new file mode 100644
index 00000000..b6fe47ec
--- /dev/null
+++ b/doc/fr/function/general.md
@@ -0,0 +1,38 @@
+## Déclaration des fonctions et expressions
+
+Les fonctions en JavaScript sont des objets de première classe. Cela signifie qu'elles peuvent être passées comme toute autre valeur. Une utilisation courante de cette caractéristique est de passer une *fonction anonyme* comme une fonction de rappel "callback" qui peut être asynchrone.
+
+### La déclaration `function`
+
+    function foo() {}
+
+La fonction ci-dessus est [hissée](#function.scopes) "hoisted" avant le démarrage du programme; ainsi, elle est donc disponible partout dans la portée "scope" d'application où la fonction a été définie, même si appelé avant sa définition dans le code source.
+
+    foo(); // Fonctionne car foo a été crée avant l'exécution de ce code
+    function foo() {}
+
+### L'expresssion `function`
+
+    var foo = function() {};
+
+Cet exemple attribue une fonction *anonyme* et sans nom à la variable `foo`.
+
+    foo; // 'undefined'
+    foo(); // provoque un erreur de type TypeError
+    var foo = function() {};
+
+En raison du fait que `var` est une déclaration qui hisse le nom de la variable `foo` avant que l'exécution réelle du code ne commence, `foo` est déjà déclarée lorsque le script est exécuté.
+
+Mais comme les assignements ne se produisent qu'au moment de l'exécution, la valeur de `foo` sera par défaut mise à [undefined](#core.undefined) avant l'exécution du code.
+
+### L'expression de fonction nommée
+
+Un autre cas est l'attribution de fonctions nommées.
+
+    var foo = function bar() {
+        bar(); // Works
+    }
+    bar(); // erreur de reference ReferenceError
+
+Ici, `bar` n'est pas disponible dans la portée externe "outer scope", puisque la fonction est seulement assignée à `foo`, mais elle est disponible à l'intérieur de `bar`. Cela est dû à la méthode de [résolution de noms](#function.scopes) de JavaScript: le nom de la fonction est *toujours* disponible dans la portée locale "local scope" de la fonction elle-même.
+
diff --git a/doc/fr/function/scopes.md b/doc/fr/function/scopes.md
new file mode 100644
index 00000000..7cd1d0b3
--- /dev/null
+++ b/doc/fr/function/scopes.md
@@ -0,0 +1,204 @@
+## Portées "scopes" et espaces de noms "namespaces"
+
+Bien que JavaScript utilise une syntaxe avec accolades pour les blocs, il ne crée **pas** de portée "scope" de bloc; par conséquent, la seule portée du langage est la portée de fonction.
+
+    function test() { // une portée "scope"
+        for(var i = 0; i < 10; i++) { // pas une portée 
+            // count
+        }
+        console.log(i); // 10
+    }
+
+> **Remarque:** Lorsqu'elle n'est pas utilisé dans un assignement, une déclaration de retour,
+> ou un argument de fonction, la notation `{...}` sera interprétée comme une déclaration
+> de bloc et non **pas** comme un littéral d'objet. Ceci, quand combiné avec
+> l'[insertion automatique des points-virgules](#de core.semicolon), peut conduire à des erreurs subtiles.
+
+Il n'existe pas d'espaces de noms "namespaces" en JavaScript, ce qui signifie que tout est défini dans un espace de noms commun partagé par tous.
+
+Chaque fois qu'une variable est référencée, JavaScript va traverser vers le haut toutes les portées jusqu'à ce qu'il la trouve.
+S'il atteint la portée globale sans avoir trouvé le nom demandé, il va générer une erreur de référence `ReferenceError`.
+
+### Le fléau des variables globales
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+Les deux scripts ci-dessus n'ont **pas** le même effet. Le script A définit une variable appelée `foo` dans la portée *globale*, le script B définit `foo` dans la portée actuelle.
+
+Ne pas utiliser `var` peut avoir des répercussions majeures.
+
+    // portée globale
+    var foo = 42;
+    function test() {
+        // portée locale
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+En laissant de côté la déclaration `var` à l'intérieur de la fonction `test`, on remplace la valeur de `foo`.
+Même si au premier abord cela ne semble pas être une grosse affaire, des milliers de lignes de JavaScript qui n'utilisent pas `var` créeront des bogues horribles qui seront très difficiles à dépister.
+
+    // portée globale
+    var items = [/* some list */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+    
+    function subLoop() {
+        // portée de subLoop
+        for(i = 0; i < 10; i++) { // var manquant
+            // ici, des choses incroyables!
+        }
+    }
+
+La boucle externe se terminera après le premier appel à `subLoop`, car `subLoop` écrase la valeur globale de `i`.
+L'utilisation d'un `var` pour la deuxième boucle `for` aurait facilement évité cette erreur.
+La déclaration de `var` devrait **jamais** être laissé de côté, sauf si l'*effet désiré* est d'affecter la portée externe.
+
+### Variables locales
+
+Seuls les paramètres de [fonction](#function.general) et les variables déclarées avec un `var` peuvent créer des variables locales en JavaScript.
+
+
+    // portée globale
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+    
+    function test(i) {
+        // portée locale de la fonction test
+        i = 5;
+    
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+`foo` et `i` sont bien des variables locales à l'intérieur de la portée de la fonction `test`, mais l'assignment `bar` remplacera la variable globale portant le même nom.
+
+### Remontée "hoisting"
+
+JavaScript **hisse** les déclarations. Cela signifie que les déclarations de `var` et `function` seront déplacés vers le haut de leur portée englobante.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+    
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+    
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+Le code ci-dessus est transformé avant que l'exécution ne commence. JavaScript déplace les déclarations `var`, ainsi que les déclarations `function`, vers le haut de la portée la plus proche.
+
+    // les déclarations var sont maintenant ici
+    var bar, someValue; // mis à 'undefined' par défaut
+    
+    // les déclarations de fonction aussi
+    function test(data) {
+        var goo, i, e; // pas de portée de bloc,
+                       // donc déclarations var viennent ici
+        if (false) {
+            goo = 1;
+    
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+    
+    bar(); // échoue avec TypeError puisque bar est toujours 'undefined'
+    someValue = 42; // les assignements ne sont pas concernés par la remontée
+    bar = function() {};
+    
+    test();
+
+L'inexistence des portées de bloc va non seulement déplacer les déclarations `var` en dehors du corps des boucles, mais va aussi rendre les résultats de certaines constructions de `if` non-intuitifs.
+
+Dans le code original, la déclaration `if` semblait modifier la *variable globale* `goo`, alors qu'en fait elle modifiait la *variable locale* - après la remontée appliquée.
+
+Sans la connaissance du concept de *remontée*, on pourrait soupçonner que le code ci-dessous produirait une erreur de référence `ReferenceError`.
+
+    // verifie si SomeImportantThing a bien été initializé
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Le code fonctionne pourtant bien, car la déclaration de `var` est déplacé vers le haut de la *portée globale*.
+
+    var SomeImportantThing;
+    
+    // du code peut, ou pas, initializer SomeImportantThing ici
+    
+    // soyons en sûr
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Ordre de la résolution de noms
+
+Toutes les portées en JavaScript, y compris la *portée globale*, ont le nom spécial [`this`](#function.this) défini qui se réfère à l'*objet courant*.
+
+Les portées de fonction ont aussi le nom [`arguments`](#Function.arguments) défini qui contient les arguments qui ont été transmis à la fonction.
+
+Par exemple, lorsque vous essayez d'accéder à une variable nommé `foo` l'intérieur de la portée d'une fonction, JavaScript va chercher le nom dans l'ordre suivant:
+
+ 1. Si il y a une déclaration `var foo` var dans la portée courante, l'utiliser.
+ 2. Si l'un des paramètres de la fonction est nommé `foo`, l'utiliser.
+ 3. Si la fonction elle-même est appelée `foo`, l'utiliser.
+ 4. Sinon, accéder à la portée externe suivante, et recommencer à **#1** pour cette portée.
+
+**Remarque:** Avoir un paramètre appelé `arguments` va **empêcher** la création d'objet par défaut `arguments`.
+
+### Espaces de noms
+
+Le fait de n'avoir qu'un seul espace de noms global engendre un risque de conflit de noms de variables, un problème commun en JavaScript.
+En JavaScript, ce problème peut facilement être évité grâces aux *enveloppes anonymes*.
+
+    (function() {
+        // un "espace de nom" autonome
+        
+        window.foo = function() {
+            // une fermeture exposée
+        };
+
+    })(); // exécute la fonction immédiatement
+
+Les fonctions anonymes sont considérées comme des [expressions](#function.general); ainsi elles doivent d'abord être évaluées avant d'être appelées.
+
+    ( // évaluer la fonction à l'intérieur des parenthèses
+    function() {}
+    ) // et retourner la fonction object
+    () // appeler le résultat de l'évaluation
+
+Il y a d'autres façons d'évaluer et d'appeler directement l'expression de fonction qui, bien que différentes dans la syntaxe, se comportent de la même manière.
+
+	// Autres styles d'invocation directe
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // etc.
+
+### En conclusion
+
+Il est recommandé de toujours utiliser une *enveloppe anonyme* pour encapsuler du code dans son propre espace de noms.
+Non seulement cela protège des conflits de noms de code, cela permet également une meilleure modularisation des programmes.
+
+En outre, l'utilisation de variables globales est considéré comme une **mauvaise pratique**.
+Leur utilisation indique un code mal écrit, sujet à des erreurs, et difficile à maintenir.
+
diff --git a/doc/fr/function/this.md b/doc/fr/function/this.md
new file mode 100644
index 00000000..aed2301c
--- /dev/null
+++ b/doc/fr/function/this.md
@@ -0,0 +1,100 @@
+## Comment marche `this`
+
+Pour JavaScript, ce que le nom spécial `this` réfère à diffère de la plupart des autres langages de programmation. Il y a exactement **cinq** façons différente de lier la valeur de `this` dans le langage.
+
+### Le contexte global "global scope"
+
+    this;
+
+Lorsque vous utilisez `this` dans le contexte global, il va simplement référer à l'objet *global*.
+
+### Appel de fonction
+
+    foo();
+
+Ici, `this` va aussi référer à l'objet *global*.
+
+> **Remarque ES5:** En mode strict, le cas global **n'existe plus**: `this` aura la valeur `undefined`.
+
+### Appel de méthode
+
+    test.foo(); 
+
+Dans cet exemple, `this` va référer à `test`.
+
+### Appel de constructeur
+
+    new foo(); 
+
+Un appel de fonction qui est précédé par le mot clé `new` agit comme un [constructeur](#function.constructors). Dans la fonction, `this` va référer à un `Object` *nouvellement créé*.
+
+### Assignement direct de `this`
+
+    function foo(a, b, c) {}
+    
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // table va s'étendre comme ci-dessous
+    foo.call(bar, 1, 2, 3); // mène à: a = 1, b = 2, c = 3
+
+Lorsque vous utilisez les méthodes `call` (appeler) ou `apply` (appliquer) de `Function.prototype`, la valeur de `this` à l'intérieur de la fonction appelée est **directement définie** par le premier argument de l'appel correspondant.
+
+En conséquence, dans l'exemple ci-dessus le cas d'*appel de méthode* ne s'applique **pas**, et `this` à l'intérieur de `foo` va bien référer à `bar`.
+
+> **Remarque:** `this` ne peut **pas** être utilisé pour se référer à l'objet à l'intérieur d'un littéral `Object`.
+> Donc dans `var obj = {moi: this}`, `moi` ne vas **pas** référer à `obj`, puisque `this` ne reçoit une valeur que dans l'un des cinq cas énumérés.
+
+### Pièges communs
+
+Bien que la plupart de ces cas ont du sens, le premier cas peut être considéré comme une autre faute de design du langage, car il n'est **jamais** d'aucune utilité pratique.
+
+    Foo.method = function() {
+        function test() {
+            // this réfère à l'objet global
+        }
+        test();
+    };
+
+Une autre erreur souvent commise est que `this` l'intérieur de `test` se réfère à `foo`; ce qui n'est **pas** du tout le cas.
+
+Pour accéder à `foo` de l'intérieur de `test`, vous pouvez créer une variable locale à intérieur de `method` qui fait référence à `foo`.
+
+    Foo.method = function() {
+        var self = this;
+        function test() {
+            // Utilisez self au lieu de this ici
+        }
+        test();
+    };
+
+`self` est juste une variable normale, couramment utilisée pour référencer un `this` extérieur. Combiné avec des [fermetures](# function.closures) "closures", on peut l'utiliser pour passer les valeurs de `this`.
+
+À partir d'ECMAScript 5, l'utilisation de la méthode `bind` avec une fonction anonyme mène au même resultat:
+
+    Foo.method = function() {
+        var test = function() {
+            // maintenant, this réfère à Foo
+        }.bind(this);
+        test();
+    };
+
+### Assignement de méthodes
+
+Une autre chose qui ne marche **pas** en JavaScript est l'alias de fonction, ou l'**assignement** d'une méthode à une variable.
+
+    var test = someObject.methodTest;
+    test();
+
+En raison du premier des cinq cas, `test` agit maintenant comme un appel de fonction normal; par conséquent, `this` à l'intérieur de la fonction ne va plus référer à `someObject`.
+
+Bien que la liaison tardive "late binding" de `this` pouvait sembler comme une mauvaise idée au premier abord, c'est en fait grâce à cela que l'[héritage prototypique](#Object.prototype) fonctionne.
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+    
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+    
+    new Bar().method();
+
+Quand `method` est appelée d'une instance de `bar`, `this` va référer à cette même instance.
+
diff --git a/doc/fr/index.json b/doc/fr/index.json
new file mode 100644
index 00000000..9f1bf373
--- /dev/null
+++ b/doc/fr/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "Le Jardin de JavaScript",
+    "langTitle": "JavaScript Garden en Français",
+    "description": "Un guide des defauts et excentricités de JavaScript",
+    "sections": [
+        {
+            "title": "Introduction",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "Objets",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Fonctions",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Tableaux",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Types",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Cœur",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "Autres",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/fr/intro/index.md b/doc/fr/intro/index.md
new file mode 100644
index 00000000..71c6ac67
--- /dev/null
+++ b/doc/fr/intro/index.md
@@ -0,0 +1,36 @@
+## Introduction
+
+Le **Jardin de JavaScript** est une collection croissante de documentation liée aux aspects les plus excentriques du langage de programmation JavaScript. Il donne des conseils pour éviter les erreurs communes, les bugs subtils, ainsi que les problèmes de performance et de mauvaises pratiques, que les amateurs de JavaScript peuvent rencontrer dans leurs efforts d'apprentissage en profondeur du langage.
+
+Le Jardin de JavaScript ne cherche pas à vous enseigner JavaScript. Une connaissance préalable du langage est fortement recommandée afin de comprendre les sujets abordés dans ce guide. Veuillez vous référer à l'excellent [guide][1] du Mozilla Developer Network pour apprendre les rudiments du langage JavaScript.
+
+## Auteurs
+
+Ce guide est l'œuvre de deux charmants utilisateurs de [Stack Overflow][2]: [Ivo Wetzel][3] (écriture) et [Zhang Yi Jiang][4] (design).
+
+Actuellement maintenu par [Tim Ruffles](http://truffles.me.uk).
+
+## Collaborateurs
+
+- Trop nombreux pour être énumérés ici, [voir la liste des collaborateurs](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
+## Hébergement
+
+Le Jardin de JavaScript est hébergé sur GitHub, mais [Cramer Développement][7] nous soutient avec un mirroir à [JavaScriptGarden.info][8].
+
+## Licence
+
+Le Jardin de JavaScript est publié sous la [licence MIT][9] et hébergé sur [GitHub][10]. Si vous trouvez des erreurs ou fautes de frappe veuillez s'il vous plaît [déposer une question][11] ou une "pull request" sur le dépôt. Vous pouvez également nous trouver dans la [Salle JavaScript][12] sur Stack Overflow.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/fr/object/forinloop.md b/doc/fr/object/forinloop.md
new file mode 100644
index 00000000..afc1a2d5
--- /dev/null
+++ b/doc/fr/object/forinloop.md
@@ -0,0 +1,44 @@
+## La boucle `for in`
+
+Tout comme l'opérateur `in`, la boucle `for in` traverse la chaîne de prototypes lors de l'itération sur les propriétés d'un objet.
+
+> **Remarque:** La boucle `for in` n'itérera **pas** sur les propriétés qui
+> ont leur attribut `enumerable` à `false`; par exemple, la propriété `length` d'un tableau "array".
+
+    // Empoisonnement d'Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // imprime bar et moo
+    }
+
+Puisqu'il n'est pas possible de changer le comportement de la boucle `for in`, il est nécessaire de filtrer les propriétés indésirables à l'intérieur du corps de la boucle. Sous ECMAScript 3 et plus, cela se fait en utilisant la méthode [`hasOwnProperty`](#object.hasownproperty) de `Object.prototype`.
+
+Depuis ECMAScript 5, `Object.defineProperty` peut être utilisé avec `enumerable` mis à faux pour ajouter des propriétés à des objets (y compris `Object`) sans que ces propriétés soient énumérées. Il est raisonnable dans ce cas d'assumer que les propriétés énumérables ont été ajouté pour une raison, ce qui permet d'omettre les appels à `hasOwnProperty` qui réduisent la lisibilité du code. Dans du code de librairie, `hasOwnProperty` devrait toujours être utilisé car des propriétés énumérables pourraient résider sur la chaîne de prototypes sans qu'on le sache.
+
+> **Remarque:** Puisque la boucle `for in` traverse toujours la chaîne de prototypes complet, elle
+> deviendra plus lente avec chaque couche supplémentaire d'héritage ajoutée à un objet.
+
+### Filtrer avec `hasOwnProperty`
+
+    // le même foo qu'au dessus
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Cette version est la seule version correcte à utiliser avec les anciennes versions d'ECMAScript.
+L'utilisation de `hasOwnProperty` nous garantie que seulement `moo` sera imprimé.
+Quand `hasOwnProperty` n'est pas utilisé, les prototypes natifs - par exemple `Object.prototype` - qui ont peut-être été étendus, causeront probablement des erreurs.
+
+Avec les versions plus récentes d'ECMAScript, des propriétés non-dénombrables peuvent être définies avec `Object.defineProperty`, réduisant le risque d'itération sur les propriétés quand `hasOwnProperty` n'est pas utilisé. Néanmoins, il faut faire attention avec l'utilisation de vieilles librairies comme [Prototype][1] qui ne bénéficient pas des nouvelles fonctions d'ECMAScript. Dans ce cadre, écrire des boucles `for in` sans `hasOwnProperty` est garanti de causer des erreurs.
+
+### En conclusion
+
+Il est recommandé de **toujours** utiliser `hasOwnProperty` avec ECMAScript 3 ou moins, ou dans du code de librairie. Dans ces environnements, il ne faut jamais assumer que les prototypes natifs n'ont pas été étendus. Depuis ECMAScript 5, `Object.defineProperty` permet de définir les propriétés non-dénombrables et donc permet d'omettre les appels à `hasOwnProperty` dans le code de l'application.
+
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/fr/object/general.md b/doc/fr/object/general.md
new file mode 100644
index 00000000..afa2ea25
--- /dev/null
+++ b/doc/fr/object/general.md
@@ -0,0 +1,85 @@
+## Utilisation des objets et propriétés
+
+
+En JavaScript, tout agit comme un objet, à part deux exceptions: [`null`](#core.undefined) et [`undefined`](#core.undefined).
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Une méprise commune est que les littéraux numériques ne peuvent pas être utilisés comme objets, due à une imperfection de l'analyseur de JavaScript qui tente d'analyser la *notation à point* sur un nombre comme une virgule flottante.
+
+    2.toString(); // erreur de syntaxe SyntaxError
+
+Des solutions de contournement existent pour forcer les littéraux numériques à agir comme des objets.
+
+    2..toString(); // le second point est correctement reconnu
+    2 .toString(); // notez l'espace à gauche du point
+    (2).toString(); // 2 est évalué en premier
+
+### Objets comme type de données
+
+Les objets en JavaScript peuvent également être utilisés comme [*HashMaps*][1]; essentiellement, des propriétés nommées pointant sur des valeurs.
+
+En utilisant un littéral d'objet - notation `{}` - il est possible de créer un objet vide.
+Ce nouvel objet [hérite](#object.prototype) de `Object.prototype` et ne possède pas de [propriétés propres](#object.hasownproperty) définies.
+
+    var foo = {}; // un nouvel objet vide
+
+    // un nouvel objet avec une propriété 'test' à valeur 12
+    var bar = {test: 12};
+
+### Accéder aux propriétés
+
+Les propriétés d'un objet sont accessibles de deux façons, soit par la notation à point, soit par la notation à crochets.
+
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+    
+    var get = 'name';
+    foo[get]; // kitten
+    
+    foo.1234; // SyntaxError
+    foo['1234']; // cela marche
+
+Les deux notations fonctionnent presque pareil, la seule différence étant que la notation à crochet permet l'écriture des propriétés et l'utilisation des noms de propriété qui autrement mèneraient à une erreur de syntaxe.
+
+### Supprimer des propriétés
+
+La seule façon de supprimer une propriété d'un objet est d'utiliser l'opérateur `delete`.
+Mettre la propriété à `null` ou `undefined` ne supprime que la *valeur* associée à la propriété, et non pas la *propriété* elle-même.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+Les résultats du programme ci-dessus sont `bar undefined` et `foo null` - seul `baz` a été correctement supprimé.
+
+### Notation des clefs "keys"
+
+    var test = {
+        'case': 'Je suis un mot-clé, donc je dois etre écrit en tant que chaîne',
+        delete: 'Je suis un mot-clé, donc moi aussi' // erreur de syntaxe SyntaxError
+    };
+
+Les propriétés d'objet peuvent être écrites simplement telles quelles ou comme des chaînes "string". Une autre imperfection de l'analyseur de JavaScript, avant ECMAScript 5, provoquera une erreur de syntaxe `SyntaxError` dans le programme qui précède.
+
+Cette erreur vient du fait que `delete` est un *mot-clé*; et par conséquent, il doit être écrit comme une *chaîne* littérale pour s'assurer qu'il sera correctement interprété par les vieux moteurs JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/fr/object/hasownproperty.md b/doc/fr/object/hasownproperty.md
new file mode 100644
index 00000000..aa912107
--- /dev/null
+++ b/doc/fr/object/hasownproperty.md
@@ -0,0 +1,46 @@
+## `hasOwnProperty`
+
+Pour savoir si un objet possède une propriété définie, et non pas quelque part ailleurs sur sa [chaîne de prototype](#object.prototype), il est nécessaire d'utiliser la méthode `hasOwnProperty`, une méthode que tous les objets héritent d'`Object.prototype`.
+
+> **Remarque:** Il n'est **pas** suffisant de vérifier si une propriété est `undefined`,
+> car la propriété peut très bien exister, mais avec une valeur `undefined`.
+
+`hasOwnProperty` est la seule chose en JavaScript qui traite des propriétés **sans** traverser la chaîne de prototypes.
+
+    // Empoisonnement d'Object.prototype
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+    
+    foo.bar; // 1
+    'bar' in foo; // vrai
+    
+    foo.hasOwnProperty('bar'); // faux
+    foo.hasOwnProperty('goo'); // vrai
+
+Seulement `hasOwnProperty` donnera le résultat attendu et correct. Voir la section sur [les boucles `for in`](#object.forinloop) pour plus de détails sur l'utilisation de `hasOwnProperty` pour traverser les propriétés d'un objet.
+
+### `hasOwnProperty` en tant que propriété
+
+JavaScript ne protège pas le nom de la propriété `hasOwnProperty`; ainsi, la possibilité existe qu'un objet peut avoir une propriété avec ce nom, et il est donc nécessaire d'utiliser une méthode `hasOwnProperty` *externe* pour obtenir des résultats corrects.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+    
+    foo.hasOwnProperty('bar'); // toujours faux
+    
+    // Utiliser hasOwnProperty d'un autre object,
+    // et l'appeler avec foo assigné à 'this'
+    ({}).hasOwnProperty.call(foo, 'bar'); // vrai
+    
+	// Il est aussi possible d'utiliser hasOwnProperty
+    //du prototype d'Object
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // vrai
+
+### En conclusion
+
+Utiliser `hasOwnProperty` est la **seule** méthode fiable pour vérifier l'existence d'une propriété sur un objet. Il est recommandé d'utiliser `hasOwnProperty` pour itérer sur les propriétés des objets comme décrit dans la section sur [les boucles `for in`](#object.forinloop).
+
diff --git a/doc/fr/object/prototype.md b/doc/fr/object/prototype.md
new file mode 100644
index 00000000..c1a471aa
--- /dev/null
+++ b/doc/fr/object/prototype.md
@@ -0,0 +1,85 @@
+## Le prototype
+
+JavaScript n'utilise pas le modèle classique d'héritage, mais un modèle *prototypique*.
+
+Souvent considéré comme l'une des faiblesses de JavaScript, le modèle d'héritage prototypique est en fait plus puissant que le modèle classique. Par exemple, il est assez facile de construire un modèle classique à partir du modèle prototypique, tandis que l'inverse est une tâche beaucoup plus difficile à entreprendre.
+
+JavaScript étant le seul langage à héritage prototypique largement utilisé, s'adapter aux différences entre les deux modèles peut prendre du temps.
+
+La première différence majeure est que l'héritage en JavaScript utilise des *chaînes de prototypes*.
+
+> **Remarque:** Utiliser simplement `Bar.prototype = Foo.prototype` résultera aux deux objets
+> partageant le **même** prototype. Par conséquent, le changement du prototype d'un objet aura une 
+> incidence sur le prototype de l'autre ce qui, dans la plupart des cas, n'est pas l'effet désiré.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+    
+    function Bar() {}
+    
+    // Assigner le prototype de Bar à une nouvelle instance de Foo
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+    
+    // S'assurer que Bar est le constructeur
+    Bar.prototype.constructor = Bar;
+    
+    var test = new Bar(); // crée une nouvelle instance de bar
+    
+    // La chaîne de prototypes qui en résulte
+    test [instance of Bar]
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* etc. */ }
+
+Dans le code ci-dessus, l'objet `test` va hériter à la fois de `Bar.prototype` et de `Foo.prototype`; par conséquent, il aura accès à la fonction `method` qui était définie sur `Foo`. Il aura également accès à la propriété `value` de la **seule** instance de `Foo` qui est son prototype. Il est important de noter que le `new Bar()` ne crée **pas** une nouvelle instance de `Foo`, mais réutilise celui attribué à son prototype; ainsi, toutes les instances de `Bar` se partageront la **même** propriété `value`.
+
+> **Remarque:** Ne **pas** utiliser `Bar.prototype = Foo`, car il ne pointera pas vers
+> le prototype de `Foo` mais plutôt à l'objet-fonction `Foo`. donc, la
+> chaîne de prototypes ira sur `Function.prototype` et non pas sur `Foo.prototype`;
+> et donc, `method` ne sera pas disponible sur la chaîne de prototypes.
+
+### Recherche des propriétés
+
+Lors de l'accès aux propriétés d'un objet, JavaScript traversera la chaîne de prototypes **vers le haut** jusqu'à ce qu'il trouve une propriété avec le nom demandé.
+
+S'il atteint le sommet de la chaîne - à savoir `Object.prototype` - sans avoir trouvé la propriété spécifiée, la valeur [undefined](#core.undefined) sera retournée.
+
+### La propriété prototype
+
+Bien que la propriété prototype est utilisé par le langage pour construire la chaîne de prototypes, il est toujours possible de lui attribuer une valeur quelconque, mais les types primitifs seront simplement ignorés.
+
+    function Foo() {}
+    Foo.prototype = 1; // aucun effet
+
+Assigner des objets, comme le montre l'exemple ci-dessus, va marcher, et permet la création dynamique de chaînes de prototypes.
+
+### Performance
+
+Les temps de recherche pour des propriétés qui sont en haut de la chaîne de prototypes peuvent avoir un impact négatif qui être significatif pour du code où la performance est critique. Essayer d'accéder à des propriétés inexistantes causera toujours la traversée complète de la chaîne de prototypes.
+
+De plus, [itérer](#object.forinloop) sur les propriétés d'un objet va causer l'énumération de **toutes** les propriétés qui se trouve sur la chaîne de prototype.
+
+### Extension des prototypes natifs
+
+Une mauvaise technique souvent utilisée est d'étendre `Object.prototype` ou un des prototypes intégrés.
+
+Cette technique est appelée [monkey patching][1] et casse l'*encapsulation*. Bien qu'utilisée par des cadriciels "frameworks" populaires tels que [Prototype][2], il n'existe aucune bonne raison pour encombrer les types intégrés avec des fonctionnalités supplémentaires *non standards*.
+
+La **seule** bonne raison d'étendre un prototype intégré est le rétroportage de caractéristiques des nouveaux moteurs JavaScript; par exemple, [`Array.forEach`][3].
+
+### En conclusion
+
+Il est **essentiel** de comprendre le modèle d'héritage prototypique avant d'écrire du code complexe qui l'utilise. Soyez conscient de la longueur des chaînes de prototypes dans votre code; découpez les si nécessaire pour éviter de possible problèmes de performance. En outre, les prototypes natifs ne devraient **jamais** être étendus, sauf pour des raisons de compatibilité avec de nouvelles caractéristiques du langage JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/fr/other/timeouts.md b/doc/fr/other/timeouts.md
new file mode 100644
index 00000000..f06623e9
--- /dev/null
+++ b/doc/fr/other/timeouts.md
@@ -0,0 +1,130 @@
+### `setTimeout` et `setInterval`
+
+Puisque JavaScript est asynchrone, il est possible de programmer l'exécution future d'une fonction en utilisant les fonctions `setTimeout` et `setInterval`.
+
+> **Remarque:** Les temps d'attente "timeouts" ne font **pas** partie de la norme ECMAScript. Ils sont implémentés dans les [BOM ou DOM Niveau 0][1], qui ne ne sont ni définies ni documentés formellement.
+> Aucune spécification recommandée n'a été publiée jusqu'à présent, cependant, ils sont en voie de normalisation par [HTML5][2].
+> En raison de cela, l'implémentation peut varier entre navigateurs et moteurs.
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // retourne un nombre > 0
+
+Quand `setTimeout` est appelé, il renvoie l'identifiant de la temporisation et fixe la date de d'exécution de `foo` **approximativement** mille millisecondes dans le future. `foo` sera exécuté **une seule** fois.
+
+La résolution de l'horloge du moteur JavaScript exécutant le code, le fait que JavaScript est mono-thread, et la possibilité qu'autre code en cours d'exécution peut bloquer le fil "thread", font qu'il n'est **pas** possible de déterminer le temps exact d'attente spécifié dans l'appel `setTimeout`.
+
+La fonction passée en tant que premier paramètre sera appelé par l'*objet global*, ce qui signifie que [`this`](#function.this) à l'intérieur de la fonction appelée fait référence à l'objet global.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this réfère a l'boject global
+            console.log(this.value); // enregistre undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+> **Remarque:** Comme `setTimeout` prend un **objet fonction** comme premier paramètre, une erreur commune est d'écrire `setTimeout(foo(), 1000)`, qui utilisera la **valeur de retour** de l'appel `foo` et non **pas** `foo`. Cette erreur est, la plupart du temps, silencieuse, car lorsque la fonction retourne `undefined`, `setTimeout` ne produira **pas** d'erreur.
+
+### Empilement des appels avec `setInterval`
+
+`setTimeout` exécute la fonction une seule fois. `setInterval` - comme son nom le suggère - exécutera la fonction toutes les 'X' millisecondes, mais son utilisation est découragée.
+
+Lorsque que du code en cours d'exécution bloque la temporisation, `setInterval` continuera a émettre plusieurs appels à la fonction spécifiée. Cela peut, en particulier avec un petit intervalle, résulter à un empilement d'appels de fonction.
+
+    function foo(){
+        // qq chose qui bloque pendant 1 seconde
+    }
+    setInterval(foo, 100);
+
+Dans le code ci-dessus, `foo` sera appelé une fois et bloquera pendant une seconde.
+
+Pendant ce temps, `setInterval` va continuer à planifier les appels à la fonction. Quand `foo` se termine, il y aura déjà **dix** autres appels qui attendent pour s'exécuter.
+
+### Traiter le code bloquant éventuel
+
+La solution la plus simple et qui offre le plus de contrôle est d'utiliser `setTimeout` dans la fonction elle-même.
+
+    function foo(){
+        // qq chose qui bloque pendant 1 seconde
+        setTimeout(foo, 100);
+    }
+    foo();
+
+Non seulement cela encapsule l'appel `setTimeout`, mais il empêche également l'empilement des appels et donne un contrôle supplémentaire. La fonction `foo` elle-même peut maintenant décider si elle veut s'exécuter à nouveau ou non.
+
+### Effacer un délais d'attente
+
+L'effacement des délais d'attente et des intervalles fonctionne en transmettant l'identifiant retourné par la fonction `setTimeout` ou `setInterval` à `clearTimeout` ou `clearInterval`, respectivement.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Effacer tous les délais d'attente
+
+Comme il n'existe pas de méthode intégrée pour effacer tous les délais d'attente et/ou intervalles, il est nécessaire d'utiliser la force brute pour obtenir cette fonctionnalité.
+
+    // Effacement de "tous" les délais d'attente
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+Mais il pourrait encore y avoir des délais d'attente qui ne sont pas effacés par ce nombre arbitraire.
+Une autre façon de faire découle du fait que l'identifiant donné à un délai d'attente est incrémenté à chaque fois que vous appelez `setTimeout`.
+
+    // Effacement de "tous" les délais d'attente
+    var identifiantLePlusGrand = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= identifiantLePlusGrand; i++) {
+        clearTimeout(i);
+    }
+
+Même si cela fonctionne sur tous les principaux navigateurs d'aujourd'hui, il ne est pas précisé que les identifiants doivent être ordonnés de cette façon et cela peut changer. Par conséquent, il est plutôt recommandé de garder une trace de tous les identifiant crées, pour qu'ils puissent être effacées spécifiquement.
+
+### Utilisation cachée de `eval`
+
+`setTimeout` et `setInterval` peuvent également prendre une chaîne de caractères comme premier paramètre.
+Cette fonctionnalité ne devrait **jamais** être utilisée car elle utilise `eval` en interne.
+
+> **Remarque:** Les mécanismes précis pour quand une chaîne est passée peuvent différer entre les diverses implémentations de JavaScript.
+> Par exemple, JScript de Microsoft utilise le constructeur `Function` à la place de `eval`.
+
+    function foo() {
+        // sera appelé
+    }
+    
+    function bar() {
+        function foo() {
+            // ne sera jamais appelé
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Puisque `eval` n'est pas appelé [directement](#core.eval), la chaîne passé à `setTimeout` sera exécutée dans la *portée globale*; ainsi, la variable `foo` locale à `bar` ne sera pas utilisée.
+
+Il est aussi recommandé de ne **pas** utiliser une chaîne pour passer des arguments à la fonction qui sera appelée par l'une des fonctions de temporisation.
+
+    function foo(a, b, c) {}
+    
+    // ne JAMAIS faire cela
+    setTimeout('foo(1, 2, 3)', 1000)
+    
+    // utiliser plutôt une fonction anonyme
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+>**Remarque:** Bien qu'il soit également possible d'utiliser la syntaxe `setTimeout(foo, 1000, 1, 2, 3)`, elle n'est pas recommandée, car son utilisation peut entraîner des erreurs subtiles lorsqu'elle est utilisée avec des [méthodes](#function.this).
+>En outre, la syntaxe peut ne pas fonctionner dans certaines implémentations de JavaScript. Par exemple, Internet Explorer de Microsoft [ne passe **pas** les arguments directement à la fonction de rappel][3].
+
+### En conclusion
+
+Une chaîne ne devrait **jamais** être passée comme paramètre de `setTimeout` ou `setInterval` pour passer des arguments à la fonction appelée. C'est un clair signe de **mauvais** code. Il faut appeler une *fonction anonyme* qui se charge d'appeler la fonction réelle avec les arguments nécessaires.
+
+En outre, l'utilisation de `setInterval` doit être évitée car son programmateur n'est pas bloqué par le code en train de s'exécuter.
+
+[1]: http://www.nczonline.net/blog/2009/09/29/web-definitions-dom-ajax-and-more/ "Web definitions: DOM, Ajax, and more"
+[2]: http://www.w3.org/TR/2014/WD-html5-20140617/webappapis.html#timers "6 Web application APIs - HTML5"
+[3]: http://msdn.microsoft.com/en-us/library/ie/ms536753(v=vs.85).aspx "setTimeout method (Internet Explorer)"
diff --git a/doc/fr/types/casting.md b/doc/fr/types/casting.md
new file mode 100644
index 00000000..a0158f6b
--- /dev/null
+++ b/doc/fr/types/casting.md
@@ -0,0 +1,62 @@
+## Changements de types
+
+JavaScript est un langage *faiblement typé*, il appliquera la *coercition de type* partout où c'est possible.
+
+    // Ceux-ci sont vrais
+    new Number(10) == 10; // Objet Number est converti
+                          // en un nombre primitif via un appel implicite
+                          // à la méthode Number.prototype.valueOf
+    
+    10 == '10';           // Strings est converti en Number
+    10 == '+10 ';         // Encore aussi fou
+    10 == '010';          // Et encore
+    isNaN(null) == false; // null est converti en 0
+                          // ce qui, bien sûr, n'est pas NaN
+    
+    // Ceux-ci sont faux
+    10 == 010;
+    10 == '-10';
+
+> **Remarque ES5:** Les nombres littéraux qui commencent avec un '0' sont interprétés comme octal (Base 8). L'octal a été **retiré** dans ECMAScript 5 en mode stricte.
+
+Pour éviter les problèmes ci-dessus, l'utilisation de l'[opérateur d'égalité stricte](# types.equality) est **fortement** recommandé.
+Bien que cela évite beaucoup de pièges communs, il y en reste encore beaucoup. Tous ces pièges découlent de la faiblesse du système de typage de JavaScript.
+
+### Constructeurs de types internes
+
+Les constructeurs de types internes comme `Number` et `String` se comportent différemment suivant s'ils sont utilisés avec ou sans le mot clé `new`.
+
+    new Number(10) === 10;     // Faux, Object et Number
+    Number(10) === 10;         // Vrai, Number et Number
+    new Number(10) + 0 === 10; // Vrai, due à la reconversion implicite
+
+L'utilisation d'un type intégré comme `Number` en tant que constructeur va créer une nouvel objet `Number`. Mais sans le mot clé `new`, `Number` se comportera comme un convertisseur.
+
+De plus, passer des valeurs littérales ou des non-objets se traduira par encore plus de coercition de type.
+
+La meilleure option est de forcer **explicitement** le type à l'un des trois types possibles .
+
+### Forcer à String
+
+    '' + 10 === '10'; // vrai
+
+En faisant précéder une **chaîne vide**, une valeur peut facilement être converti en une chaîne.
+
+### Forcer à Number
+
+    +'10' === 10; // vrai
+
+L'utilisation de l'opérateur **plus unaire** converti une valeur en nombre.
+
+### Forcer à Boolean
+
+L'utilisation double de l'opérateur **non** converti une valeur en booléen.
+
+    !!'foo';   // vrai
+    !!'';      // faux
+    !!'0';     // vrai
+    !!'1';     // vrai
+    !!'-1'     // vrai
+    !!{};      // vrai
+    !!true;    // vrai
+
diff --git a/doc/fr/types/equality.md b/doc/fr/types/equality.md
new file mode 100644
index 00000000..3c1c09dd
--- /dev/null
+++ b/doc/fr/types/equality.md
@@ -0,0 +1,58 @@
+## Égalité et comparaisons
+
+JavaScript a deux façons de comparer les valeurs des objets pour égalité.
+
+### L'opérateur d'égalité
+
+L'opérateur d'égalité se compose de deux signes égal: `==`.
+
+JavaScript est un langage au *typage faible* "weak typing". Cela signifie que l'opérateur d'égalité va convertir les deux opérandes en un même type afin de les comparer.
+    
+    ""           ==   "0"           // faux
+    0            ==   ""            // vrai
+    0            ==   "0"           // vrai
+    false        ==   "false"       // faux
+    false        ==   "0"           // vrai
+    false        ==   undefined     // faux
+    false        ==   null          // faux
+    null         ==   undefined     // vrai
+    " \t\r\n"    ==   0             // vrai
+
+Le tableau ci-dessus montre les résultats de la coercition de type, et c'est la raison principale pourquoi l'utilisation de `==` est largement considéré comme une mauvaise pratique. Les règles de conversion de types compliquées introduisent des bogues difficiles à dépister.
+
+### L'opérateur d'égalité stricte
+
+L'opérateur d'égalité stricte se compose de **trois** signes égal: `===`. 
+
+Il fonctionne comme l'opérateur d'égalité normale, sauf que l'égalité stricte ne converti **pas** le types de ses opérandes.
+
+    ""           ===   "0"           // faux
+    0            ===   ""            // faux
+    0            ===   "0"           // faux
+    false        ===   "false"       // faux
+    false        ===   "0"           // faux
+    false        ===   undefined     // faux
+    false        ===   null          // faux
+    null         ===   undefined     // faux
+    " \t\r\n"    ===   0             // faux
+
+Les résultats ci-dessus sont beaucoup plus clairs et permettent la rupture précoce de code.
+Cela durcit le code jusqu'à un certain degré, et améliore la performance dans le cas où les opérandes sont de types différents.
+
+### Comparaison d'objets
+
+Bien que `==` et `===` sont appelés **opérateurs d'égalité**, ils se comportent différement quand au moins un des opérandes est un objet `Object`.
+
+    {} === {};                   // faux
+    new String('foo') === 'foo'; // faux
+    new Number(10) === 10;       // faux
+    var foo = {};
+    foo === foo;                 // vrai
+
+En effet, les deux opérateurs comparent l'**identité** et non pas l'**égalité**. Autrement dit, ils comparent pour la même **instance** de l'objet, tout comme `is` en Python, ou la comparaison de pointeur en C.
+
+### En conclusion
+
+Il est fortement recommandé de n'utiliser que l'opérateur d'**égalité stricte**. Dans les cas où les types ont à être convertis, cela devraient être fait [explicitement](#types.casting) et non pas laissé aux règles complexes de coercition de type du langage.
+
+
diff --git a/doc/fr/types/instanceof.md b/doc/fr/types/instanceof.md
new file mode 100644
index 00000000..ba733e43
--- /dev/null
+++ b/doc/fr/types/instanceof.md
@@ -0,0 +1,35 @@
+## L'opérateur `instanceof`
+
+L'opérateur `instanceof` (instance de) compare les constructeurs de ses deux opérandes. Il est seulement utile pour comparer des objets faits sur mesure. Utilisé sur les types intégrés, il est
+aussi inutile que l'[opérateur typeof](# types.typeof).
+
+### Comparer des objets personnalisés
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+    
+    new Bar() instanceof Bar; // vrai
+    new Bar() instanceof Foo; // vrai
+    
+    // Ceci définit simplement Bar.prototype à l'objet de fonction Foo,
+    // mais pas à une instance réelle de Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // faux
+
+### Utiliser `instanceof` avec des types natifs
+
+    new String('foo') instanceof String; // vrai
+    new String('foo') instanceof Object; // vrai
+
+    'foo' instanceof String; // faux
+    'foo' instanceof Object; // faux
+
+Une chose importante à noter ici est que `instanceof` ne fonctionne pas sur les objets qui proviennent de différents contextes JavaScript (par exemple, différents documents
+dans un navigateur web), car leurs constructeurs ne seront pas exactement le même objet.
+
+### En conclusion
+
+L'opérateur `instanceof` devrait **seulement** être utilisé sur des objets crées sur mesure provenant du même contexte JavaScript.
+Tout comme l'opérateur [`typeof`](#types.typeof), chaque autre utilisation de celui-ci devrait être **évitée**.
+
diff --git a/doc/fr/types/typeof.md b/doc/fr/types/typeof.md
new file mode 100644
index 00000000..186bfb32
--- /dev/null
+++ b/doc/fr/types/typeof.md
@@ -0,0 +1,66 @@
+## L'opérateur `typeof`
+
+L'opérateur `typeof` (avec [`instanceof`](#types.instanceof)) est probablement le plus grand défaut de design de JavaScript, car il est presque **complètement cassé**.
+
+Bien que `instanceof` (instance de) a quelques utilisations limitées, `typeof` (type de) n'a qu'un seul cas pratique d'utilisation, et ce cas n'est **pas** la vérification du type d'un objet.
+
+> **Remarque:** Alors que `typeof` peut être appelé comme une fonction, i.e. `typeof(obj)`, ce n'est pas un appel de fonction.
+> Les parenthèses se comportent comme d'habitude et la valeur de retour sera utilisé comme opérande de l'opérateur `typeof`. La *fonction* `typeof` n'existe pas.
+
+### table de types JavaScript
+
+    Valeur              Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function pour Nitro/V8)
+    new RegExp("meow")  RegExp     object (function pour Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+Dans la table ci-dessus, *Type* se réfère à la valeur retournée pas l'opérateur `typeof`, et comme on peut le voir clairement, cette valeur est incohérente.
+
+*Class* se réfère à la valeur de la propriété interne `[[Class]]` d'un objet.
+
+> **D'après la spécification:** La valeur de `[[Class]]` peut être l'une des chaînes suivantes: `Arguments`, `Array`, `Boolean`, `Date`, `Error`, `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+Pour récupérer la valeur de `[[Class]]`, on peut utiliser la méthode `toString` de `Object.prototype`.
+
+### La classe d'un objet
+
+La spécification donne exactement un moyen d'accéder à la valeur `[[Class]]`: via `Object.prototype.toString`.
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // vrai
+    is('String', new String('test')); // vrai
+
+Dans l'exemple ci-dessus, `Object.prototype.toString` est appelé avec la valeur [this](#function.this) pointant sur l'objet dont on cherche a récupérer la valeur de `[[Class]]`.
+
+> **Remarque ES5:** Pour plus de commodité la valeur de retour de `Object.prototype.toString` de `null` et `undefined` a été **changée** de `Object` à `Null` et `Undefined` avec ECMAScript 5.
+
+### Test pour les variables indéfinies
+
+    typeof foo !== 'undefined'
+
+Ce qui précède vérifie si `foo` a été effectivement déclarée. Juste référencer la variable résulterait en une erreur de référence `ReferenceError`. C'est la seule chose pour laquelle  `typeof` est réellement utile.
+
+### En conclusion
+
+Pour vérifier le type d'un objet, il est fortement recommandé d'utiliser `Object.prototype.toString` parce que c'est le seul moyen fiable de le faire.
+Comme représenté dans la table de type ci-dessus, certaines valeurs de retour de `typeof` ne sont pas définies dans la spécification; et donc, elles peuvent différer entre les implémentations.
+
+If faut éviter d'utiliser `typeof`, sauf pour vérifier si une variable est définie.
+
diff --git a/doc/hu/array/constructor.md b/doc/hu/array/constructor.md
new file mode 100644
index 00000000..57a5a9ca
--- /dev/null
+++ b/doc/hu/array/constructor.md
@@ -0,0 +1,34 @@
+## Az `Array` konstruktor
+
+Mivel az `Array` konstruktora kétértelműen bánik a paraméterekkel, melegen
+ajánlott mindig a tömb literált - `[]` jelölés - használni új tömbök létrehozásakor.
+
+    [1, 2, 3]; // Eredmény: [1, 2, 3]
+    new Array(1, 2, 3); // Eredmény: [1, 2, 3]
+
+    [3]; // Eredmény: [3]
+    new Array(3); // Eredmény: []
+    new Array('3') // Eredmény: ['3']
+
+Abban az esetben, ha ez a konstruktor csak egy `szám` paramétert kap, akkor
+visszatérési értékül egy olyan tömböt fog létrehozni amelynek a `length` mezője
+akkorára van beállítva, ahogy azt megadtuk az argumentumban. Megjegyzendő hogy
+**csak** a `length` tulajdonság lesz ekkor beállítva; az egyes indexek külön-külön
+nem lesznek inicializálva.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // hamis, nincs ilyen index
+
+A tömb hosszának közvetlen állítása amúgy is csak elég kevés esetben
+használható értelmesen, mint például alább, hogyha el akarjuk kerülni a 
+`for ciklus` használatát egy string ismétlésekor.
+
+    new Array(count + 1).join(ismetlendoString);
+
+### Összegzésül
+
+Az `Array` konstruktor közvetlen használata erősen kerülendő. A literálok használata
+elfogadott inkább, mivel rövidebbek, tisztább a szintaxisuk és olvashatóbb kódot
+eredményeznek.
+
diff --git a/doc/hu/array/general.md b/doc/hu/array/general.md
new file mode 100644
index 00000000..f7fa98e4
--- /dev/null
+++ b/doc/hu/array/general.md
@@ -0,0 +1,58 @@
+## Tömb iteráció és tulajdonságok
+
+Habár a tömbök a JavaScriptben objektumok, nincsen jó ok arra, hogy a [`for in`](#object.forinloop) ciklussal járjuk be őket. 
+Valójában sokkal több jó ok van arra, hogy **miért ne** így tegyünk.
+
+> **Megjegyzés:** A JS tömbök **nem** *asszociatív tömbök*. A JavaScriptben egyedül
+> az [objektumokkal](#object.general) lehet kulcsokat értékekhez rendelni. Ráadásul
+> amíg az asszociatív tömbök **megőrzik** a sorrendjüket, az objektumok **nem**.
+
+Mivel a `for in` ciklus a prototípus láncon levő összes tulajdonságon végigmegy,
+és mivel az egyetlen út ennek megkerülésére a [`hasOwnProperty`](#object.hasownproperty) használata, így majdnem **hússzor** 
+lassabb mint egy sima `for` ciklus.
+
+### Iteráció
+
+Annak érdekében, hogy a legjobb teljesítményt érjük el a tömbökön való iteráció során,
+a legjobb hogyha a klasszikus `for` ciklust használjuk.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Még egy érdekesség van a fenti példában, ami a tömb hosszának cachelését végzi
+a `l = list.length` kifejezés használatával.
+
+Habár a `length` tulajdonság mindig magán a tömbön van definiálva, még mindig
+lehet egy kis teljesítmény kiesés amiatt hogy minden iterációban újra meg kell
+keresni ezt a tulajdonságot. Persze a legújabb JavaScript motorok **talán**
+használnak erre optimalizációt, de nem lehet biztosan megmondani, hogy ahol a kódunk
+futni fog, az egy ilyen motor-e vagy sem.
+
+Valójában, a cachelés kihagyása azt eredményezheti, hogy a ciklusunk csak 
+**fele olyan gyors** lesz mintha a cachelős megoldást választottuk volna.
+
+### A `length` mező
+
+Míg a `length` mező *getter* függvénye egyszerűen csak visszaadja a tömbben
+levő elemek számát, addig a *setter* függvény használható arra (is), hogy
+**megcsonkítsuk** a tömbünket.
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo.push(4);
+    foo; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Egy rövidebb hossz alkalmazása csonkítja a tömböt. A nagyobb hossz megadása
+értelemszerűen növeli.
+
+### Összegzésül
+
+A megfelelő teljesítmény érdekében, a `for` ciklus használata és a length cachelése
+ajánlott. A `for in` ciklus használata a tömbökön a rosszul megírt kód jele, amely
+tele lehet hibákkal, és teljesítményben sem jeleskedik.
+
diff --git a/doc/hu/core/delete.md b/doc/hu/core/delete.md
new file mode 100644
index 00000000..89b95b41
--- /dev/null
+++ b/doc/hu/core/delete.md
@@ -0,0 +1,91 @@
+## A `delete` Operátor
+
+Röviden, *lehetetlen* globális változókat, függvényeket és olyan dolgokat törölni
+JavaScriptben amelyeknek a `DontDelete` attribútuma be van állítva.
+
+### Globális kód és Függvény kód
+
+Amikor egy változó/függvény, globális vagy 
+[függvény hatókörben](#function.scopes) van definiálva, 
+akkor az vagy az Aktivációs (Activation) vagy a Globális (Global) objektum egyik mezőjeként
+jön létre.  Az ilyen mezőknek van egy halom attribútuma, amelyek közül az egyik 
+a `DontDelete`. A változó és függvény deklarációk a globális vagy függvény kódon
+belül mindig `DontDelete` tulajdonságú mezőket hoznak létre, így nem lehet őket
+törölni.
+
+    // globális változó
+    var a = 1; // A DontDelete be lett állítva
+    delete a; // hamis
+    a; // 1
+
+    // függvény:
+    function f() {} // A DontDelete be lett állítva
+    delete f; // hamis
+    typeof f; // "function"
+
+    // új értékadással sem megy
+    f = 1;
+    delete f; // hamis
+    f; // 1
+
+### Explicit mezők
+
+Az expliciten beállított mezőket persze normálisan lehet törölni.
+
+    // expliciten beállított mező
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // igaz
+    delete obj.y; // igaz
+    obj.x; // undefined
+    obj.y; // undefined
+	
+
+A fenti példában az `obj.x` és `obj.y` törölhető, mivel nincs `DontDelete`
+attribútuma egyik mezőnek sem. Ezért működik az alábbi példa is.
+
+    // működik, kivéve IE-ben
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // igaz - egy globális változó
+    delete GLOBAL_OBJECT.a; // igaz
+    GLOBAL_OBJECT.a; // undefined
+
+Itt egy trükköt használunk az `a` törlésére. A [`this`](#function.this) itt 
+a Globális objektumra mutat, és expliciten bevezetjük rajta az `a` változót, mint
+egy mezőjét, így törölni is tudjuk.
+
+Mint az szokás, a fenti kód egy kicsit bugos IE-ben (legalábbis 6-8-ig).
+
+### Függvény argumentumok és beépített dolgaik
+
+A függvény argumentumok, az [`arguments` objektum](#function.arguments)
+és a beépített mezők szintén `DontDelete` tulajdonságúak.
+
+    // függvény argumentumok és mezők
+    (function (x) {
+    
+      delete arguments; // hamis
+      typeof arguments; // "object"
+      
+      delete x; // hamis
+      x; // 1
+      
+      function f(){}
+      delete f.length; // hamis
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Vendég (host) objektumok
+
+A `delete` operátor működése megjósolhatatlan a vendég objektumokra. A specifikáció
+szerint ezek az objektumok szükség szerint bármilyen viselkedést implementálhatnak.
+
+(A ford.: Vendég objektumok azok az objektumok, amelyek nincsenek konkrétan
+meghatározva az ES aktuális verziójú specifikációjában, pl. a window)
+
+### Összegzésképp
+
+A `delete` működése helyenként megjósolhatatlan, így biztonsággal csak olyan
+objektumok mezőin használhatjuk, amelyeket expliciten mi állítottunk be.
\ No newline at end of file
diff --git a/doc/hu/core/eval.md b/doc/hu/core/eval.md
new file mode 100644
index 00000000..9de5d3b3
--- /dev/null
+++ b/doc/hu/core/eval.md
@@ -0,0 +1,49 @@
+## Miért Ne Használjuk az `eval`-t
+
+Az `eval` (evil) funkció egy stringbe ágyazott JavaScript kódot futtat a 
+lokális scopeon belül.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+	
+Viszont az `eval` csak akkor viselkedik így, hogyha expliciten hívjuk meg
+*és* a meghívott funkció neve valóban `eval`.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+Az `eval` használata kerülendő. A "felhasználása" az esetek 99.9%-ban 
+**mellőzhető**.
+    
+### Az `eval` ezer arca
+
+A `setTimeout` és `setInterval` nevű [timeout függvények](#other.timeouts) is
+tudnak úgy működni, hogy első paraméterükként egy stringbe ágyazott kódot várnak.
+Ez a string **mindig** a globális hatókörben lesz végrehajtva, mivel az `eval`t
+így nem direktben hívjuk meg.
+
+### Biztonsági problémák
+
+Az `eval` azért is veszélyes, mert **bármilyen** JS kódot végrehajt, amit odaadunk
+neki. Éppen ezért **sose** használjuk olyan kódok végrehajtására amiknek az eredete
+nem megbízható/ismeretlen.
+
+### Összegzésül
+
+Soha ne használjunk `eval`t. Bármilyen kód működése, teljesítménye, ill. biztonsága
+megkérdőjelezhető, amely használja ezt a nyelvi elemet. Semmilyen megoldás
+használata **nem ajánlott** amely első sorban `eval`ra épül. Ekkor egy *jobb
+megoldás* szükségeltetik, amely nem függ az `eval`tól.
\ No newline at end of file
diff --git a/doc/hu/core/semicolon.md b/doc/hu/core/semicolon.md
new file mode 100644
index 00000000..fddd1acf
--- /dev/null
+++ b/doc/hu/core/semicolon.md
@@ -0,0 +1,119 @@
+## Automatic Semicolon Insertion
+
+Bár a JavaScriptnek látszólag C-s szintaxisa van, **mégsem** kötelező benne
+kirakni a pontosvesszőket, így (helyenként) kihagyhatóak a forrásból.
+(A ford.: hiszen interpretált nyelv lévén nincsenek fordítási hibák, így 
+nyelvi elemek meglétét sem tudja erőltetni a nyelv)
+
+Itt jön a csel, hogy ennek ellenére a JavaScript csak pontosvesszőkkel
+értelmezi megfelelően a beírt kódot. Következésképp, a JS **automatikusan**
+illeszti be a pontosvesszőket (megpróbálja kitalálni a gondolataink) 
+azokra a helyekre, ahol amúgy emiatt értelmezési hibába futna.
+
+    var foo = function() {
+    } // értelmezési hiba, pontosvessző kéne
+    test()
+
+Az automatikus beillesztés megtörténik, ezután így értelmeződik a kód
+
+    var foo = function() {
+    }; // nincs hiba, mindenki örül
+    test()
+
+Az automatikus beillesztés (ASI) a JavaScript (egyik) **legnagyobb** design
+hibája, mivel igen... *meg tudja* változtatni a kód értelmezését
+
+### Hogyan Működik
+
+Az alábi kódban nincsen pontosvessző, így az értelmező (parser) feladata kitalálni,
+hogy hova is illessze be őket.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'hosszú string az argumentumban',
+                'még még még még még hossszabbbbbbb'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Alább mutatjuk a "kitalálós" játék eredményét.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Nincs beillesztés, a sorok össze lettek vonva
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- beillesztés
+
+            options.value.test(
+                'hosszú string az argumentumban',
+                'még még még még még hossszabbbbbbb'
+            ); // <- beillesztés
+
+            return; // <- beillesztés, eltörik a return kifejezésünk
+            { // blokként értelemződik
+
+                // név: kifejezés formátumban értelmeződik
+                foo: function() {} 
+            }; // <- beillesztés
+        }
+        window.test = test; // <- beillesztés
+
+    // Ezeket a sorokat összeilleszti
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- beillesztés
+
+    })(window); //<- beillesztés
+
+> **Megjegyzés:** A JavaScript értelmező nem tudja "korrektül" kezelni azokat
+> a return kifejezéseket, amelyek után közvetlen új sor áll. Habár ez nem biztos hogy 
+> szükségszerűen az ASI hibájából történik, azért nem egy túl kellemes mellékhatás.
+
+Az értelmező drasztikusan megváltoztatta a fenti kódot. A legtöbb esetben a 
+beillesztő **rosszul** tippel.
+
+(A ford.: Semmilyen nyelvben sem jó, hogyha hagyjuk hogy a gép találja ki mit
+szerettünk volna írni. Néma gyereknek az anyja sem érti a kódját ugye.)
+
+### Kezdő Zárójelek
+
+Az értelmező **nem** rak be új pontosvesszőt, hogyha a sor eleje (nyitó) zárójellel kezdődik.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Ez a kód egy sorként értelmeződik
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+Az esélyek arra **elég** magasak, hogy a `log` **nem** egy függvényt fog visszatéríteni; így a fenti kód egy `TypeError` típusú hibát fog dobni 
+`undefined is not a function` üzenettel.
+
+### Összefoglalásképp
+
+Szükségszerűen **soha** ne hagyjuk ki a pontoszvesszőket. Nem árt a kapcsos
+zárójeleket is ugyanazon a soron tartani, mint amelyiken az utasítást elkezdtük,
+így nem ajánlott az egysoros `if` / `else` kifejezések kedvéért elhagyni
+őket. Ezek a szempontok nem csak a kódot (és annak olvashatóságát) tartják
+konzisztensen, de megelőzik azt is hogy a JavaScript értelmező valamit rosszul
+"találjon ki".
\ No newline at end of file
diff --git a/doc/hu/core/undefined.md b/doc/hu/core/undefined.md
new file mode 100644
index 00000000..316feb14
--- /dev/null
+++ b/doc/hu/core/undefined.md
@@ -0,0 +1,77 @@
+## Az `undefined` és a `null`
+
+A JavaScript két értéket is tartogat a semmi kifejezésére, ezek a `null` és az
+`undefined` és ezek közül az utóbbi a hasznosabb.
+
+### Az `undefined`
+
+Ha az előbbi bevezetőtől nem zavarodtál volna össze; az 
+`undefined` egy típus amelynek pontosan egy értéke van, az `undefined`.
+
+A nyelvben szintén van egy `undefined` nevű globális változó amelynek az értékét
+hogy-hogy nem `undefined`-nak hívják. Viszont ez a változó **nem** konstans vagy
+kulcsszó a nyelvben. Ez azt jeletni hogy az *értéke* könnyedén felülírható.
+
+> **ES5 Megjegyzés:** Az `undefined` ECMAScript 5-ben **többé** *nem felülírható* 
+> strict módban, bár a neve továbbra is eltakarható, például egy saját függvénnyel
+> aminek a neve éppen `undefined`.
+
+Itt van pár példa, hogy mikor is találkozhatunk az `undefined` értékkel:
+ 
+ - Az `undefined` globális változó elérésekor
+ - Egy deklarált, de nem inicializált változó elérésekor.
+ - Egy függvény hívásakor ez a visszatérési érték, `return` utasítás híján.
+ - Egy olyan `return` utasítás lefutásakor, amely nem térít vissza értéket.
+ - Nem létező mezők lekérésekor.
+ - Olyan függvény paraméterek elérésekor amelyeknek a hívó oldalon nem kaptak értéket.
+ - Bármikor amikor az `undefined` érték van valaminek beállítva.
+ - Bármelyik `void(kifejezés)` utasítás futtatásakor.
+
+###  `undefined` megőrzési trükkök
+
+Mivel az `undefined` nevű globális változó csak egy másolatot tárol az 
+`undefined` elnevezésű értékből, az értékének megváltoztatása **nem** írja
+felül az eredeti `undefined` *típus* értékét.
+
+Ezért, ha valamilyen értékkel össze szeretnénk hasonlítani az `undefined` értéket,
+nem árt hogyha először magát az `undefined`-ot el tudjuk érni.
+
+Egy gyakori technika annak érdekében hogy megvédjük a kódunkat az 
+`undefined` lehetséges felüldefiniálásaitól, hogy egy [névtelen (wrapper)](#function.scopes) függvénybe
+csomagoljuk az egész kódunkat, amelynek lesz egy direkt üres paramétere.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // az undefined ebben a hatókörben 
+        // megint valóban az `undefined` értékre referáll.
+
+    })('Hello World', 42);
+
+Egy másik módja ennek, hogy használunk egy "üres" deklarációt a wrapper függvényen
+belül.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+Az egyetlen különbség ebben a változatban, hogyha minifikáljuk ezt a kódot,
+és nem definiálunk további változókat ezen a részen belül, akkor ezzel a
+változattal extra 4 byte "veszteséget" szenvedünk el.
+
+### Mikor használjunk `null`t
+
+Miközben az `undefined` a natív JavaScript megvalósításokban inkább a (más 
+nyelvekben levő) tradícionális *null* helyett használandó, azalatt maga a `null` 
+inkább csak egy különböző adattípusnak számít, mindenféle különös jelentés nélkül.
+
+Egy pár belső JavaScriptes megoldásban ugyan használják (ahol pl. a prototípus lánc végét a `Foo.prototype = null` beállítással jelölik), de a legtöbb esetben ez
+felcserélhető az `undefined`-al.
+
+(A ford.: A `null` annak az esetnek a jelölésére hasznos, amikor
+egy referencia típusú változót deklarálunk, de még nem adunk neki értéket. Pl. a 
+`var ezObjektumLesz = null` kifejezés ezt jelöli. Tehát a null leginkább
+kezdeti értékként állja meg a helyét, minden másra ott az `undefined`)
+
diff --git a/doc/hu/function/arguments.md b/doc/hu/function/arguments.md
new file mode 100644
index 00000000..0a0a1e6f
--- /dev/null
+++ b/doc/hu/function/arguments.md
@@ -0,0 +1,120 @@
+## Az `arguments` objektum
+
+Minden függvényhatókörben hozzáférhető az `arguments` nevű speciális változó,
+amely azon argumentumok listáját tartalmazza, amelyekkel a függvényt meghívták.
+
+> **Megjegyzés:** Abban a trükkös esetben, hogyha a függvényhatókörön belül valahogy
+> definiáljuk az `arguments`-et mint nevet, akár változóként (`var`ral), vagy a függvény 
+> paramétereként, akkor ez a speciális `arguments` objektum nem lesz létrehozva.
+
+Lehet hogy úgy néz ki, de az `arguments` objektum **nem** egy `tömb`. Látszólag hasonlít rá,
+mivel van például egy `length` nevű mezője, de igazából nem az `Array.prototype`-ból "származik",
+hanem tisztán az `Object`-ből.
+
+Itt jön a trükk lényege, hogy ennek köszönhetően **nem** használhatóak rajta a standard
+tömb műveletek mint például a `push`, `pop` vagy a `slice`. Míg a sima `for` ciklusos iterálás
+működik itt is, ahhoz hogy az előbb említett műveleteket is tudjuk rajta használni, át kell
+konvertálni egy valódi `Array` objektummá.
+
+### Tömbbé konvertálás
+
+Ez a kódrészlet egy új `Array` objektummá varázsolja az emlegetett `arguments` szamarat.
+
+    Array.prototype.slice.call(arguments);
+	
+De, ez a konverzió meglehetősen **lassú**, így egyáltalán **nem ajánlott** teljesítmény kirtikus
+alkalmazások írásakor.
+
+### Argumentumok kezelése
+
+A következő módszer ajánlott arra az esetre, hogy ha az egyik függvény paramétereit egy-az-egyben
+át szeretnénk adni egy másik függvény számára.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // sok okos kód ide
+    }
+
+Egy másik trükk arra, hogy teljesen független wrapper függvényeket gyártsunk, a `call`
+és `apply` együttes használata.
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Elkészíti a "method" (this) független verzióját
+    // Ezeket kapja paraméterül: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // Eredmény: Foo.prototype.method.call(this, arg1, ...argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+	
+### Paraméterek és argumentum indexek
+
+A háttérben az `arguments` objektum minden egyes indexére (elemére) egy *getter* és egy *setter*
+függvényt is kap, csak úgy ahogy a függvény paramétereit is felül tudjuk írni, illetve eltudjuk érni.
+
+Ennek eredményeképp, az `arguments` objektumon véghezvitt változtatások szinkronban
+változtatják a függvény névvel ellátott paramétereit is.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+	
+### Teljesítmény mítoszok és trükkök
+
+Ahogy már azt korábban körvonalaztuk, az `arguments` objektum csak akkor nem jön létre,
+hogyha a függvényhatókörön belül definiálunk egy változót ezzel a névvel, vagy a függvényünk
+egyik paraméterének ezt a nevet választjuk.
+
+Azonban a *getterek* és *setterek* mindig létrejönnek, de ez ne zavarjon meg minket, mert
+semmiféle befolyása nincs a teljesítményre, pláne olyan kódban ahol sokkal több mindennel
+is foglalkozunk, mint az `arguments` objetkumhoz való hozzáférés.
+
+> **ES5 Megjegyzés:** Ezek a **getterek** és **setterek** nem jönnek létre strict módban.
+
+Habár, egyetlen eset van, amelynek komoly hatása lehet a kód teljesítményére a modern
+JavaScript motorokban. Ez pedig az `arguments.callee` használata.
+
+    function foo() {
+        // ..csinálunk valamit
+        arguments.callee; // ezzel a függvény objektummal
+        arguments.callee.caller; // és ennek a hívójával..
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Így viszont nem lehet behelyettesíteni ide...
+        }
+    }
+
+A fenti kódban a `foo` helyére nem lehet egyszerűen behelyettesíteni a [függvény törzsét][1],
+mivel a függvény törzsének fogalma kell legyen mind magáról, mind az ő hívójáról. Ez nem csak
+hogy azt akadályozza meg, hogy a behelyettesítéssel nyerjünk egy kis többlet performanciát,
+de az egységbe zárás elvét is erősen keresztbevágja, hiszen a függvény így erősen támaszkodni
+fog a hívó környezetére (kontextusára).
+
+Emiatt is, az `arguments.callee`, vagy bármely mezőjének használata **erősen kerülendő**.
+
+> **ES5 Okoskodás:** Strict módban, az `arguments.callee` kifejezés egy `TypeError` hibát fog dobni,
+> mivel a használata elavult.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
+
+
+
diff --git a/doc/hu/function/closures.md b/doc/hu/function/closures.md
new file mode 100644
index 00000000..33d4e3bd
--- /dev/null
+++ b/doc/hu/function/closures.md
@@ -0,0 +1,99 @@
+## Closure-ök és referenciák
+
+A JavaScript nyelv egyik legerőteljesebb tulajdonsága a *closure*-ök használatában rejlik.
+Ezek használatával a hatókörök egymásba ágyazhatóak, és egy belső hatókör mindig hozzáfér
+az őt körülvevő, külső hatókör változóihoz. Miután JavaScriptben egyetlen dologgal lehet
+hatóköröket kifejezni, és ez a [függvény](#function.scopes) (bizony az if, try/catch és hasonló blokkok **nem** jelentenek új hatókört, mint pl. a Javaban), az összes funkció closure-ként szerepel.
+
+### Privát változók emulálása
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+	
+Ebben a példában a `Counter` **két** closure-rel tér vissza: az `increment` és
+a `get` függvénnyel. Mind a két függvény **referenciát** tárol a `Counter` hatókörre,
+és így mindketten hozzáférnek a `count` változóhoz, ami ebben a hatókörben lett
+definiálva.
+
+### Miért működnek a privát változók?
+
+Mivel a JavaScriptben egyszerűen **nem** lehet hatókörre referálni, vagy hatókört
+értékül adni, így ezért szintén lehetetlen elérni az iménti `count` változót a külvilág számára.
+Egyetlen mód van a megszólítására, ezt pedig láttuk a fentebbi két closure-ön belül.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+	
+A fentebbi kód **nem** fogja megváltoztatni a `Counter` hatókör `count` változóját,
+mivel a `foo.hack` mező **nem abban** a hatókörben lett létrehozva. Ehelyett, okosan,
+létre fogja hozni, vagy felül fogja írni a *globális* `count` változót (window.count).
+
+### Closure-ök használata ciklusokban
+
+Az egyik leggyakoribb hiba, amit el lehet követni, az a closure-ök ciklusokban való használata.
+Annak is azon speciális esete amikor a ciklus indexváltozóját szeretnénk lemásolni a closure-ön belül.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+A fenti kódrészlet marhára **nem** a számokat fogja kiírni `0`-tól `9`-ig, de inkább
+a `10`-et fogja tízszer kiírni.
+
+Ugyanis a belső *névtelen* függvény egy **referenciát** fog tárolni a külső `i` változóra, és
+akkor, amikor végül a `console.log` sor lefut, a `for loop` már végzett az egész ciklussal,
+így az `i` értéke `10`-re lesz beállítva.
+
+Ahhoz, hogy a várt működést kapjuk (tehát a számokat 0-tól 9-ig), szükségszerű az `i` változó
+értékét **lemásolni**.
+
+### A referencia probléma elkerülése
+
+Az előző problémára megoldást úgy lehet jól adni, hogy az utasításoknak megfelelően 
+lemásoljuk a ciklusváltozót, úgy hogy a jelenlegi ciklusmagöt körbevesszük egy [névtelen
+függvénnyel](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+A külső (wrapper) névtelen függvény így azonnal meghívódik az `i` ciklusváltozóval, mint paraméterrel,
+és így mindig egy másolatot fog kapni az `i` változó **értékéről**, amit ő `e` néven emészt tovább.
+
+Így a `setTimeout`ban lévő névtelen függvény mindig az `e` nevű referenciára fog mutatni, aminek az értéke így már **nem** változik meg a ciklus futása során.
+
+Egy másik lehetséges út a megoldáshoz az, hogy egy wrapper függvényt visszatérítünk a setTimeoutból, aminek ugyanaz lesz a hatása, mint a fentebbi példának.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+
+
+
diff --git a/doc/hu/function/constructors.md b/doc/hu/function/constructors.md
new file mode 100644
index 00000000..c955cce1
--- /dev/null
+++ b/doc/hu/function/constructors.md
@@ -0,0 +1,128 @@
+## Konstruktorok
+
+Csak úgy, mint minden más, a konstruktorok működése szintén különbözik 
+a megszokottól. Itt minden függvényhívás amelyet a `new` kulcsszó előz meg, 
+konstruktor hívásnak számít.
+
+A `this` értéke a konstruktoron - hívott függvényen - belül az újonnan létrehozott objektumra
+mutat. Az **új** objektum [prototípusa](#object.prototype) a konstruktor függvény `prototípusával` fog megegyezni.
+
+Ha a konstruktor függvényben nincs `return` utasítás, akkor automatikusan a `this` értékével tér vissza - a létrehozott objektummal.
+
+    function Foo() {
+        this.bla = 1;
+    }
+
+    Foo.prototype.test = function() {
+        console.log(this.bla);
+    };
+
+    var test = new Foo();
+	
+A fenti kódban a `Foo` függvényt, mint konstruktort hívjuk meg, ami a test változóban
+egy új objektumot fog eredményezni. Ennek az objektumnak a `prototípusa` a Foo prototípusa lesz.
+
+Trükkös ugyan, de ha mégis van `return` utasítás az éppen konstruált függvényben, akkor
+a függvény hívása az annak megfelelő értékkel fog visszatérni, de **csak** akkor, ha a 
+visszatérített érték `Objektum` típusú.
+
+    function Bar() {
+        return 2;
+    }
+    new Bar(); // ez egy új üres objektum lesz: {}, a 2 helyett
+
+    function Test() {
+        this.value = 2;
+
+        return {
+            foo: 1
+        };
+    }
+    new Test(); // ez a { foo: 1 } objektumot fogja eredményezni
+	
+Hogyha kihagyjuk a `new` kulcsszó használatát, a függvény **nem** egy új objektummal fog visszatérni.
+
+    function Foo() {
+        this.bla = 1; // ez a globális objektumon állít
+    }
+    Foo(); // undefined
+
+A [`this`](#function.this) JavaScript beli működésének köszönhetően, még ha le is
+fut az előbbi kód, akkor a `this` helyére a *globális objektumot* képzeljük.
+
+### Gyárak (Factory-k)
+
+Ahhoz, hogy teljesen el tudjuk hagyni a `new` kulcsszó használatát, a konstruktor
+függvény explicit értékkel kell visszatérjen.
+
+    function Bar() {
+        var value = 1;
+        return {
+            method: function() {
+                return value;
+            }
+        }
+    }
+    Bar.prototype = {
+        foo: function() {}
+    };
+
+    new Bar();
+    Bar();
+
+Mindkét `Bar`-ra történő hívásmód ugyanazt fogja eredményezni. Kapunk általuk 
+egy újonnan létrehozott objektumot, amelynek lesz egy `method` nevű mezője,
+ami egyébiránt egy [Closure](#function.closures).
+
+Azt is érdekes itt megjegyezni, hogy a `new Bar()` hívás **nem** befolyásolja a
+visszatérített objektum prototípusát. Mivel a prototípus csak az újonnan 
+létrehozott objektumon létezik, amit a `Bar` nem térít vissza (mivel egy explicit
+értéket ad vissza).
+
+A fenti példában nincs funkcionális különbség aközött hogy kiírjuk-e a `new`
+varázsszót avagy nem.
+
+### Új objektumok létrehozása gyárakon keresztül
+
+Gyakran bevett módszer egy projetkben, hogy a `new` varázsszó használatát 
+teljesen elhagyjuk, mert a kiírásának elfelejtése bugokhoz vezetne.
+
+Ennek érdekében egy új objektum létrehozásához inkább egy gyárat kell 
+implementálni, és annak a belsejében létrehozni az új objektumot. 
+
+
+    function Foo() {
+        var obj = {};
+        obj.value = 'blub';
+
+        var private = 2;
+        obj.someMethod = function(value) {
+            this.value = value;
+        }
+
+        obj.getPrivate = function() {
+            return private;
+        }
+        return obj;
+    }
+
+A fenti kód ugyan ellenálló a hiányzó `new` kulcsszó hibáját illetően és 
+megfelelően használ [privát változókat](#function.closures), érdemes 
+megemlíteni a dolgok kontra részét is.
+
+ 1. Több memóriát használ, mivel az így létrehozott objektumok **nem**
+	osztják meg a prototípusukat egymás között.
+ 2. A származtatás macerás, mivel a gyár kénytelen ilyenkor lemásolni
+	az összes származtatandó metódust egy másik objektumról, vagy ezt az objektumot
+	be kell állítsa a létrehozott új objektum prototípusának.
+ 3. Az a megközelítés miszerint egy kifelejtett `new` kulcsszó miatt eldobjuk
+	az objektum teljes prototípusát, ellenkezik a nyelv szellemiségével.
+
+### Összefoglaló
+
+A `new` varázsszó kihagyása ugyan bugokhoz vezethet, de ez **nem** megfelelő indok
+arra hogy ezért eldobjuk a prototípusok használatát. Végeredményben mindig
+az fog dönteni a különböző stílusok megválasztása között, hogy mire van
+szüksége éppen az aktuális programunknak. Egy dolog azért elengedhetetlenül
+fontos, ez pedig hogy megválasszuk melyik stílust fogjuk használni objektumok
+létrehozásra, és ezt **konzisztensen** használjuk a teljes megoldáson keresztül.
diff --git a/doc/hu/function/general.md b/doc/hu/function/general.md
new file mode 100644
index 00000000..9b62b0ee
--- /dev/null
+++ b/doc/hu/function/general.md
@@ -0,0 +1,48 @@
+## Függvény deklarációk és kifejezések
+
+A függvények JavaScriptben egyben objektumok is. Ez azt jelenti, hogy
+ugyanúgy lehet őket passzolgatni, mint bármelyik más értékeket. Ezt a featuret
+gyakran használják arra, hogy egy *névtelen (callback) függvényt* átadjunk 
+egy másik -aszinkron- függvény paramétereként.
+
+### A `függvény` deklaráció
+
+    function foo() {}
+	
+Ez a függvény felkerül a scope tetejére ([hoisting](#function.scopes)), mielőtt a kód végrehajtása megtörténne. Így abban a scope-ban, ahol *definiálták*, *mindenhol* elérhető, 
+még abban a trükkös esetben is, hogyha a kód azon pontján hívjuk ezt a függvényt, mielőtt
+definiáltuk volna (látszólag).
+
+    foo(); // Így is működik
+    function foo() {}
+
+### A `függvény` kifejezés (expression)
+
+    var foo = function() {};
+
+A fentebbi példában egy *névtelen* függvényt adunk értékül a foo változónak. 
+
+    foo; // 'undefined'
+    foo(); // TypeError hiba
+    var foo = function() {};
+
+Habár ebben a példában a `var` deklaráció futás előtt a kód tetejére kúszik,
+ettől függetlenül a foo mint függvény meghívásakor hibát fogunk kapni.
+
+Ugyanis a deklaráció felkúszott, azonban az értékadás csak futásidőben fog megtörténni,
+addig is a foo változó értéke [undefined](#core.undefined) marad. Az undefinedot pedig hiába hívjuk függvényként, TypeErrort kapunk végeredményül.
+
+### Névvel ellátott függvény kifejezés
+
+Egy másik érdekes eset, amikor névvel ellátott függvényeket adunk értékül változóknak.
+
+    var foo = function bar() {
+        bar(); // Működik
+    }
+    bar(); // ReferenceError
+
+Ebben a példában a `bar`t önmagában nem lehet elérni egy külső scope-ból (utolsó sor), 
+mivel egyből értékül adtuk a `foo` változónak. Ennek ellenére a `bar`on belül elérhető
+a `bar` név. A tanulság az, hogy a függvény önmagát *mindig* eléri a saját scopeján belül, és ez a JavaScriptben található [névfeloldásnak](#function.scopes) köszönhető.
+
+
diff --git a/doc/hu/function/scopes.md b/doc/hu/function/scopes.md
new file mode 100644
index 00000000..7e75a0b5
--- /dev/null
+++ b/doc/hu/function/scopes.md
@@ -0,0 +1,234 @@
+## Névterek és hatókörök
+
+Habár látszólag a kapcsos zárójelek jelentik a blokkok határait JavaScriptben, 
+fontos megjegyezni hogy **nincsen** blokk szintű hatókör, csakis *függvény hatókörök*
+léteznek.
+
+    function test() { // ez egy hatókör
+        for(var i = 0; i < 10; i++) { // ez meg nem
+            // utasítások...
+        }
+        console.log(i); // 10
+    }
+
+> **Megjegyzés**: Amikor a `{...}` jelölés nem értékadásban, return utasításban vagy
+> függvény argumentumként szerepel, akkor blokk utasításként lesz értelmezve és
+> nem objektum literálként. Ez a szép tulajdonság az [automatikus pontosvessző
+> generálással](#core.semicolon) karöltve nehezen észrevehető hibákhoz vezethet.
+
+A nyelvben nincsenek beépített névterek, ami azt jelenti hogy minden, egyetlen
+*globálisan megosztott* névtérben kerül deklarálásra.
+
+Akárhányszor egy változóra hivatkozunk, a JavaScript elkezdi felfele utazva
+megkeresni hatókörökön, amíg csak meg nem találja. Hogyha elérjük
+a globális hatókört és még mindig nem találjuk a keresett változót, akkor egy
+`ReferenceError` hibával gazdagodik a futásidőnk.
+
+### A globális változók csapása
+
+    // A script
+    foo = '42';
+
+    // B script
+    var foo = '42'
+
+Érdemes észrevenni, hogy a fenti két scriptnek **nem** ugyanaz a hatása. Az A script
+egy `foo` nevű változót vezet be a *globális* hatókörben, a B script pedig egy `foo`
+nevű változót deklarál az *ő hatókörében*.
+
+Mégegyszer tehát, ez a kettő **nem** *ugyanazt jelenti*: a `var` elhagyásának jópár
+beláthatatlan következménye is lehet.
+
+    // globális hatókör
+    var foo = 42;
+    function test() {
+        // lokális hatókör
+        foo = 21;
+    }
+    test();
+    foo; // 21
+	
+Itt, a `var` elhagyása azt eredményezi, hogy a `test` függvény mindig felülírja
+a globális hatókörben definiált `foo` változó értékét. Habár ez elsőre nem tűnik
+nagy dolognak, ha a `var`okat több száz sornyi JavaScript kódból hagyjuk el, az 
+olyan hibákhoz vezethet, amit még az anyósunknak se kívánnánk.
+    
+    // globális hatókör
+    var items = [/* random lista */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // a subLoop hatóköre
+        for(i = 0; i < 10; i++) { // hiányzik a var
+            // elképesztő dolgokat művelünk itt
+        }
+    }
+	
+Ennél a kódnál a külső ciklus az első `subLoop` hívás után megáll, mivel a `subLoop`
+felülírja az `i` változó globális értékét. Hogyha a második `for` ciklusban használtuk
+volna `var`-t azzal könnyen elkerülhettük volna ezt a hibát. **Sose** hagyjuk el a `var` utasítást, ha csak nem direkt az a *kívánt hatás*, hogy befolyásoljuk a 
+külső hatókört.
+
+
+### Lokális változók
+
+Kétféleképp (és nem több módon) lehet lokális változókat JavaScriptben leírni; ez vagy a [függvény](#function.general) paraméter vagy a `var` utasítás.
+
+    // globális hatókör
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // a test függvény lokális hatóköre
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+	
+Itt a `foo` és `i` lokális változók a `test` hatókörén belül, viszont a `bar`os
+értékadás felül fogja írni a hasonló nevű globális változót.
+
+### Hoisting
+
+A JS **hoistolja** (megemeli) a deklarációkat. Ez azt jelenti hogy minden `var`
+utasítás és `függvény` deklaráció az őt körülvevő hatókör tetejére kerül.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+A fenti kód átalakul egy másik formára mielőtt lefutna. A JavaScript felmozgatja
+a `var` utasításokat és a `függvény` deklarációkat, az őket körülvevő legközelebbi
+hatókör tetejébe.
+
+    // a var utasítások felkerülnek ide
+    var bar, someValue; // alapból mindegyik 'undefined' értékű lesz
+
+    // a függvény deklaráció is felkerül ide
+    function test(data) {
+        var goo, i, e; // ezek is felkerülnek
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // Ez TypeErrorral elszáll, mivel a bar még 'undefined'
+    someValue = 42; // az értékadásokat nem piszkálja a hoisting
+    bar = function() {};
+
+    test();
+
+A hiányzó blokk hatókör ténye nem csak azt eredményezi, hogy a `var` utasítások
+kikerülnek a ciklusmagokból, hanem az `if` utasítások kimenetele is megjósolhatatlan
+lesz.
+
+Habár úgy látszik az eredeti kódban, hogy az `if` utasítás a `goo` *globális 
+változót* módosítja, a hoisting után látjuk hogy valójában a *lokális változóra*
+lesz befolyással. Trükkös.
+
+A *hoisting* tudása nélkül valaki azt hihetné, hogy az alábbi kód egy `ReferenceError`
+-t fog eredményezni.
+
+    // nézzük meg hogy a SomeImportantThing inicializálva lett-e
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Persze ez működik, annak köszönhetően hogy a `var` utasítás a *globális hatókör*
+tetejére lett mozgatva.
+
+    var SomeImportantThing;
+
+    // más kódok még inicializálhatják az előbbi változót itt...
+
+    // ellenőrizzük hogy létezik-e
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Névfeloldási sorrend
+
+JavaScriptben az összes hatókörnek -beleértve a *globálisat* is- megvan a maga
+[`this`](#function.this) változója, amelyik mindig az *aktuális objektumra* utal.
+
+A függvény hatókörökben van még egy speciális [`arguments`](#function.arguments)
+változó is mindig definiálva, amely a függvénynek átadott argumentumokat
+tartalmazza.
+
+Hogy hozzunk egy példát, amikor valaki a `foo` nevű változót próbálja elérni egy
+függvény hatókörön belül, a JavaScript az alábbi sorrendben fogja keresni az adott
+változó nevet.
+ 
+ 1. Abban az esetben ha találunk `var foo` utasítást, használjuk azt.
+ 2. Hogyha bármelyik függvény paraméter neve `foo`, használjuk azt.
+ 3. Hogyha magának a függvénynek a neve `foo, használjuk azt.
+ 4. Menjünk a külső hatókörre, és kezdjük újra **#1**-től.
+ 
+> **Megjegyzés**: Egy `arguments` nevű függvény paraméter **megakadályozza**
+> a bépített `arguments` objektum létrehozását.
+
+### Névterek
+
+Hogyha egyetlen globális névterünk van, akkor egy gyakori probléma lehet az,
+hogy névütközésekbe futunk. A JavaScriptben szerencsére ez a gond könnyen
+elkerülhető a *névtelen wrapper függvények* használatával.
+
+    (function() {
+        // egy 'öntartalmazó' névtér
+        
+        window.foo = function() {
+            // egy exportált closure
+        };
+
+    })(); // a függvényt azonnal végre is hajtjuk
+
+A névtelen függvények [kifejezésekként](#function.general) vannak értelmezve; így
+ahhoz hogy meghívhatóak legyenek, először ki kell értékelni őket.
+
+    ( // a függvény kiértékelése a zárójeleken belül
+    function() {}
+    ) // a függvény objektum visszatérítése
+    () // az eredmény meghívása
+
+Persze más kifejezések is használhatóak arra, hogy kiértékeljük és meghívjuk
+a függvény kifejezést, amelyek habár szintaxisukban eltérnek, ugyan azt eredményezik.
+
+    // Még több stílus anonymus függvények azonnali hívásához...
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // és a lista folytatódik...
+
+### Összegzésül
+
+Az *anonym wrapper függvények* használata erősen ajánlott a kód egységbezárása 
+érdekében, saját névtér alkotásához. Ez nem csak hogy megvédi a kódunkat a 
+névütközésektől, de jobb modularizációhoz is vezet.
+
+Emelett a globális változók használata **nem ajánlott**. **Bármilyen** fajta 
+használata rosszul megírt kódról árulkodik, amelyik könnyen eltörik és nehezen
+karbantartható.
diff --git a/doc/hu/function/this.md b/doc/hu/function/this.md
new file mode 100644
index 00000000..8c363873
--- /dev/null
+++ b/doc/hu/function/this.md
@@ -0,0 +1,110 @@
+## A `this` mágikus működése
+
+A `this` kicsit másképp működik a JavaScriptben, mint ahogy azt megszokhattuk
+más nyelvekben. Ugyanis pontosan **öt féle** módja lehet annak, hogy a `this` 
+éppen mire utal a nyelvben.
+
+### A Globális hatókör
+
+	this;
+	
+Amikor globális hatókörben van használva a `this`, akkor pontosan a *globális* objektumra utal.
+
+### Függvény híváskor
+
+	foo();
+	
+Itt a `this` megint a *globális* objektumra fog utalni.
+
+> **ES5 Megjegyzés:** Strict módban a globális eset **nem létezik** többé.
+> Ezekben az esetekben a `this` értéke undefined lesz.
+
+### Eljárás hívásakor
+
+    test.foo(); 
+
+Ebben a példában a `this` a `test` objektumra fog hivatkozni.
+
+### Konstuktor hívásakor
+
+    new foo(); 
+
+Ha a függvény hívását a `new` kulcsszóval előzzük meg, akkor a függvény  [konstruktorként](#function.constructors) fog viselkedni. A függvényen belül, a `this`
+az *újonnan létrehozott* `Objektumra` fog hivatkozni.
+
+### A `this` explicit beállítása
+
+    function foo(a, b, c) {}
+                          
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // ugyanaz mint egy sorral lejjebb
+    foo.call(bar, 1, 2, 3); // argumentumok: a = 1, b = 2, c = 3
+
+A `Function.prototype`-ban levő `call` vagy `apply` használatakor aztán elszabadul a pokol 😀.
+Ezekben az esetekben ugyanis a this a foo hívásakor **egzaktan** be lesz állítva az apply/call
+első argumentumára. 
+
+Ennek eredményképp az előzőekben említett *Eljárás hívásakor* rész **nem** érvényes,
+a `foo` fentebbi meghívásakor a `this` értéke a `bar` objektumra lesz beállítva.
+
+> **Megj.:** A `this` kulcsszót **nem lehet** `Objektum` literál létrehozásakor arra használni,
+> hogy magára az objektumra hivatkozzon.
+> Így a `var obj = {me: this}` kódban a `me` **nem fog** a `this`-re hivatkozni, ugyanis
+> ez az eset nem tartozik egyikhez sem a fent megtalálható öt közül.
+
+### Gyakori buktatók
+
+Míg a fent megtalálható eseteknek van gyakorlatban vett értelme, az első
+a nyelv rossz designjára utal, ugyanis ennek **soha** nem lesz semmilyen 
+praktikus felhasználási módja.
+
+    Foo.method = function() {
+        function test() {
+            // A this itt a globális ojjektum.
+        }
+        test();
+    };
+
+Gyakori hiba, hogy úgy gondolják a fenti példában az emberek, hogy a `this` a `test` függvényen
+belül az őt körülvevő `Foo`-ra fog mutatni, pedig **nem**.
+
+Megoldásképp, hogy a `Foo`-hoz hozzáférhessük a `test`-en belül, szükségszerű egy változót
+lokálisan elhelyezni a `method`-on belül, ami már valóban a kívánt `this`-re (`Foo`-ra) mutat.
+
+    Foo.method = function() {
+        var that = this;
+        function test() {
+            // Használjuk a that-et a this helyett
+        }
+        test();
+    };
+	
+A `that` tuladjonképpen egy mezei változónév (nem kulcsszó), de sokszor használják arra,
+hogy egy másik `this`-re hivatkozzanak vele. A [closure-ökkel](#function.closures) kombinálva
+ez a módszer arra is használható, hogy `this`-eket passzolgassunk a vakvilágban és még tovább.
+
+### Eljárások értékül adása
+
+Egy másik koncepció ami **nem** fog a JavaScriptben működni, az az alias függvények létrehozása, ami tulajdonképpen egy függvény másik névhez való **kötését** jelentené.
+
+    var test = someObject.methodTest;
+    test();
+
+
+Az első eset miatt a `test` egy sima függvényhívásként működik, azonban a `this` értéke
+a függvényen belül a továbbiakban **nem** a `someObject` lesz.	
+
+Elsőre a `this` alábbi módon való utánkötése (late binding) nem tűnik jó ötletnek.
+Azonban ez az, amitől a [prototípusos öröklődés](#object.prototype) is működni tud, 
+ami a nyelv egyik fő erőssége.
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+Amikor a `method` meghívódik a `Bar` példányaként, a `this` pontosan a `Bar`
+megfelelő példányára fog mutatni.
diff --git a/doc/hu/index.json b/doc/hu/index.json
new file mode 100644
index 00000000..c3a3c82e
--- /dev/null
+++ b/doc/hu/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "description": "Bevezet\u00E9s a JavaScript bugyraiba, hib\u00E1iba.",
+    "langTitle": "A JavaScript Garden magyarul",
+    "sections": [
+        {
+            "title": "Bevezet\u0151",
+            "dir": "intro",
+            "articles": [ "index" ]
+        },
+        {
+            "title": "Objektumok",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "F\u00FCggv\u00E9nyek",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "T\u00F6mb\u00F6k",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "T\u00EDpusok",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "L\u00E9nyeg",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "Egy\u00E9b",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/hu/intro/index.md b/doc/hu/intro/index.md
new file mode 100644
index 00000000..83bb9b94
--- /dev/null
+++ b/doc/hu/intro/index.md
@@ -0,0 +1,41 @@
+## Bevezető
+
+A **JavaScript Garden** egy folytonosan növekvő kódgyűjtemény amely a nyelv kihívást okozó részeit hivatott tisztázni. Itt tanácsokat kaphatsz afelől, hogyan kerüld el a leggyakoribb programozási- valamint nyelvi hibákat, hogyan írj gyorsabb kódot, és mik a legsűrűbben elkövetett *bad practice*k amelyekkel egy átlagos JavaScript programozó (nem) mindennapi útján találkozhat a nyelv megismerése közben. 
+
+A JavaScript Gardennek **nem** célja, hogy megtanítsa a JavaScript nyelvet!
+Az itt felsorolt témák megértéséhez mindenképp szükséges némi tapasztalat. Ha a nyelv alapjait szeretnéd elsajátítani, először nézd át ezt a kiváló [tutorialt][1] a Mozilla Developer Networkön.
+
+## Szerzők
+
+Ez a leírás két kiváló [Stack Overflow][2] felhasználó, [Ivo Wetzel][3] (szerző) és [Zhang Yi Jiang][4] (Design) tollából született.
+
+A dokumentumot jelenleg [Tim Ruffles](http://truffles.me.uk) gondozza.
+
+## Hozzájárultak még
+
+ - Túl hosszú lenne itt mindenkit felsorolni, lásd a [közreműködők listáját](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
+ - A magyar fordítás [jozsefDevs](https://twitter.com/jozsefDevs) jóvoltából született.
+
+## Hosting
+
+A JavaScript Garden a GitHubon van hostolva, de a [Cramer Development][7] jóvoltából
+a [JavaScriptGarden.info][8] címen is elérhető.
+
+## Licensz
+
+A JavaScript Garden az [MIT licensszel][9] van ellátva és a [GitHubon][10] hostoljuk.
+Ha bármilyen hibát vagy elírást veszel észre, kérlek [jelezd azt][11], vagy javítsd és küldj egy pull requestet. Továbbá, megtalálhatsz minket a [JavasScript szobában][12] a Stack Overflow chaten.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/hu/object/forinloop.md b/doc/hu/object/forinloop.md
new file mode 100644
index 00000000..642dc265
--- /dev/null
+++ b/doc/hu/object/forinloop.md
@@ -0,0 +1,53 @@
+## A `for in` ciklus
+
+Csak úgy, mint a jó öreg `in` operátor, a `for in` is bejárja az egész
+prototípus láncot, amikor egy objektum mezőin próbálnánk iterálni.
+
+> **Megjegyzés:** A `for in` ciklus **nem** fog iterálni azokon a mezőkön,
+> amelyeknek az `enumerable` tulajdonsága `false`-ra van állítva. Például a 
+> `length` mező nem kerül az iterációba amikor egy tömbön iterálnánk végig.
+    
+    // Mérgezzük Object.prototype-ot!
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // mind a moo és bar is kiírásra kerül
+    }
+
+Mivel -hála égnek- magának a `for in` ciklusnak a működését nem lehet befolyásolni,
+így más módszert kell találnunk ahhoz hogy száműzzük a váratlan mezőket a ciklus magból.
+(Értsd: Azokat amelyek a prototípus láncon csücsülnek csak). Ezt pedig az `Object.prototype`-ban
+lakó [`hasOwnProperty`](#object.hasownproperty) függvény használatával érhetjük el.
+
+> **Fontoljuk meg:** Mivel a `for in` mindig bejárja a teljes prototípus láncot,
+> így minnél több elemet adunk a származtatási láncunkba, annál lassabban fog tekerni.
+
+### Szűrés használata a `hasOwnProperty`-vel
+
+    // még mindig a fenti foo-nál tartunk
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Ez az egyetlen helyes útja annak, hogy az objektum saját mezőin iteráljunk csak végig.
+Mivel a `hasOwnProperty`-t használjuk, így csak a várt `moo`-t fogja kiírni. Tehén jó
+kódunk van! Hogyha a `hasOwnProperty`-t kihagynánk, a kódunk ki lenne téve nem várt
+hibáknak, amik pl. abból fakadnak, hogy valaki ocsmányul kiterjesztette az
+`Object.prototype`-t.
+
+Például, ha a [Prototype][1] frameworköt használjuk, és nem ilyen stílusban írjuk a
+ciklusainkat, a hibák szinte garantáltak, ugyanis ők saját szájízükre kiterjesztik az
+`Object.prototype`-t.
+
+### Konklúzió
+
+A `hasOwnProperty` használata erősen javasolt. Soha ne éljünk pozitív
+feltételezésekkel a futó kódot illetően, főleg olyan döntésekben nem érdemes
+orosz rulettezni, mint hogy kiterjeszti-e valaki a natív prototípusokat vagy nem.
+Mert általában igen.
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/hu/object/general.md b/doc/hu/object/general.md
new file mode 100644
index 00000000..0032e735
--- /dev/null
+++ b/doc/hu/object/general.md
@@ -0,0 +1,90 @@
+## Objektumok és mezők használata
+
+A JavaScriptben minden objektumként működik, a [`null`](#core.undefined) és az [`undefined`](#core.undefined) kivételével.
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Gyakori tévhitként terjed, hogy a JavaScriptben a számok nem használhatóak objektumként. 
+Ez csak látszólag igaz, mivel a JavaScript a pont utáni részt úgy próbálja értelmezni,
+mintha lebegőpontos számot látna. Így hibát kaphatunk.  
+
+    2.toString(); // SyntaxErrort vált ki
+
+Azonban számos kifejezés létezik megoldásként, amelyekkel megkerülhető ez a probléma.
+
+    2..toString(); // így a második pont már az objektumra utal
+    2 .toString(); // fontos a space-t észrevenni itt a pont előtt
+    (2).toString(); // a 2 értékelődik ki hamarabb
+
+### Objektumok mint adattípusok
+
+Az objektumok JavaScriptben [*Hash táblaként*][1] is használhatóak, mivel természetszerűleg kulcs-érték párokat tartalmaznak.
+
+Az objektum literál leírásával - `{}` jelöléssel - lehet létrehozni egy új objektumot. Ez az új objektum az `Object.prototype`-ból [származik](#object.prototype) és nincsenek [saját mezői](#object.hasownproperty) definiálva.
+
+    var foo = {}; // egy új, üres objektum
+
+    // egy új objektum egy 'test' nevű mezővel, aminek 12 az értéke
+    var bar = {test: 12}; 
+
+### Mezők elérése
+
+Egy objektum mezői kétféle módon érhetőek el, vagy az 'objektum.mezőnév' jelöléssel,
+(Ford.: amit "dot notationként" emlegetünk) vagy a szögletes zárójelek kirakásával.
+    
+    var foo = {name: 'macska'}
+    foo.name; // macska
+    foo['name']; // macska
+    
+    var get = 'name';
+    foo[get]; // macska
+    
+    foo.1234; // SyntaxError
+    foo['1234']; // működik
+
+A két jelölés majdnem egyenértékűen használható, kivéve, hogy a szögletes zárójelekkel dinamikusan állíthatunk be mezőket és olyan neveket is választhatunk, amik amúgy szintaxis hibához vezetnének (Fordító: mivel a neveket stringbe kell rakni, megadhatunk a JS által "lefoglalt" kulcsszavakat is mezőnévként, habár ennek használata erősen kerülendő).
+
+### Mezők törlése
+
+Egyetlen módon lehet mezőt törölni egy objektumból, ez pedig a `delete` operátor
+használata; a mező értékének `undefined`-ra vagy `null`-ra való állítása csak
+magára az értékre van kihatással, de a kulcs ugyanúgy megmarad az objektumban.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+A fenti ciklus a `bar undefined` és a `foo null` eredményeket fogja kiírni - 
+egyedül a `baz` mező került törlésre, és emiatt hiányzik is az outputról.
+
+### Kulcsok jelölése
+
+    var test = {
+        'case': 'Kulcsszó vagyok, ezért stringként kell leírnod',
+        delete: 'Én is az vagyok' // SyntaxError
+    };
+
+Az objektumok mezőnevei mind stringként, mind egyszerű szövegként (Ford.: aposztrófok nélkül)
+leírhatóak. A JavaScript értelmező hibája miatt, a fenti kód azonban `SyntaxErrort` eredményez ECMAScript 5 előtti verzió esetén.
+
+Ez a hiba onnan ered, hogy a `delete` egy *kulcsszó*, viszont érdemes *string literálként*
+leírni, hogy helyesen megértsék a régebbi JavaScript motorok is.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/hu/object/hasownproperty.md b/doc/hu/object/hasownproperty.md
new file mode 100644
index 00000000..245a3287
--- /dev/null
+++ b/doc/hu/object/hasownproperty.md
@@ -0,0 +1,61 @@
+## `hasOwnProperty`
+
+Hogy meg tudjuk nézni egy adott objektum saját mezőit - azokat a mezőket, amelyek
+az objektumon *közvetlenül* vannak definiálva, és nem valahol a 
+[prototípus láncon](#object.prototype) -, a `hasOwnProperty` függvény használata 
+ajánlott, amelyet az összes objektum amúgy is örököl az `Object.prototype`-ból.
+
+> **Megj.:** Vicces programozók miatt, **nem** biztos hogy elég lesz megnézni hogy 
+> egy adott mező `undefined`-e. Mivel lehet hogy ekkor maga a mező létezik, csak valaki
+> konkrétan az értékét `undefined`-ra állította.
+
+A `hasOwnProperty` függvény az egyetlen olyan dolog amelyik anélkül tudja ellenőrizni
+az objektum mezőit, hogy megpróbálná bejárni a prototípus láncot.
+
+    // Az Object.prototype beszennyezése
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // igaz
+
+    foo.hasOwnProperty('bar'); // hamis
+    foo.hasOwnProperty('goo'); // igaz
+
+Hogy megértsük a fontosságát, egyedül a `hasOwnProperty` tudja hozni a korrekt
+és elvárt eredményeket mezőellenőrzés szempontjából. Egyszerűen **nincs más** 
+módja annak, hogy kizárjuk a szűrésünkből azokat a mezőket amelyek nem az objektumon, 
+hanem valahol feljebb, a prototípus láncon lettek definiálva.
+
+### A `hasOwnProperty` mint mező
+
+A JavaScript persze nem védi magát a `hasOwnProperty` nevet, így egy jókedvű
+programozóban mindig megvan a lehetőség, hogy így nevezze el a saját függvényét.
+Ennek kikerülése érdekében ajánlott mindig a `hasOwnProperty`-re *kívülről* hivatkozni
+(Értsd: A hackelt -saját hasOwnPropertyvel ellátott- objektum kontextusán kívüli objektum hasOwnPropertyjét hívjuk meg).
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Mordor itt kezdődik'
+    };
+
+    foo.hasOwnProperty('bar'); // mindig hamissal tér vissza
+
+    // Használhatjuk egy másik objektum hasOwnPropertyjét, 
+	// hogy meghívjuk a foo-n.
+    ({}).hasOwnProperty.call(foo, 'bar'); // ez már igaz
+
+    // Szintén jó megoldás lehet közvetlenül az 
+	// Object prototypejából hívni ezt a függvényt.
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // ez is igaz
+
+
+### Konklúzió
+
+A `hasOwnProperty` használata az **egyetlen** megbízható módszer annak eldöntésére,
+hogy egy mező közvetlenül az objektumon lett-e létrehozva. Melegen ajánlott a 
+`hasOwnProperty`-t **minden** [`for in` ciklusban](#object.forinloop) használni.
+Használatával ugyanis elkerülhetjük a kontár módon kiegészített natív prototípusokból
+fakadó esetleges hibákat, amire az imént láttunk példát.
\ No newline at end of file
diff --git a/doc/hu/object/prototype.md b/doc/hu/object/prototype.md
new file mode 100644
index 00000000..27a533b4
--- /dev/null
+++ b/doc/hu/object/prototype.md
@@ -0,0 +1,120 @@
+## A Prototípus
+
+A JavaScript nem a klasszikus öröklődést használja, hanem egy ún. *prototípusos*
+származtatást használ.
+
+Míg ezt gyakran a JavaScript legnagyobb hibái között tartják számon, valójában
+ez a származtatási modell jóval kifejezőbb, mint klasszikus barátja.
+Ezt jelzi, hogy például sokkal könnyebb megépíteni a klasszikus modellt, alapul véve
+a prototípusos modellt, míg a fordított irány kivitelezése igencsak nehézkes lenne.
+
+A JavaScript az egyetlen széles körben elterjedt nyelv, amely ezt a származtatást
+használja, így mindenképp időt kell szánni a két modell közti különbség megértésére.
+
+Az első feltűnő különbség, hogy ez a fajta származtatás *prototípus láncokat* 
+használ.
+
+> **Megj.:** Egyszerűen a `Bar.prototype = Foo.prototype` utasítást használva, mind a 
+> két objektum **ugyanazon** a prototípus objektumon fog osztozni. Így aztán ha bárki közülük
+> megváltoztatja ezt a prototípust, az a változás a másik objektum működését is befolyásolja,
+> ami általában nem egyezik meg a kívánt működéssel.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Beállítjuk a Bar prototípusát a Foo egy új példányára
+    Bar.prototype = new Foo(); // !
+    Bar.prototype.foo = 'Hello World';
+
+    // Beállítjuk a Bar konstruktorát
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar(); // új Bar példány létrehozása
+
+    // A kapott prototípus lánc
+    test [instance of Bar]
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* stb. */ }
+
+A fenti kódban a `test` objektum mind a `Bar.prototype` és `Foo.prototype`
+prototípusokból származik, így lesz hozzáférése a `method` nevű függvényhez amely
+a `Foo` prototípusában lett definiálva. A `value` mezőhöz szintén lesz hozzáférése,
+amely akkor jött létre, amikor (szám szerint) **egy** új `Foo` példányt hoztunk létre.
+Érdemes észrevenni hogy a `new Bar()` kifejezés **nem** hoz létre egy új `Foo` példányt
+minden alkalommal, azonban újrahasználja azt az egyetlen (//!) inicilalizált `Foo` pédlányunkat. Így az összes `Bar` példány *egy és ugyanazt* a `value` mezőt (és
+értéket) fogja használni.
+
+> **Megj.:** **Ne** használd a `Bar.prototype = Foo` kifejezést, mivel ez nem
+> a `Foo` prototípusára fog mutatni, hanem magára a `Foo` függvényre, mint objektumra.
+> Így a prototípus lánc a `Function.prototype`-ra fog futni a `Foo.prototype` helyett.
+> Ekkor, a `method` függvény nem lesz benne a prototípus láncban.
+
+### Mezők keresése
+
+Amikor olyan utasítást adunk ki, amellyel egy objektum mezőjét keressük, a
+JavaScript **felfele** bejárja az egész prototípus láncot, amíg meg nem találja
+a kért mezőt.
+
+Hogyha eléri a lánc legtetejét - nevezetesen az `Object.prototype`-t és még
+ekkor sem találja a kért mezőt, akkor az [undefined-dal](#core.undefined) fog
+visszatérni.
+
+### A Prototype mező
+
+Alapjáraton, a JavaScript a prototype nevű mezőt használja a prototípus láncok
+kialakításához, de ettől függetlenül ez is ugyanolyan mező mint a többi, és 
+**bármilyen** értéket be lehet neki állítani. Viszont a primitív típusokat egyszerűen
+figyelmen kívül fogja hagyni a feldolgozó.
+
+    function Foo() {}
+    Foo.prototype = 1; // nincs hatása
+
+Az objektumok megadása, mint azt a fentebbi példában láthattuk, hatással van a prototype
+mezőkre és ezeknek az átállításával bele lehet szólni a prototípus láncok kialakításába.
+
+### Teljesítmény
+
+Értelemszerűen, minél nagyobb a prototípus lánc, annál tovább tart egy-egy mező
+felkeresése, és ez rossz hatással lehet a kód teljesítményére. Emellett, ha egy
+olyan mezőt próbálunk elérni, amely nincs az adott objektum példányban, az mindig
+a teljes lánc bejárását fogja eredményezni.
+
+Vigyázat! Akkor is bejárjuk a teljes láncot, amikor egy objektum mezőin próbálunk [iterálni](#object.forinloop).
+
+### Natív prototípusok bővítése
+
+Egy gyakran elkövetett hiba, hogy az `Object.prototype` prototípust vagy egy másik előre
+definiált prototípust próbálunk kiegészíteni új kóddal.
+
+Ezt [monkey patching][1]-nek is hívják, és aktívan kerülendő, mivel megtöri 
+az *egységbe zárás* elvét. Habár ezt a technikát olyan népszerű framework-ök
+is használják, mint a [Prototype][2], ettől függetlenül ne hagyjuk magunkat csőbe húzni;
+nincs ésszerű indok arra, hogy összezavarjuk a beépített típusokat, további 
+*nem standard* saját funkcionalitással.
+
+Az **egyetlen** ésszerű használati indok a natív prototípusokba nyúlásra az lehet, 
+hogy megpróbáljuk szimulálni az új JavaScript motorok szolgáltatásait régebbi társaikon, például az [`Array.forEach`][3] implementálásával.
+
+### Zárásként
+
+**Nagyon fontos** megérteni a prototípusos származtatási modellt, mielőtt olyan
+kódot próbálnánk írni, amely megpróbálja kihasználni a sajátosságait. Nagyon
+oda kell figyelni a prototípuslánc hosszára - osszuk fel több kis láncra ha
+szükséges - hogy elkerüljük a teljesítmény problémákat. Továbbá, a natív
+prototípusokat **soha** ne egészítsük ki, egészen addig amíg nem akarunk
+JavaScript motorok közötti kompatibilitási problémákat áthidalni.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/hu/other/timeouts.md b/doc/hu/other/timeouts.md
new file mode 100644
index 00000000..7ad37665
--- /dev/null
+++ b/doc/hu/other/timeouts.md
@@ -0,0 +1,167 @@
+### A varázslatos `setTimeout` és `setInterval`
+
+Mivel a JavaScript aszinkron, a `setTimeout` és `setInterval` használatával
+lehetséges késleltetni a kódok lefutási idejét.
+
+> **Megjegyzés:** A timeout függvények **nem** részei az ECMAScript Standardnek.
+> Mivel a [DOM][1] részeként lettek implementálva.
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // Egy számmal (> 0) tér vissza
+
+Amikor a `setTimeout` függvényt meghívjuk, válaszul egy timeout ID-t kapunk,
+valamint be lesz ütemezve a `foo` függvényhívás, hogy **körülbelül** 1000 miliszekundum múlva fusson le a jövőben. A `foo` **egyszer** lesz végrehajtva.
+
+Az aktuális JavaScript motor időzítésétől függően, és annak figyelembe vételével,
+hogy a JavaScript mindig egyszálú, tehát a megelőző kódok blokkolhatják a szálat,
+**soha** nem lehet biztonságosan meghatározni hogy valóban a kért időzítéssel 
+fog lefutni a kód amit megadtunk a `setTimeout`ban. Erre semmilyen biztosíték nincs.
+
+Az első helyen bepasszolt függvény a *globális objektum* által lesz meghívva, ami
+azt jelenti hogy a [`this`](#function.this) a függvényen belül a globális objektumra
+utal.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // a this egy globális objektumra utal, nem a Foo-ra
+            console.log(this.value); // undefined-ot logol ki
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+
+> **Note:** Mivel a `setTimeout` egy **függvény objektumot** vár első paramétereként
+> egy gyakori hiba a `setTimeout(foo(), 1000)` módon való használata, amely a 
+> `foo` **visszatérési értékét** fogja használni és **nem** a `foo`t mint függvényt. 
+> Ez a legtöbb esetben egy észrevétlen hibát okoz, mivel a függvény `undefined`-t
+> térít vissza amire a `setTimeout` **nem** fog hibát dobni.
+
+### Híváshalmozás a `setInterval`al
+
+Míg a `setTimeout` csak egyszer futtatja le a megadott függvényt, a `setInterval` -
+ahogy a neve is mutatja - **minden** `X` miliszekundumban végrehajtja a 
+neki átadott kódot, használata pedig erősen kerülendő.
+
+Nagy hátulütője, hogy még akkor is ütemezi az újabb és újabb
+hívásokat, hogyha az aktuálisan futattot kód a megadott időintervallumon
+felül blokkolja a további kód futtatást. Ez, hogyha megfelelően rövid
+intervallumokat állítunk be, felhalmozza a függvényhívásokat a call stacken.
+
+    function foo(){
+        // kód ami 1 másodpercig feltartja a futtatást
+    }
+    setInterval(foo, 100);
+
+A fenti kódban amikor a `foo` meghívódik, 1 másodpercig feltartja a további futtatást.
+
+A `setInterval` persze ütemezni fogja a jövőbeli `foo` hívásokat továbbra is, amíg
+blokkolódik a futtatás. Így **tíz** további hívás fog várakozni, miután a `foo`
+futtatása először végzett.
+
+### Hogyan Bánjunk El a Blokkolással
+
+A legkönnyebb és kontrollálhatóbb megoldásnak az bizonyul, ha a `setTimeout`
+függvényt a rögtön a foo-n belül használjuk.
+
+    function foo(){
+        // 1 másodpercig blokkoló kód
+        setTimeout(foo, 100);
+    }
+    foo();
+
+Ez nem csak egységbe zárja a `setTimeout` hívást, de meggátolja a felesleges hívások
+felhalmozását, és több irányítást ad a kezünkbe. A `foo` így magától el tudja
+dönteni, hogy akarja-e újra futtatni önmagát vagy sem.
+
+### Timeout Tisztogatás Kézzel
+
+A `clearTimeout` vagy `clearInterval` hívással tudjuk a timeoutjainkat 
+megszüntetni, természetesen attól függ, hogy melyiket használjuk,
+hogy melyik `set` függvénnyel indítottuk útjára a timeoutunkat.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Az Összes Timeout Megszüntetése
+
+Mivel nincsen beépített megoldás az összes timeout és/vagy interval
+hívás törlésére, ezért bruteforce módszerekhez kell folyamodjunk.
+
+    // az "összes" timeout kitörlése
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+Persze ez csak véletlenszerű lövöldözés, semmi sem garantálja, hogy a fenti 
+módszerrel nem marad timeout a rendszerben (A ford.: például az ezredik timeout vagy
+afelett). Szóval egy másik módszer ennek megoldására, hogy feltételezzük hogy
+minden `setTimeout` hívással az azonosítók száma egyel növekszik.
+
+    // az "összes" timeout kiírtása
+    var legnagyobbTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= legnagyobbTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+Habár ez a megoldás minden böngészőben megy (egyelőre), ez az azonosítókról született mondás nincs specifikációban rögzítve, és ennek megfelelően változhat. 
+Az ajánlott módszer továbbra is az, hogy kövessük nyomon az összes timeout azonosítót, amit generáltunk, és így ki is tudjuk őket rendesen törölni.
+
+### `eval` A Színfalak Mögött
+
+Habár a `setTimeout` és a `setInterval` (kód) stringet is tud első paramétereként
+fogdani, ezt a fajta formáját használni kimondottan **tilos**, mivel a függöny
+mögött ő is csak `eval`t használ.
+
+> **Megjegyzés:** Mivel az ECMAScript Standard nem specifikálja a timeout
+> függvények működését, az eltérő JavaScript implementációkban eltérő módon
+> működhetnek. Például a Microsoft JScript-je a `Function` konstruktort használja
+> az `eval` helyett.
+
+    function foo() {
+        // meg lesz hívva
+    }
+
+    function bar() {
+        function foo() {
+            // soha nem hívódik meg
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Mivel az `eval`t nem [direkt](#core.eval) módon hívjuk meg a fenti esetben,
+a `setTimeout`nak passzolt string a *globális hatókörben* fog lefutni; így
+a lokális `foo` függvényt sosem használjuk a `bar` hatóköréből.
+
+Továbbá **nem** ajánlott argumentumokat átadni annak a függvénynek amelyik
+a timeout függvények által meg lesz hívva a későbbiekben.
+
+    function foo(a, b, c) {}
+    
+    // SOHA ne használd így!
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // Ehelyett csomagoljuk névtelen függvénybe
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **Megjegyzés:** Habár lehetséges a `setTimeout(foo, 1000, 1, 2, 3)` szintaxist
+> használni, mégsem ajánlott, mivel [metódusok](#function.this)  használatakor
+> észrevehetetlen hibákhoz vezethet.
+
+### Összegzésképp
+
+**Soha** ne használjunk stringeket a `setTimeout` vagy `setInterval` első
+paramétereiként. Ha argumentumokat kell átadni a meghívandó függvénynek, az 
+egyértelműen **rossz** kódra utal. Ebben az esetben a függvényhívás 
+lebonyolításához egy *anonim* függvény használata ajánlott.
+
+Továbbá, mivel az ütemező kódja nem blokkolódik a JavaScript futás által, a 
+`setInterval` használata úgy általában kerülendő.
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
+
diff --git a/doc/hu/types/casting.md b/doc/hu/types/casting.md
new file mode 100644
index 00000000..ee604410
--- /dev/null
+++ b/doc/hu/types/casting.md
@@ -0,0 +1,68 @@
+## Típus kasztolás
+
+Előre kössük le, hogy a JavaScript egy *gyengén típusos* nyelv, így **ahol
+csak tud**, ott *típus kényszerítést* használ.
+
+    // Ezek igazak
+    new Number(10) == 10; // A Number.toString() számmá lesz
+                          // visszaalakítva
+
+    10 == '10';           // A Stringek visszaalakulnak számmá
+    10 == '+10 ';         // Mégtöbb string varázslat
+    10 == '010';          // és mégtöbb
+    isNaN(null) == false; // a null varázslatosan 0-vá alakul
+                          // ami persze nem NaN
+    
+    // Ezek hamisak
+    10 == 010;
+    10 == '-10';
+
+> **ES5 Megjegyzés:** A `0`-val kezdődő számliterálok oktálok (8-as számrendszer).
+> Az oktál támogatást az ECMAScript 5 strict módból **eltávolították**
+
+Hogy elkerüljük a fenti varázslatokat, a [szigorú egyenlőség ellenőrzés](#types.equality) **melegen** ajánlott. Habár ezzel elkerüljük
+a problémák farkasrészét, még mindig tartogat a JS gyengén típusos rendszere
+meglepetéseket.
+
+### Natív típusok konstruktorai
+
+A jó hír az, hogy a natív típusok, mint a `Number` és a `String` különféle
+módon viselkednek, hogy ha a `new` kulcsszóval avagy anélkül vannak inicializálva.
+
+    new Number(10) === 10;     // Hamis, Objektum vs. Szám
+    Number(10) === 10;         // Igaz, Szám vs. szám
+    new Number(10) + 0 === 10; // Igaz, az implicit konverziónak hála
+
+Ha egy natív típust, mint a `Number` konstruktorként kezelünk, akkor egy új
+`Number` objektumot kapunk. De ha kihagyjuk a `new` kulcsszót akkor a `Number`
+egy egyszerű konverter függvényként fog viselkedni.
+
+Ráadásul a literálok passzolgatásakor még több típuskonverzió üti fel a fejét.
+
+A legjobb megoldás hogyha a három típus valamelyikére **expliciten** kasztolunk.
+
+### Stringre kasztolás
+
+    '' + 10 === '10'; // igaz
+
+Egy üres string hozzáfűzésével könnyen tudunk egy értéket stringgé kasztolni.
+
+### Számra kaszt
+
+    +'10' === 10; // igaz
+	
+Az **unáris** plusz operátor használatával lehetséges egy értéket számra alakítani.
+
+### Booleanre kasztolás
+
+A **nem** operátor kétszeri alkalmazásával tudunk booleanné kasztolni.
+
+    !!'foo';   // igaz
+    !!'';      // hamis
+    !!'0';     // igaz
+    !!'1';     // igaz
+    !!'-1'     // igaz
+    !!{};      // igaz
+    !!true;    // igaz
+
+
diff --git a/doc/hu/types/equality.md b/doc/hu/types/equality.md
new file mode 100644
index 00000000..d627e86c
--- /dev/null
+++ b/doc/hu/types/equality.md
@@ -0,0 +1,77 @@
+## Egyenlőség vizsgálat
+
+A JavaScriptben két különböző megoldás létezik az objektumok egyenlőségének 
+vizsgálatára
+
+### Az egyenlőség operátor
+
+Az egyenlőség vizsgálatot végző (egyik) operátort így jelöljük: `==`
+
+A JavaScript egy *gyengén típusos* nyelv. Ez azt jelenti, hogy az egyenlőség
+operátor **típuskényszerítést** alkalmaz ahhoz, hogy össze tudjon hasonlítani
+két értéket.
+    
+    ""           ==   "0"           // hamis
+    0            ==   ""            // igaz
+    0            ==   "0"           // igaz
+    false        ==   "false"       // hamis
+    false        ==   "0"           // igaz
+    false        ==   undefined     // hamis
+    false        ==   null          // hamis
+    null         ==   undefined     // igaz
+    " \t\r\n"    ==   0             // igaz
+
+A fenti táblázat szépen mutatja, hogy mi a típuskényszerítés eredménye, és egyben
+azt is, hogy miért rossz szokás a `==` használata. Szokás szerint, ez megint
+olyan fícsör, ami nehezen követhető kódhoz vezethet a komplikált konverziós
+szabályai miatt.
+
+Pláne, hogy a kényszerítés teljesítmény problémákhoz is vezet; ugyanis, mielőtt
+egy stringet egy számhoz hasonlítanánk azelőtt a karakterláncot át kell konvertálni
+a megfelelő típusra.
+
+### A szigorú(bb) egyenlőség operátor
+
+Ez az operátor már **három** egyenlőségjelből áll: `===`.
+
+Ugyanúgy működik, mint az előbbi, kivéve hogy ez a változat **nem** alkalmaz
+típuskényszerítést az operandusai között.
+
+    ""           ===   "0"           // hamis
+    0            ===   ""            // hamis
+    0            ===   "0"           // hamis
+    false        ===   "false"       // hamis
+    false        ===   "0"           // hamis
+    false        ===   undefined     // hamis
+    false        ===   null          // hamis
+    null         ===   undefined     // hamis
+    " \t\r\n"    ===   0             // hamis
+
+A felső eredmények sokkal egyértelműbbek és ennek köszönhetően sokkal hamarabb
+eltörik a kód egy-egy ellenőrzésen. Ettől sokkal hibatűrőbb lesz
+a produktumunk, ráadásul teljesítménybeli gondjaink sem lesznek.
+
+### Objektumok összehasonlítása
+
+Habár mind a `==`-t és a `===`-t is egyenlőség operátornak hívjuk, eltérően
+viselkednek, hogy ha legalább az egyik operandusuk egy objektum.
+	
+	{} === {};                   // hamis
+    new String('foo') === 'foo'; // hamis
+    new Number(10) === 10;       // hamis
+    var foo = {};
+    foo === foo;                 // igaz
+	
+Ebben az esetben mindkét operátor **identitást** és **nem** egyenlőséget 
+ellenőriz; tehát azt fogják ellenőrizni hogy az operandus két oldalán
+ugyanaz az objektum referencia áll-e, mint az `is` operátor Pythonban
+vagy a pointerek összehasonlítása C-ben. (A ford.: Tehát nem azt, hogy a 
+két oldalon álló objektumnak például ugyanazok-e a mezői, hanem azt hogy ugyanazon
+a memóriacímen található-e a két operandus).
+
+### Összegzésül
+
+Azt érdemes tehát megjegyezni, hogy a **szigorú egyenlőség vizsgálatot** érdemes
+mindig használni. Amikor szeretnék típuskényszerítést alkalmazni, akkor azt
+inkább tegyük meg [direkt módon](#types.casting), és ne a nyelv komplikált
+automatikus szabályaira bízzuk magunkat. 
\ No newline at end of file
diff --git a/doc/hu/types/instanceof.md b/doc/hu/types/instanceof.md
new file mode 100644
index 00000000..50dbd489
--- /dev/null
+++ b/doc/hu/types/instanceof.md
@@ -0,0 +1,35 @@
+## Az `instanceof` operátor
+
+Az `instanceof` operátor a két operandusának konstruktorait hasonlítja össze. 
+Csak akkor bizonyul hasznosnak, amikor saját készítésű objektumokon alkalmazzuk.
+Beépített típusokon ugyanolyan hasztalan alkalmazni, mint a [typeof operátort](#types.typeof).
+
+### Saját objektumok összehasonlítása
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // igaz
+    new Bar() instanceof Foo; // igaz
+
+    // Ez csak a Bar.prototypeot beállítja a Foo fv. objektumra,
+    // de nem egy kimondott Foo példányra
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // hamis
+
+### Az `instanceof` reakciója natív típusokra
+
+    new String('foo') instanceof String; // igaz
+    new String('foo') instanceof Object; // igaz
+
+    'foo' instanceof String; // hamis
+    'foo' instanceof Object; // hamis
+
+Érdemes itt megjegyezni hogy az `instanceof` nem működik olyan objektumokon,
+amelyek különböző JavaScript kontextusokból származnak (pl. különböző dokumentumok
+a böngészőn belül), mivel a konstruktoruk nem pontosan ugyanaz az objektum lesz.
+
+### Összegzésül
+
+Az `instanceof`-ot tehát **csak** megegyező JS kontextusból származó, saját készítésű objektumoknál használjuk. Minden más felhasználása kerülendő, csak úgy, mint a [`typeof`](#types.typeof) operátor esetén.
\ No newline at end of file
diff --git a/doc/hu/types/typeof.md b/doc/hu/types/typeof.md
new file mode 100644
index 00000000..556543dc
--- /dev/null
+++ b/doc/hu/types/typeof.md
@@ -0,0 +1,15 @@
+## A `typeof` vizsgálat
+
+A `typeof` operátor (az [`instanceof`](#types.instanceof)-al karöltve) 
+lehetőség szerint a JavaScript nyelv egyik legnagyobb buktatója, mivel majdnem
+teljesen **rosszul működik**.
+
+Habár az `instanceof`-nak korlátozottan még lehet értelme, a `typeof` operátor
+tényleg csak egyetlen praktikus use case-el rendelkezik és ez **nem** az, hogy egy
+objektum típusvizsgálatát elvégezzük.
+
+> **Megjegyzés:** Mivel a `typeof` vizsgálatot ravaszul úgy is le lehet írni,
+> mintha egy függvény lenne; `typeof(obj)`, itt jegyezzük meg hogy ez nem
+> egy függvényhívás. A zárójelek ebben a kifejezésben úgy működnek mint általában,
+> kiértékelik az obj változót és visszaadják az értékét. Ez pedig bekerül a 
+> `typeof` operandusaként. **Nincsen** `typeof` függvény.
\ No newline at end of file
diff --git a/doc/it/array/constructor.md b/doc/it/array/constructor.md
new file mode 100644
index 00000000..c6c2edb9
--- /dev/null
+++ b/doc/it/array/constructor.md
@@ -0,0 +1,34 @@
+## Il costruttore `Array`
+
+Dato che il costruttore `Array` è ambiguo riguardo a come esso gestisca i suoi
+parametri, si consiglia calorosamente di usare l'array letterale (notazione `[]`)
+quando si creano array.
+
+    [1, 2, 3]; // Risultato: [1, 2, 3]
+    new Array(1, 2, 3); // Risultato: [1, 2, 3]
+
+    [3]; // Risultato: [3]
+    new Array(3); // Risultato: []
+    new Array('3') // Risultato: ['3']
+
+Nei casi in cui c'è solo un argomento passato al costruttore `Array` e quando
+l'argomento è un `Number`, il costruttore ritornerà un nuovo array *frammentato*
+con la proprietà `length` impostata al valore dell'argomento. Si noti
+che in questo modo **solo** la proprietà `length` del nuovo array verrà impostata,
+mentre gli indici dell'array non verranno inizializzati.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, l'indice non è stato impostato
+
+Essere in grado di impostare la lunghezza dell'array in anticipo è utile soltanto
+in poche situazioni, come ad esempio la ripetizione di una stringa, nel cui caso
+si eviterebbe l'uso di un ciclo.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### In conclusione
+
+I letterali sono da preferirsi al costruttore Array. Sono più concisi, hanno una
+sintassi più chiara ed incrementano la leggibilità del codice.
+
diff --git a/doc/it/array/general.md b/doc/it/array/general.md
new file mode 100644
index 00000000..453dc088
--- /dev/null
+++ b/doc/it/array/general.md
@@ -0,0 +1,61 @@
+## Iterazione e proprietà degli Array
+
+Sebbene gli array in JavaScript siano oggetti, non ci sono valide ragioni
+per usare il ciclo [`for in`](#object.forinloop). Infatti, ci sono varie
+buone ragioni per **evitare** l'utilizzo di `for in` con gli array.
+
+> **Nota:** gli array in JavaScript **non** sono *array associativi*. JavaScript
+> ha solo [oggetti](#object.general) per mappare chiavi con valori. E mentre
+> gli array **preservano** il loro ordine, gli oggetti **non lo fanno**.
+
+Dato che il ciclo `for in` enumera tutte le proprietà che sono presenti nella
+catena di prototipi, e dal momento che il solo modo per escludere queste
+proprietà è quello di usare [`hasOwnProperty`](#object.hasownproperty),
+esso è già **venti volte** più lento di un normale ciclo `for`.
+
+### Iterazione
+
+Per poter ottenere la miglior performance durante l'iterazione degli array,
+è meglio usare il classico ciclo `for`.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+In questo esempio c'è un ulteriore particolare da notare, che è il caching
+della lunghezza dell'array tramite `l = list.length`.
+
+Sebbene la proprietà `length` sia definita nell'array stesso, c'è ancora un
+sovraccarico di lavoro dato dal fatto che deve essere ricercata ad ogni
+iterazione del ciclo. E mentre i motori JavaScript recenti **potrebbero**
+applicare delle ottimizzazioni in questo caso, non c'è modo di dire se il
+codice verrà eseguito su uno di questi nuovi motori oppure no.
+
+Infatti, l'omissione della parte di caching può risultare in un ciclo eseguito
+soltanto alla **metà della velocità** con cui potrebbe essere eseguito facendo
+il caching della lunghezza.
+
+### La proprietà `length`
+
+Mentre il *getter* della proprietà `length` ritorna semplicemente il numero di
+elementi che sono contenuti nell'array, il *setter* può essere usato per
+**troncare** l'array.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Assegnando una lunghezza più piccola si tronca l'array. Incrementandola si
+crea un array frammentato.
+
+### In conclusione
+
+Per la miglior performance, si raccomanda di usare sempre il ciclo `for`
+classico e fare il caching della proprietà `length`. L'uso di `for in` su di
+un array è segno di un codice scritto male che è suscettibile a bug e pessima
+performance.
diff --git a/doc/it/core/delete.md b/doc/it/core/delete.md
new file mode 100644
index 00000000..ba4ec77d
--- /dev/null
+++ b/doc/it/core/delete.md
@@ -0,0 +1,90 @@
+## L'operatore `delete`
+
+In breve, è *impossibile* eliminare variabili globali, funzioni e qualche
+altra cosa in JavaScript che ha l'attributo `DontDelete` impostato.
+
+### Codice globale e codice funzione
+
+Quando una variabile o una funzione viene definita in un scope globale o
+[funzione](#function.scopes), essa è una proprietà dell'oggetto Activation
+o dell'oggetto Global. Queste proprietà hanno un set di attributi, tra i quali
+`DontDelete`. Dichiarazioni di variabile o funzione nel codice globale o
+funzione, creano sempre proprietà con `DontDelete`, e quindi non possono essere
+eliminate.
+
+    // variabile globale:
+    var a = 1; // DontDelete è impostato
+    delete a; // false
+    a; // 1
+
+    // funzione normale:
+    function f() {} // DontDelete è impostato
+    delete f; // false
+    typeof f; // "function"
+
+    // la riassegnazione non aiuta:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Proprietà esplicite
+
+Proprietà esplicitamente impostate possono essere eliminate normalmente.
+
+    // proprietà impostata esplicitamente:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+Nel codice qui sopra, `obj.x` e `obj.y` possono essere eliminate perché
+non hanno l'attributo `DontDelete`. Ecco perché anche l'esempio seguente
+funziona.
+
+    // questo funziona, tranne che per IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - solo una variabile globale
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Qui usiamo un trucco per eliminare `a`. [`this`](#function.this) qui fa
+riferimento all'oggetto Global e noi dichiariamo esplicitamente la
+variabile `a` come sua proprietà, il che ci permette di eliminarla.
+
+IE (almeno 6-8) ha alcuni bug, quindi il codice precedente non funziona.
+
+### Argomenti funzione e proprietà interne
+
+Anche i normali argomenti delle funzioni, gli
+[oggetti `arguments`](#function.arguments) e le proprietà interne hanno
+`DontDelete` impostato.
+
+    // argomenti funzione e proprietà:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### Oggetti non nativi (host)
+
+Il comportamento dell'operatore `delete` può essere inaspettato con gli oggetti
+non nativi. A causa delle specifiche, agli oggetti non nativi è permesso di
+implementare qualsiasi tipo di funzionalità.
+
+### In conclusione
+
+L'operatore `delete` spesso ha un comportamento inaspettato e può solo essere
+usato con sicurezza per eliminare proprietà esplicitamente impostate in oggetti
+normali.
diff --git a/doc/it/core/eval.md b/doc/it/core/eval.md
new file mode 100644
index 00000000..54cf4566
--- /dev/null
+++ b/doc/it/core/eval.md
@@ -0,0 +1,49 @@
+## Perché non usare `eval`
+
+La funzione `eval` eseguirà una stringa di codice JavaScript nello scope locale.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+Comunque, `eval` esegue solo nello scope locale quando viene chiamata
+direttamente *e* quando il nome della funzione chiamata è `eval`.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+L'uso di `eval` dovrebbe essere evitato. Il 99.9% dei suoi "utilizzi" può
+essere ottenuto **senza** di essa.
+
+### `eval` sotto mentite spoglie
+
+Le [funzioni di timeout](#other.timeouts) `setTimeout` e `setInterval` possono
+entrambe accettare una stringa come loro primo argomento. Questa stringa verrà
+**sempre** eseguita nello scope globale dato che `eval` non viene chiamato
+direttamente in questo caso.
+
+### Problemi di sicurezza
+
+`eval` è anche un problema di sicurezza, perché essa esegue **qualsiasi**
+codice le viene passato. Non si dovrebbe **mai** usare con stringhe di origine
+sconosciuta o inaffidabile.
+
+### In conclusione
+
+`eval` non dovrebbe mai essere usata. Qualsiasi codice che ne faccia uso dovrebbe
+essere messo in discussione sotto l'aspetto della funzionalità, della performance
+e della sicurezza. Se qualcosa richiede `eval` per poter funzionare, allora **non**
+dovrebbe essere usato in primo luogo, ma si dovrebbe prevedere una
+*miglior progettazione* che non richieda l'uso di `eval`.
diff --git a/doc/it/core/semicolon.md b/doc/it/core/semicolon.md
new file mode 100644
index 00000000..22ed6098
--- /dev/null
+++ b/doc/it/core/semicolon.md
@@ -0,0 +1,120 @@
+## Inserimento automatico dei punti-e-virgola
+
+Sebbene JavaScript utilizzi lo stile di sintassi del C, esso **non**
+obbliga l'uso dei punti-e-virgola nel codice sorgente, perciò è possibile
+ometterli.
+
+Detto questo, JavaScript non è un linguaggio che fa a meno dei punti-e-virgola.
+Infatti, esso necessita di punti-e-virgola per poter comprendere il codice
+sorgente. Quindi, il parser del JavaScript li inserisce **automaticamente**
+ogni volta che incontra un errore di analisi dato dalla mancanza di un
+punto-e-virgola.
+
+    var foo = function() {
+    } // errore di analisi, atteso punto-e-virgola
+    test()
+
+Quindi avviene l'inserimento, ed il parser prova nuovamente.
+
+    var foo = function() {
+    }; // nessun errore, il parser continua
+    test()
+
+L'inserimento automatico dei punti-e-virgola è considerato essere uno dei
+**più grandi** errori di progettazione del linguaggio, perché *può*
+modificare il comportamento del codice.
+
+### Come funziona
+
+Il codice qui sotto non ha punti-e-virgola, quindi sta al parser decidere dove
+inserirli.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Di seguito il risultato del gioco da "indovino" del parser.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Non inserito, linee unite
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- inserito
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- inserito
+
+            return; // <- inserito, invalida l'istruzione return
+            { // trattato come un blocco
+
+                // un'etichetta e una singola espressione
+                foo: function() {}
+            }; // <- inserito
+        }
+        window.test = test; // <- inserito
+
+    // Le linee vengono unite nuovamente
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- inserito
+
+    })(window); //<- inserito
+
+> **Nota:** il parser del JavaScript non gestisce "correttamente" le istruzioni
+> return che sono seguite da un ritorno a capo. Mentre questo non è necessariamente
+> da considerarsi un errore dell'inserimento automatico di punti-e-virgola, esso
+> può ancora essere considerato un effetto collaterale indesiderato.
+
+Il parser ha drasticamente modificato il comportamento del codice. In alcuni casi,
+questo porta ad eseguire **cose sbagliate**.
+
+### Parentesi ad inizio riga
+
+Nel caso di parentesi ad inizio riga, il parser **non** inserirà un punto-e-virgola.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Questo codice viene trasformato in una sola linea.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+Le possibilità che `log` **non** ritorni una funzione sono **veramente** alte,
+perciò il codice qui sopra porterà ad un `TypeError` dichiarando che
+`undefined is not a function` (undefined non è una funzione).
+
+### In conclusione
+
+&Egrave; fortemente raccomandato di non omettere **mai** i punti-e-virgola.
+Si raccomanda anche di mantenere le parentesi sulla stessa linea della
+corrispondente istruzione, e di non ometterle mai in istruzioni `if` / `else`
+a linea singola. Queste misure precauzionali non solo miglioreranno la
+consistenza del codice, ma preverranno anche che il parser JavaScript
+modifichi il comportamento del codice in modo inaspettato.
+
diff --git a/doc/it/core/undefined.md b/doc/it/core/undefined.md
new file mode 100644
index 00000000..c94d5b68
--- /dev/null
+++ b/doc/it/core/undefined.md
@@ -0,0 +1,74 @@
+## `undefined` e `null`
+
+JavaScript usa due valori distinti per il nulla, `null` e `undefined`, e
+quest'ultimo è il più utile.
+
+### Il valore `undefined`
+
+`undefined` è un tipo con esattamente un valore: `undefined`.
+
+Il linguaggio definisce anche una variabile globale che ha il valore di `undefined`.
+Questa variabile è anche chiamata `undefined`. Comunque, questa variabile **non** è
+né una costante né una parola chiave del linguaggio. Ciò significa che il suo *valore*
+può facilmente essere sovrascritto.
+
+> **ES5 Nota:** `undefined` in ECMAScript 5 **non è più** *scrivibile* in strict
+> mode, ma il suo nome può ancora essere sostituito da, per esempio, una funzione
+> con nome `undefined`.
+
+Ecco alcuni esempi di quando il valore `undefined` viene ritornato:
+
+ - Accedendo la variabile globale (non modificata) `undefined`.
+ - Accedendo una variabile dichiarata *ma non* ancora inizializzata.
+ - Ritorno implicito da funzioni che non hanno l'istruzione `return`.
+ - Istruzioni `return` che non ritornano esplicitamente alcun valore.
+ - Ricerca di proprietà inesistenti.
+ - Parametri funzione a cui non viene esplicitamente passato alcun valore.
+ - Qualsiasi cosa a cui sia stato assegnato il valore `undefined`.
+ - Qualsiasi espressione nella forma di `void(espressione)`.
+
+### Gestire le modifiche al valore di `undefined`
+
+Dato che la variabile globale `undefined` mantiene solo una copia dell'attuale
+valore di `undefined`, assegnandole un nuovo valore **non** cambia il valore del
+*tipo* `undefined`.
+
+Inoltre, per confrontare qualcosa con il valore di `undefined`, è necessario
+ottenere prima il valore di `undefined`.
+
+Per proteggere il codice da possibili sovrascritture della variabile `undefined`,
+viene usata una comune tecnica che prevede l'aggiunta di un ulteriore parametro
+ad un [contenitore anonimo](#function.scopes) al quale non viene passato alcun
+argomento.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // ora undefined nello scope locale
+        // fa nuovamente riferimento al valore `undefined`
+
+    })('Hello World', 42);
+
+Un altro modo per ottenere lo stesso effetto sarebbe quello di usare una
+dichiarazione all'interno del contenitore.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+La sola differenza è che questa versione si traduce in 4 byte in più quando
+minificata, e non c'è nessun'altra istruzione `var` al'interno del contenitore
+anonimo.
+
+### Utilizzi di `null`
+
+Mentre `undefined` nel contesto del linguaggio JavaScript viene principalmente
+usato come un tradizionale *null*, l'attuale `null` (sia letterale che tipo di
+dati) è più o meno solo un altro tipo di dato.
+
+Viene usato in alcune funzioni interne al JavaScript (come la dichiarazione
+del termine della catena di prototipi, impostando `Foo.prototype = null`), ma
+nella maggior parte dei casi, può essere rimpiazzato da `undefined`.
+
diff --git a/doc/it/function/arguments.md b/doc/it/function/arguments.md
new file mode 100644
index 00000000..518c9b68
--- /dev/null
+++ b/doc/it/function/arguments.md
@@ -0,0 +1,123 @@
+## L'oggetto `arguments`
+
+Ogni scope di funzione in JavaScript può accedere alla speciale variabile
+`arguments`. Questa variabile mantiene un elenco di tutti gli argomenti
+che sono stati passati alla funzione.
+
+> **Nota:** nel caso `arguments` sia stato già definito nello scope della
+> funzione tramite una dichiarazione `var` o come parametro formale,
+> l'oggetto `arguments` non sarà creato.
+
+L'oggetto `arguments` **non** è un `Array`. Sebbene abbia in parte la
+semantica di un array (nello specifico la proprietà `length`), esso non
+eredita da `Array.prototype` ed è a tutti gli effetti un `Object`.
+
+Proprio per questo motivo, **non** è possibile usare su `arguments` i metodi
+standard degli array come `push`, `pop`, `slice`. E mentre l'iterazione con
+un semplice ciclo `for` funzionerà senza problemi, sarà necessario convertire
+l'oggetto in un vero `Array` per poter usare i metodi standard di `Array` con
+esso.
+
+### Conversione ad array
+
+Il codice seguente ritornerà un nuovo `Array` contenenente tutti gli elementi
+dell'oggetto `arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Dato che questa conversione è **lenta**, **non è raccomandato** usarla in sezioni
+di codice in cui la performance è un fattore critico.
+
+### Passaggio di argomenti
+
+Quello che segue è il metodo raccomandato per passare argomenti da una funzione
+ad un'altra.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // codice da eseguire
+    }
+
+Un altro trucco è quello di usare `call` e `apply` insieme per creare veloci
+contenitori senza vincoli.
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Crea una versione senza vincoli di "method"
+    // Richiede i parametri: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // Risultato: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### Parametri formali e indici degli argomenti
+
+L'oggetto `arguments` crea funzioni *getter* e *setter* sia per le sue
+proprietà che per i parametri formali della funzione.
+
+Come risultato, la modifica del valore di un parametro formale modificherà
+anche il valore della corrispondente proprietà nell'oggetto `arguments`, e
+vice versa.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Miti e verità sulla performance
+
+Il solo caso in cui l'oggetto `arguments` non viene creato, è quando esso
+viene dichiarato come un nome all'interno di una funzione o uno dei suoi
+parametri formali. Non importa che venga usato o meno.
+
+Sia i *getter* che i *setter* vengono **sempre** creati. Perciò, il loro
+utilizzo non ha praticamente alcun impatto sulle prestazioni, specialmente
+nel mondo reale dove nel codice c'è più di un semplice accesso alle proprietà
+dell'oggetto `arguments`.
+
+> **ES5 Nota:** questi *getter* e *setter* non vengono creati in strict mode.
+
+Ad ogni modo, c'è un caso che ridurrà drasticamente la performance nei motori
+JavaScript moderni. &Egrave; il caso dell'utilizzo di `arguments.callee`.
+
+    function foo() {
+        arguments.callee; // fa qualcosa con questo oggetto funzione
+        arguments.callee.caller; // e l'oggetto funzione chiamante
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // normalmente sarebbe sostituito con il suo codice...
+        }
+    }
+
+Nel codice qui sopra, `foo` non può più essere soggetto ad [inlining][1]
+dal momento che necessita di conoscere sia se stesso che il suo chiamante.
+Questo non solo annulla possibili guadagni prestazionali ottenibili con
+l'inlining, ma spezza anche il principio di incapsulazione perché la funzione
+ora potrebbe essere dipendente da uno specifico contesto di esecuzione.
+
+L'utilizzo di `arguments.callee` o di qualsiasi altra delle sue proprietà
+è **altamente sconsigliato**.
+
+> **ES5 Nota:** In strict mode, `arguments.callee` lancierà un `TypeError`
+> dato che il suo utilizzo è stato deprecato.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
diff --git a/doc/it/function/closures.md b/doc/it/function/closures.md
new file mode 100644
index 00000000..58bcaf4c
--- /dev/null
+++ b/doc/it/function/closures.md
@@ -0,0 +1,106 @@
+## Closures e riferimenti
+
+Una delle caratteristiche più potenti di JavaScript è la disponibilità delle
+*closure*. Con le closure, gli scope hanno **sempre** accesso allo scope
+più esterno nel quale sono state definite. Dal momento che il solo scope che
+JavaScript ha è lo [scope di funzione](#function.scopes), tutte le funzioni,
+per default, agiscono da closure.
+
+### Emulare variabili private
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+Qui, `Counter` ritorna **due** closure: la funzione `increment` e `get`.
+Entrambe mantengono un **riferimento** allo scope di `Counter` e, quindi,
+hanno sempre accesso alla variabile `count` definita in quello scope.
+
+### Perché le variabili private funzionano
+
+Dato che non è possibile fare riferimento o assegnare scope in JavaScript,
+**non** c'è modo per accedere alla variabile `count` dall'esterno. Il solo
+modo per interagire con essa è tramite le due closure.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+Il codice sopra **non** modificherà la variabile `count` nello scope di `Counter`,
+dato che `foo.hack` non è stato definito in **quello** scope. Invece, creerà
+(o meglio, sostituirà) la variabile *globale* `count`.
+
+### Closure nei cicli
+
+Un errore che spesso viene fatto è quello di usare le closure all'interno dei
+cicli, come se stessero copiando il valore della variabile dell'indice del ciclo.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);
+        }, 1000);
+    }
+
+Questo esempio **non** stamperà i numeri da `0` a `9`, ma semplicemente il
+numero `10` dieci volte.
+
+La funzione *anonima* mantiene un riferimento ad `i`, ma al momento in cui
+`console.log` viene richiamata, il `ciclo for` è già terminato, ed il valore
+di `i` è stato impostato a `10`.
+
+Per ottenere l'effetto desiderato, è necessario creare una **copia** del valore
+di `i`.
+
+### Evitare il problema del riferimento
+
+Per copiare il valore della variabile indice del ciclo, è meglio usare un
+[contenitore anonimo](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);
+            }, 1000);
+        })(i);
+    }
+
+La funzione anonima più esterna viene chiamata immediatamente con `i` come
+suo primo argomento e riceverà una copia del **valore** di `i` come suo
+parametro `e`.
+
+La funzione anonima che viene passata a `setTimeout` ora ha un riferimento a
+`e`, il cui valore **non** viene modificato dal ciclo.
+
+C'è anche un altro possibile modo per ottenere il medesimo risultato, e cioè
+ritornare una funzione dal contenitore anonimo che avrà quindi lo stesso
+comportamento del codice visto precedentemente.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+C'è un ulteriore modo per ottenere ciò, usando `.bind`, che può assegnare un
+contesto `this` e degli argomenti ad una funzione. Esso funziona allo stesso
+modo degli esempi precedenti
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
diff --git a/doc/it/function/constructors.md b/doc/it/function/constructors.md
new file mode 100644
index 00000000..1273e87c
--- /dev/null
+++ b/doc/it/function/constructors.md
@@ -0,0 +1,129 @@
+## Costruttori
+
+I costruttori in JavaScript sono differenti da quelli di molti altri linguaggi.
+Qualsiasi chiamata a funzione preceduta dalla parola chiave `new` agisce come
+un costruttore.
+
+Dentro al costruttore (la funzione chiamata) il valore di `this` fa riferimento
+al nuovo oggetto creato. Il [prototype](#object.prototype) di questo **nuovo**
+oggetto viene impostato al `prototype` dell'oggetto funzione che è stato invocato
+come costruttore.
+
+Se la funzione che è stata chiamata non ha un'istruzione `return` esplicita,
+allora essa ritorna implicitamente il valore di `this` (il nuovo oggetto).
+
+    function Person(name) {
+        this.name = name;
+    }
+
+    Person.prototype.logName = function() {
+        console.log(this.name);
+    };
+
+    var sean = new Person();
+
+Questo esempio chiama `Person` come costruttore ed imposta il `prototype` del
+nuovo oggetto creato a `Person.prototype`.
+
+In caso di istruzione `return` esplicita, la funzione ritorna il valore
+specificato da quell'istruzione, ma **solo** se il valore di ritorno è un
+`Object`.
+
+    function Car() {
+        return 'ford';
+    }
+    new Car(); // un nuovo oggetto, non 'ford'
+
+    function Person() {
+        this.someValue = 2;
+
+        return {
+            name: 'Charles'
+        };
+    }
+    new Person(); // l'oggetto ritornato ({name: 'Charles'}), escluso someValue
+
+Quando la parola chiave `new` viene omessa, la funzione **non** ritornerà un
+nuovo oggetto.
+
+    function Pirate() {
+        this.hasEyePatch = true; // imposta la proprietà nell'oggetto globale!
+    }
+    var somePirate = Pirate(); // somePirate è undefined
+
+Mentre l'esempio precedente potrebbe sembrare essere funzionante in alcuni
+casi, a causa del modo in cui lavora [`this`](#function.this) in JavaScript,
+esso userà l'*oggetto globale* come valore di `this`.
+
+### Factory (Fabbriche di oggetti)
+
+Per poter omettere la parola chiave `new`, la funzione costruttore deve
+esplicitamente ritornare un valore.
+
+    function Robot() {
+        var color = 'gray';
+        return {
+            getColor: function() {
+                return color;
+            }
+        }
+    }
+    Robot.prototype = {
+        someFunction: function() {}
+    };
+
+    new Robot();
+    Robot();
+
+Entrambe le chiamate a `Robot` ritornano lo stesso risultato, un nuovo oggetto
+creato con una proprietà chiamata `method`, che è una [Closure](#function.closures).
+
+Bisogna anche notare che la chiamata `new Robot()` **non** influisce sul prototipo
+dell'oggetto ritornato. Mentre il prototipo sarà impostato con il nuovo oggetto
+creato, `Robot` non ritornerà mai quel nuovo oggetto.
+
+Nell'esempio sopra, non c'è differenza funzionale nell'usare o meno la parola
+chiave `new`.
+
+### Creare nuovi oggetti tramite factory
+
+Viene spesso raccomandato di **non** usare `new` perché una sua dimenticanza
+può portare a bug potenzialmente insidiosi da risolvere.
+
+Per poter creare un nuovo oggetto, si dovrebbe invece usare una factory e
+costruire un nuovo oggetto all'interno di quella factory.
+
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
+
+        var milesPerGallon = 2;
+
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
+        }
+
+        car.getMPG = function() {
+            return milesPerGallon;
+        }
+        return car;
+    }
+
+Sebbene questo esempio sia a prova di omissione della parola chiave `new` e
+renda sicuramente più semplice l'utilizzo delle [variabili private](#function.closures),
+esso ha alcuni aspetti negativi.
+
+ 1. Usa più memoria dal momento che gli oggetti creati **non** condividono
+    i metodi di un prototipo.
+ 2. Per poter ereditare, la factory deve copiare tutti i metodi da un altro
+    oggetto oppure mettere quell'oggetto nel prototipo del nuovo oggetto.
+ 3. Perdere la catena di prototipi solo perché si vuole tralasciare la
+    parola chiave `new` è contrario allo spirito del linguaggio.
+
+### In conclusione
+
+Sebbene l'omissione della parola chiave `new` possa portare all'introduzione di
+bug, **non** è certo un motivo per privarsi completamente dell'uso dei prototipi.
+Alla fine si tratta di decidere quale sia la soluzione più adatta per
+l'applicazione. &Egrave; specialmente importante scegliere uno specifico stile
+di creazione degli oggetti ed usarlo in maniera **consistente**.
diff --git a/doc/it/function/general.md b/doc/it/function/general.md
new file mode 100644
index 00000000..9181ad88
--- /dev/null
+++ b/doc/it/function/general.md
@@ -0,0 +1,52 @@
+## Dichiarazioni ed espressioni di funzione
+
+Le funzioni in JavaScript sono oggetti di prima classe. Ciò significa che
+possono essere usate come ogni altro valore. Un uso comune di questa
+caratteristica è quello di passare una *funzione anonima* come funzione di
+callback ad un'altra funzione, possibilmente asincrona.
+
+### La dichiarazione di `function`
+
+    function foo() {}
+
+La funzione qui sopra viene [elevata](#function.scopes) (hoisted) prima
+che inizi l'esecuzione del programma. Questo vuol dire che essa è disponibile
+da un *qualsasi* punto dello scope in cui è stata *definita*, anche se
+richiamata prima dell'effettiva definizione nel sorgente.
+
+    foo(); // funziona perché foo è stata creata prima di eseguire il codice
+    function foo() {}
+
+### L'espressione `function`
+
+    var foo = function() {};
+
+Questo esempio assegna la funzione *anonima* alla variabile `foo`.
+
+    foo; // 'undefined'
+    foo(); // questo solleva un TypeError
+    var foo = function() {};
+
+Dato che `var` è una dichiarazione che eleva il nome di variabile `foo`
+prima che l'esecuzione del codice inizi, `foo` è già dichiarata quando lo
+script viene eseguito.
+
+Ma, dal momento che le assegnazioni avvengono solo a runtime, il valore di
+`foo` sarà [undefined](#core.undefined) per default, prima che il relativo
+codice sia eseguito.
+
+### Espressione di funzione con nome
+
+Un altro caso speciale è l'assegnazione di funzioni con nome.
+
+    var foo = function bar() {
+        bar(); // funziona
+    }
+    bar(); // ReferenceError
+
+Qui, `bar` non è disponibile nello scope più esterno, dal momento che la
+funzione viene assegnata solo a `foo`, mentre è disponibile all'interno di
+`bar`. Ciò è dato dal modo in cui funziona la [risoluzione dei nomi](#function.scopes)
+in JavaScript: il nome della funzione è *sempre* reso disponibile nello scope
+locale della funzione stessa.
+
diff --git a/doc/it/function/scopes.md b/doc/it/function/scopes.md
new file mode 100644
index 00000000..24f6d250
--- /dev/null
+++ b/doc/it/function/scopes.md
@@ -0,0 +1,241 @@
+## Scope e spazi di nome (namespace)
+
+Sebbene JavaScript non abbia problemi con la sintassi delle parentesi
+graffe per la definizione di blocchi, esso **non** supporta lo scope
+per blocco, quindi, tutto ciò che il linguaggio ci mette a disposizione
+è lo *scope di funzione*.
+
+    function test() { // questo è uno scope
+        for(var i = 0; i < 10; i++) { // questo non è uno scope
+            // conta
+        }
+        console.log(i); // 10
+    }
+
+> **Nota:** quando non usato in un'assegnazione, istruzione return o come
+> argomento di una funzione, la notazione `{...}` verrà interpretata come
+> una dichiarazione di blocco e **non** come un oggetto letterale. Questo,
+> assieme all'[inserimento automatico dei punti-e-virgola](#core.semicolon),
+> può portare ad errori alquanto subdoli.
+
+Anche gli spazi di nome (namespace) non sono gestiti in JavaScript, e ciò
+significa che ogni cosa viene definita in un namespace *globalmente condiviso*.
+
+Ogni volta che ci si riferisce ad una variabile, JavaScript risale attraverso
+tutti gli scope fino a che non la trova e, nel caso esso raggiunga lo scope
+globale senza aver trovato il nome richiesto, solleva un `ReferenceError`.
+
+### Il problema delle variabili globali
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+Questi due script **non** hanno lo stesso effetto. Lo script A definisce una
+variabile chiamata `foo` nello scope *globale*, mentre lo script B definisce
+una `foo` nello scope *attuale*.
+
+Ancora una volta. Questo esempio **non** sortisce lo *stesso effetto*: il
+non utilizzo di `var` può avere importanti conseguenze.
+
+    // scope globale
+    var foo = 42;
+    function test() {
+        // scope locale
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+L'omissione dell'istruzione `var` all'interno della funzione `test` sostituirà
+il valore di `foo`. Sebbene questo possa non sembrare un grosso problema in
+un primo momento, ritrovarsi con migliaia di linee di JavaScript senza
+utilizzare `var` introdurrà orribili bug molto difficili da individuare.
+
+    // scope globale
+    var items = [/* un elenco */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // scope di subLoop
+        for(i = 0; i < 10; i++) { // istruzione var omessa
+            // fai qualcosa di eccezionale!
+        }
+    }
+
+Il ciclo esterno terminerà dopo la prima chiamata a `subLoop`, dato che `subLoop`
+sovrascriverà il valore globale di `i`. L'utilizzo di una `var` per il secondo ciclo
+`for` avrebbe facilmente evitato questo errore. L'istruzione `var` non dovrebbe
+**mai** essere omessa a meno che l'*effetto desiderato* non sia proprio quello
+di influenzare lo scope esterno.
+
+### Variabili locali
+
+In JavaScript le sole sorgenti per le variabili locali sono i parametri
+[funzione](#function.general) e le variabili dichiarate tramite l'istruzione
+`var`.
+
+    // scope globale
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // scope locale della funzione test
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+Mentre `foo` e `i` sono variabili locali all'interno dello scope della funzione
+`test`, l'assegnazione di `bar` sostituirà la variabile globale con lo stesso
+nome.
+
+### Elevamento (hoisting)
+
+JavaScript **eleva** le dichiarazioni. Questo significa che le istruzioni `var`
+e le dichiarazioni `function` verranno spostate in cima agli scope che le
+racchiudono.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+Il codice qui sopra, viene trasformato prima che inizi l'esecuzione. JavaScript
+sposta sia le istruzioni `var` che le dichiarazioni `function` in cima al più
+vicino scope che le racchiude.
+
+    // le istruzioni var vengono spostate qui
+    var bar, someValue; // di default a 'undefined'
+
+    // la dichiarazione function viene spostata qui
+    function test(data) {
+        var goo, i, e; // il blocco scope mancante sposta qui queste istruzioni
+        if (false) {
+            goo = 1;
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // fallisce con un TypeError dato che bar è ancora 'undefined'
+    someValue = 42; // le assegnazioni non vengono influenzate dall'elevazione
+    bar = function() {};
+
+    test();
+
+L'omissione del blocco di scope non solo muoverà le istruzioni `var` fuori dal
+corpo dei cicli, ma renderà anche i risultati di certi costrutti `if` poco
+intuitivi.
+
+Nel codice originale, sebbene l'istruzione `if` sembrasse modificare la
+*variabile globale* `goo`, effettivamente essa va a modificare la *variabile locale*
+(dopo che l'elevazione è stata eseguita).
+
+Senza la conoscenza dell'*elevazione*, uno potrebbe pensare che il codice
+qui sotto sollevi un `ReferenceError`.
+
+    // verifica se SomeImportantThing è stato inizializzato
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Ma ovviamente tutto funziona grazie al fatto che l'istruzione `var` è stata
+spostata all'inzio dello *scope globale*.
+
+    var SomeImportantThing;
+
+    // qui altro codice potrebbe o meno inizializzare SomeImportantThing
+
+    // ci assicuriamo che ci sia
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Ordine di risoluzione dei nomi
+
+Tutti gli scope in JavaScript, *scope globale* incluso, hanno lo speciale
+nome [`this`](#function.this) definito in essi, che fa riferimento
+all'*oggetto attuale*.
+
+Gli scope di funzione hanno anche il nome [`arguments`](#function.arguments)
+definito in essi, che contiene gli argomenti passati alla funzione.
+
+Per esempio, cercando di accedere ad una variabile di nome `foo` all'interno
+dello scope di una funzione, JavaScript effettuerà una ricerca del nome nel
+seguente ordine:
+
+ 1. Nel caso ci sia un'istruzione `var foo` nello scope attuale, usa quella.
+ 2. Se uno dei parametri funzione si chiama `foo`, usa quello.
+ 3. Se la funzione stessa si chiama `foo`, usa quella.
+ 4. Vai al successivo scope esterno e ricomincia dal numero **1**.
+
+> **Nota:** avere un parametro di nome `arguments` **preverrà** la creazione
+> dell'oggetto `arguments` di default.
+
+### Spazi di nome (Namespace)
+
+Un comune problema associato al fatto di avere un solo spazio nomi globale,
+è che facilmente si incappa in problemi dove i nomi di variabile si
+sovrappongono. In JavaScript queso problema può essere facilmente evitato
+con l'aiuto dei *contenitori anonimi*.
+
+    (function() {
+        // "namespace" auto contenuto
+
+        window.foo = function() {
+            // una closure esposta
+        };
+
+    })(); // esecue immediatamente la funzione
+
+Le funzioni anonime sono considerate [espressioni](#function.general), quindi
+per poter essere richiamabili, esse devono prima essere valutate.
+
+    ( // valuta la funzione dentro le parentesi
+    function() {}
+    ) // e ritorna l'oggetto funzione
+    () // richiama il risultato della valutazione
+
+Ci sono altri modi per valutare e chiamare direttamente l'espressione funzione
+i quali, sebbene differenti nella sintassi, hanno tutti il medesimo effetto.
+
+    // Alcuni modi per invocare direttamente la
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // e così via...
+
+### In conclusione
+
+Si raccomanda sempre di usare un *contenitore anonimo* per incapsulare il
+codice nel suo proprio namespace. Questo non solo protegge il codice da
+eventuali conflitti con i nomi, ma permette anche una migliore modularizzazione
+dei programmi.
+
+Inoltre, l'uso delle variabili globali è considerato una **cattiva pratica**.
+**Qualsiasi** loro uso indica codice scritto male che è suscettibile ad errori
+e difficile da mantenere.
+
diff --git a/doc/it/function/this.md b/doc/it/function/this.md
new file mode 100644
index 00000000..258086a3
--- /dev/null
+++ b/doc/it/function/this.md
@@ -0,0 +1,124 @@
+## Come funziona `this`
+
+JavaScript ha una concezione differente di ciò a cui il nome speciale `this`
+fa normalmente riferimento nella maggior parte degli altri linguaggi di
+programmazione. Ci sono esattamente **cinque** differenti modi nei quali
+il valore di `this` può essere associato nel linguaggio.
+
+### Lo scope globale
+
+    this;
+
+Usando `this` nello scope globale, esso farà semplicemente riferimento
+all'oggetto *globale*.
+
+### Richiamando una funzione
+
+    foo();
+
+Qui, `this` farà ancora riferimento all'oggetto *globale*.
+
+> **ES5 Nota:** in strict mode, il caso globale **non** esiste più.
+> In quel caso `this` avrà invece il valore di `undefined`.
+
+### Richiamando un metodo
+
+    test.foo();
+
+In questo esempio, `this` farà riferimento a `test`.
+
+### Richiamando un costruttore
+
+    new foo();
+
+Una chiamata di funzione che viene preceduta dalla parola chiave `new`
+agisce come un [costruttore](#function.constructors). Dentro la funzione,
+`this` farà riferimento all'`Object` **appena creato**.
+
+### Impostazione esplicita di `this`
+
+    function foo(a, b, c) {}
+
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // l'array verrà espanso come mostrato sotto
+    foo.call(bar, 1, 2, 3); // risulterà in a = 1, b = 2, c = 3
+
+Quando si usano i metodi `call` o `apply` di `Function.prototype`, il valore di
+`this` all'interno della funzione chiamata viene **esplicitamente impostato**
+al primo argomento della corrispondente chiamata di funzione.
+
+Come risultato, nell'esempio sopra, il *caso del metodo* **non** viene applicato,
+e `this` all'interno di `foo` sarà impostato a `bar`.
+
+> **Nota:** `this` **non può** essere usato per far riferimento all'oggetto
+> all'interno di un `Object` letterale. Perciò `var obj = {me: this}` **non**
+> avrà come risultato `me` che fa riferimento ad `obj`, dato che `this`
+> viene assegnato solo da uno dei cinque casi elencati.
+
+### Insidie comuni
+
+Mentre molti di questi casi hanno senso, il primo può essere considerato
+un altro errore di progettazione del linguaggio perché non ha **mai** un
+uso pratico.
+
+    Foo.method = function() {
+        function test() {
+            // this viene impostato all'oggetto globale
+        }
+        test();
+    };
+
+Una comune credenza è che `this` all'interno di `test` faccia riferimento a
+`Foo` mentre, invece, **non** è così.
+
+Per poter ottenere l'accesso a `Foo` dall'interno di `test`, si può creare
+una variabile locale all'interno di `method` che faccia riferimento a `Foo`.
+
+    Foo.method = function() {
+        var self = this;
+        function test() {
+            // Qui viene usato self invece di this
+        }
+        test();
+    };
+
+`self` è solo un normale nome di variabile, ma viene comunemente usato come
+riferimento ad un `this` più esterno. Abbinato alle [closures](#function.closures)
+può anche essere usato per passare il valore di `this`.
+
+Con l'introduzione di ECMAScript 5 è possibile usare il metodo `bind` combinato
+con una funziona anonima
+
+    Foo.method = function() {
+        var test = function() {
+            // this ora fa riferimento a Foo
+        }.bind(this);
+        test();
+    };
+
+### Metodi di asseganzione
+
+Un'altra cosa che **non** funziona in JavaScript è la creazione di un alias ad
+una funzione, cioè l'**assegnazione** di un metodo ad una variabile.
+
+    var test = someObject.methodTest;
+    test();
+
+A causa della prima dichiarazione, `test` ora agisce da semplice chiamata a
+funzione e quindi, `this` all'interno di essa non farà più riferimento a
+`someObject`.
+
+Mentre l'assegnazione tardiva di `this` potrebbe sembrare una cattiva idea
+in un primo momento, alla prova dei fatti è ciò che fa funzionare
+l'[ereditarietà prototipale](#object.prototype).
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+Quando `method` viene chiamato da un'istanza di `Bar`, `this` farà riferimento
+a quell'istanza.
diff --git a/doc/it/index.json b/doc/it/index.json
new file mode 100644
index 00000000..b7b090e1
--- /dev/null
+++ b/doc/it/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden in italiano",
+    "description": "Guida alle peculiarità e i difetti del JavaScript.",
+    "sections": [
+        {
+            "title": "Introduzione",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "Oggetti",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Funzioni",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Array",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Tipi di dati",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Base",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "Varie",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/it/intro/index.md b/doc/it/intro/index.md
new file mode 100644
index 00000000..b9e7ceb1
--- /dev/null
+++ b/doc/it/intro/index.md
@@ -0,0 +1,51 @@
+## Introduzione
+
+**JavaScript Garden** è una collezione in continua crescita di documentazione
+relativa alle parti più peculiari del linguaggio di programmazione JavaScript.
+Il suo intento è quello di mostrare come evitare i più comuni errori, i
+problemi legati alla performance e le cattive abitudini che i programmatori
+JavaScript non esperti possono incontrare lungo il loro cammino di
+approfondimento del linguaggio.
+
+L'obiettivo di JavaScript Garden **non** è quello di insegnarti JavaScript.
+Una conoscenza pregressa del linguaggio è fortemenete consigliata, in modo da
+capire gli argomenti trattati da questa guida. Per poter imparare le basi del
+linguaggio, ti suggeriamo di leggere l'eccellente [guida][1] su Mozilla
+Developer Network.
+
+## Gli autori
+
+Questa guida è il risultato del lavoro di due utenti di [Stack Overflow][2],
+[Ivo Wetzel][3] (stesura) e [Zhang Yi Jiang][4] (progettazione).
+
+&Egrave; attualmente mantenuto da [Tim Ruffles](http://truffles.me.uk).
+
+## Collaboratori
+
+- Veramente troppi da elencare qui, [vedi tutti i collaboratori](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
+## Hosting
+
+JavaScript Garden è ospitato su GitHub, ma [Cramer Development][7] ci supporta
+con un mirror su [JavaScriptGarden.info][8].
+
+## Licenza
+
+JavaScript Garden è pubblicato sotto la [licenza MIT][9] ed ospitato su
+[GitHub][10]. Se trovi inesattezze o errori di battitura, ti prego di
+[segnalare il problema][11] o fare un pull request sul nostro repository.
+Puoi anche trovarci nella [stanza JavaScript][12] della chat di Stack
+Overflow.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/it/object/forinloop.md b/doc/it/object/forinloop.md
new file mode 100644
index 00000000..96fc2d24
--- /dev/null
+++ b/doc/it/object/forinloop.md
@@ -0,0 +1,68 @@
+## Il ciclo `for in`
+
+Come per l'operatore `in`, il ciclo `for in` attraversa la catena di
+prototipi quando itera tra le proprietà di un oggetto.
+
+> **Nota:** il ciclo `for in` **non** itererà alcuna proprietà che abbia
+> il proprio attributo `enumerable` impostato su `false`. Ad esempio,
+> la proprietà `lenght` di un array.
+
+    // Modifichiamo Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // stampa sia bar che moo
+    }
+
+Dato che non è possibile modificare il comportamento del ciclo `for in`,
+è necessario filtrare le proprietà indesiderate all'interno del ciclo stesso.
+In ECMAScript 3 o precedente, questo può essere fatto usando il metodo
+[`hasOwnProperty`](#object.hasownproperty) di `Object.prototype`.
+
+A partire da ECMAScript 5, `Object.defineProperty` può essere utilizzato con
+`enumerbale` impostato a `false` per aggiungere proprietà agli oggetti (incluso
+`Object`) senza che queste proprietà vengano enumerate. In questo caso è
+ragionevole assumere che, nel codice di un'applicazione, ogni proprietà
+enumerabile sia stata aggiunta per un motivo, ed quindi omettere `hasOwnProperty`
+in quanto rende il codice più prolisso e meno leggibile. Nel codice delle
+librerie `hasOwnProperty` dovrebbe essere ancora utilizzato, dato che non è
+possibile presumere quali proprietà enumerabili siano presenti nella catena dei
+prototipi.
+
+
+> **Nota:** dato che `for in` attraversa sempre tutta la catena di prototipi,
+> esso rallenterà per ogni strato aggiuntivo di ereditarietà aggiunto ad un
+> oggetto.
+
+### Usare `hasOwnProperty` per il filtraggio
+
+    // questo è il foo dell'esempio precedente
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Questa è la sola versione corretta da usare con le vecchie versioni di ECMAScript.
+Proprio a causa dell'utilizzo di `hasOwnProperty`, **soltanto** `moo` verrà
+stampato; mentre omettendone l'uso, il codice sarà soggetto ad errori nei casi
+dove i prototipi nativi (ad esempio `Object.prototype`) sono stati estesi.
+
+Nelle nuove versioni di ECMAScript, le proprietà non enumerabili possono essere
+definite con `Object.defineProperty`, riducendo il rischio di iterare sulle
+proprietà non usando `hasOwnProperty`. &Egrave; altresì importante stare attenti
+quando si usano librerie come [Prototype][1], che ancora non sfruttano le nuove
+funzionalità di ECMAScript.
+Quando questo framework viene incluso, è sicuro che i cicli `for in` che non
+utilizzano `hasOwnProperty` non funzioneranno.
+
+### In conclusione
+
+Si raccomanda di usare **sempre** `hasOwnProperty` in ECMAScript 3 o precedenti,
+e nel codice delle librerie. Non si dovrebbe mai dare per scontato nell'ambiente
+in cui il codice sta girando, se i prototipi nativi sono stati estesi o meno. A
+partire da ECMAScript 5 `Object.defineProperty` rende possibile definire proprietà
+non enumerabili ed omettere `hasOwnProperty` nel codice dell'applicazione.
+
+[1]: http://www.prototypejs.org/
diff --git a/doc/it/object/general.md b/doc/it/object/general.md
new file mode 100644
index 00000000..bc47d3e9
--- /dev/null
+++ b/doc/it/object/general.md
@@ -0,0 +1,103 @@
+## Utilizzo di oggetti e proprietà
+
+Tutto in JavaScript funziona come un oggetto, con la sola eccezione di
+[`null`](#core.undefined) e [`undefined`](#core.undefined).
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Un'idea comunemente errata è che i numeri letterali non possano essere
+usati come oggetti. Questo a causa di una scorretta gestione da parte del
+parser di JavaScript, che tenta di analizzare la *dot notation* di un
+numero come se fosse un letterale in virgola mobile.
+
+    2.toString(); // solleva SyntaxError
+
+Esistono un paio di soluzioni che possono essere usate per far sì che i
+numeri letterali vengano considerati come oggetti.
+
+    2..toString(); // il secondo punto viene correttamente riconosciuto
+    2 .toString(); // notate lo spazio tra il numero e il punto
+    (2).toString(); // viene prima valutato 2
+
+### Oggetti come un tipo di dato
+
+Gli oggetti in JavaScript possono anche essere usati come [*tabelle hash*][1] e
+consistono principalmente di proprietà con un nome che mappano dei valori.
+
+Usando un oggetto letterale (notazione `{}`) è possibile creare un
+semplice oggetto. Questo nuovo oggetto [eredita](#object.prototype) da
+`Object.prototype` e non ha [proprietà](#object.hasownproperty) definite.
+
+    var foo = {}; // un nuovo oggetto vuoto
+
+    // un nuovo oggetto con una proprietà `test` con valore 12
+    var bar = {test: 12};
+
+### Accedere alle proprietà
+
+&Egrave; possibile accedere alle proprietà di un oggetto in due modi.
+Usando il punto oppure attraverso l'uso delle parentesi quadre.
+
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+
+    var get = 'name';
+    foo[get]; // kitten
+
+    foo.1234; // SyntaxError
+    foo['1234']; // funziona
+
+Le due notazioni funzionano quasi in modo identico, con la sola differenza
+che usando le parentesi quadre è possibile impostare dinamicamente le
+proprietà ed il loro nome identificatore, cosa che altrimenti genererebbe
+un errore di sintassi.
+
+### Cancellazione delle proprietà
+
+Il solo modo per rimuovere una proprietà da un oggetto è quello di usare
+l'operatore `delete`. Impostando la proprietà a `undefined` o `null`, infatti,
+si rimuove solo il *valore* associato alla proprietà, ma non la *chiave*.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+Il codice qui sopra, stamperà sia `bar undefined` che `foo null`. Soltanto
+`baz` è stato rimosso, e quindi non compare nell'output.
+
+### Notazione delle chiavi
+
+    var test = {
+        'case': 'Parola chiave, scrivimi come stringa',
+        // solleva SyntaxError
+        delete: 'Parola chiave, anche io devo essere una stringa'
+    };
+
+Le proprietà di un oggetto possono essere scritte sia come normali caratteri
+che come stringhe. A causa di un altro errore di progettazione del parser di
+JavaScript, il codice appena visto genererà un `SyntaxError` in ECMAScript
+precedente alla versione 5.
+
+Questo errore nasce dal fatto che `delete` è una *parola chiave*, quindi,
+deve essere scritta come una *stringa letterale* per assicurarsi che venga
+correttamente interpretata dai vecchi motori JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/it/object/hasownproperty.md b/doc/it/object/hasownproperty.md
new file mode 100644
index 00000000..71226c10
--- /dev/null
+++ b/doc/it/object/hasownproperty.md
@@ -0,0 +1,58 @@
+## `hasOwnProperty`
+
+Per verificare se un oggetto ha (possiede) una proprietà definita dentro
+**se stesso** piuttosto che in qualche parte della sua
+[catena di prototipi](#object.prototype), è necessario usare il metodo
+`hasOwnProperty` che tutti gli oggetti ereditano da `Object.prototype`.
+
+> **Nota:** **non** è sufficiente verificare se una proprietà è `undefined`.
+> La proprietà potrebbe benissimo esistere, ed il suo valore potrebbe essere
+> impostato a `undefined`.
+
+`hasOwnProperty` è la sola cosa in JavaScript che si occupa delle proprietà
+**senza** attraversare la catena di prototipi.
+
+    // Modifichiamo Object.prototype
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+Solo `hasOwnProperty` darà il risultato atteso e corretto. Guarda la sezione
+[cicli `for in`][#object.forinloop] per maggiori dettagli riguardo a quando
+usare `hasOwnProperty` per iterare le proprietà di un oggetto.
+
+### `hasOwnProperty` come proprietà
+
+JavaScript non protegge il nome di proprietà `hasOwnProperty`. Quindi, se
+esiste la possibilità che un oggetto possa avere una proprietà con questo
+nome, è necessario usare un `hasOwnProperty` *esterno* per ottenere il
+risultato corretto.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // ritorna sempre false
+
+    // Usa un altro hasOwnProperty di Object e lo richiama con 'this' impostato a foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+    // E' anche possibile usare hasOwnProperty dal prototipo di
+    // Object per questo scopo
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+
+
+### In conclusione
+
+Usare `hasOwnProperty` è l'**unico** metodo affidabile per verificare
+l'esistenza di una proprietà in un oggetto. &Egrave; raccomandabile che
+`hasOwnProperty` venga usata in molti casi in cui è necessario iterare le
+proprietà di un oggetto, come descritto nella sezione [cicli `for in`](#object.forinloop).
diff --git a/doc/it/object/prototype.md b/doc/it/object/prototype.md
new file mode 100644
index 00000000..8f8111d1
--- /dev/null
+++ b/doc/it/object/prototype.md
@@ -0,0 +1,126 @@
+## Il prototipo
+
+JavaScript non segue il classico modello di ereditarietà ma, piuttosto,
+utilizza quello *prototipale*.
+
+Anche se ciò viene considerato come uno dei punti più deboli del JavaScript,
+il modello ad ereditarietà prototipale è difatto più potente di quello
+classico. Ad esempio, è piuttosto semplice creare un modello classico
+sulle basi di quello prototipale, mentre l'operazione inversa è piuttosto
+complessa.
+
+JavaScript è il solo linguaggio ampiamente utilizzato che sfrutta l'ereditarietà
+prototipale, quindi è possibile prendersi il proprio tempo per adeguarsi alle
+differenze esistenti tra i due modelli.
+
+La prima grande differenza è che l'ereditarietà in JavaScript utilizza le
+*catene di prototipi*.
+
+> **Nota:** il semplice utilizzo di `Bar.prototype = Foo.prototype` avrà come
+> risultato che entrambe gli oggetti condivideranno lo **stesso** prototipo.
+> Quindi le modifiche ad uno dei prototipi degli oggetti, si rifletteranno
+> anche sull'altro prototipo, che nella maggior parte dei casi non è l'effetto
+> che vogliamo.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Imposta il prototipo di Bar ad una nuova istanza di Foo
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Si assicura di elencare Bar come l'attuale costruttore
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar(); // crea una nuova istanza di bar
+
+    // La catena di prototipi finale
+    test [istanza di Bar]
+        Bar.prototype [istanza di Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* ecc. */ }
+
+Nel codice qui sopra, l'oggetto `test` erediterà sia da `Bar.prototype` che da
+`Foo.prototype`, e quindi avrà accesso alla funzione `method` che era stata
+definita in `Foo`. Avrà anche accesso alla proprietà `value` dell'**unica**
+istanza di `Foo`, cioè il suo prototipo. &Egrave; importante notare come
+`new Bar()` **non** crei una nuova istanza di `Foo`, ma piuttosto riutilizzi
+quella assegnata al suo prototipo. Perciò, tutte le istanze di `Bar`
+condivideranno la **stessa** proprietà `value`.
+
+> **Nota:** **non** usare `Bar.prototype = Foo`, dal momento che questo non
+> lo farà puntare al prototipo di `Foo`, ma piuttosto alla funzione oggetto
+> `Foo`. Quindi la catena di prototipi passerà per `Function.prototype`
+> invece che `Foo.prototype`. Perciò, `method` non sarà presente nella catena
+> di prototipi.
+
+### Tabella delle proprietà
+
+Quando si accede alle proprietà di un oggetto, JavaScript **risale** la
+catena di prototipi fino a che non incontra una proprietà con il nome
+richiesto.
+
+Se raggiunge la cima della catena (cioè `Object.prototype`) senza aver
+trovato le specifica proprietà, ritorna il valore [undefined](#core.undefined).
+
+### La proprietà Prototype
+
+Anche se la proprietà prototype viene usata dal linguaggio per creare la
+catena di prototipi, è comunque sempre possibile assegnarvi un **qualsiasi**
+dato valore. Nonostante cio, i dati primitivi verranno semplicemente ignorati
+quando assegnati ad un prototipo.
+
+    function Foo() {}
+    Foo.prototype = 1; // nessun effetto
+
+L'assegnazione di oggetti, come mostrato nell'esempio precedente, funzionerà,
+e permette la creazione dinamica di catene di prototipi.
+
+### Performance
+
+Il tempo di ricerca per proprietà presenti in alto (all'inizio) della catena
+di prototipi, può avere un impatto negativo sulla performance, e questo deve
+essere tenuto bene in considerazione in codice dove la performance è un fattore
+critico. Inoltre, il tentativo di accedere a proprietà inesistenti obbligherà
+comunque ad attraversare tutta la catena di prototipi.
+
+Oltre a ciò, [iterando](#object.forinloop) tra le proprietà di un oggetto,
+**ogni** proprietà presente nella catena di prototipi verrà enumerata.
+
+### Estensione di prototipi nativi
+
+Una caratteristica che viene spesso abusata, è quella di estendere
+`Object.prototype` o uno degli altri prototipi interni al linguaggio.
+
+Questa tecnica viene detta [monkey patching][1] e vìola il principio di
+*incapsulamento*. Anche se usata da popolari framework come [Prototype][2],
+non c'è una valida ragione per pasticciare, aggiungendo ai tipi interni del
+linguaggio funzionalità **non standard**.
+
+La **sola** buona ragione per estendere un prototipo interno è quella di
+effettuare il backport di funzionalità presenti nei motori JavaScript
+più recenti, come ad esempio [`Array.forEach`][3].
+
+### In conclusione
+
+&Egrave; **essenziale** capire il modello di ereditarietà prototipale prima
+di scrivere codice complesso che ne faccia uso. Bisogna, inoltre, tenere
+sotto controllo la lunghezza della catena di prototipi nel proprio codice,
+e suddividerla in più catene se necessario, per evitare possibili problemi di
+performance. Inoltre, i prototipi nativi non dovrebbero **mai** essere
+estesi a meno che non sia per garantire compatibilità con le funzionalità
+più recenti di JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/it/other/timeouts.md b/doc/it/other/timeouts.md
new file mode 100644
index 00000000..da216d54
--- /dev/null
+++ b/doc/it/other/timeouts.md
@@ -0,0 +1,180 @@
+### `setTimeout` e `setInterval`
+
+Dato che JavaScript è asincrono, è possibile programmare l'esecuzione di una
+funzione usando le funzioni `setTimeout` e `setInterval`.
+
+> **Nota:** i timeout **non** sono parte dello standard ECMAScript. Erano stati
+> implementati in [BOM, o DOM Level 0][1], i quali non sono mai stati definiti
+> o documentati formalmente. Nessuna specifica raccomandazione è mai stata
+> pubblicata, tuttavia, la loro standardizzazione è in via di ultimazione con
+> [HTML5][2]. Per loro stessa natura, quindi, l'implementazione può essere
+> differente nei vari browser e motori di rendering.
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // ritorna un Number > 0
+
+Quando chiamato, `setTimeout` ritorna l'ID del timeout e programma `foo` per
+essere eseguito **approssimativamente** un migliaio di millisecondi nel futuro.
+`foo` verrà quindi eseguito **una volta**.
+
+Dipendendo dalla risoluzione del timer del motore JavaScript che esegue il codice,
+come anche dal fatto che JavaScript è single threaded e quindi altro codice
+potrebbe essere eseguito bloccando il thread, **non è mai** sicuro scommettere
+che una funzione verrà eseguita esattamente al ritardo specifiato nella chiamata
+a `setTimeout`.
+
+La funzione che è stata passata come primo parametro verrà chiamata dall'*oggetto globale*,
+e ciò significa che [`this`](#function.this) all'interno della funzione chiamata
+farà riferimento all'oggetto globale.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this fa riferimento all'oggetto globale
+            console.log(this.value); // stamperà undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+> **Nota:** dato che `setTimeout` accetta un **oggetto funzione** come suo
+> primo parametro, un errore comune è quello di usare `setTimeout(foo(), 1000)`,
+> che userà il **valore di ritorno** della chiamata a `foo` e **non** `foo`.
+> Questo è, la maggior parte delle volte, un errore silenzioso, dato che quando
+> la funzione ritorna `undefined` `setTimeout` **non** solleverà alcun errore.
+
+### Sovrapposizione di chiamate con `setInterval`
+
+Mentre `setTimeout` esegue solo una volta la funzione, `setInterval` (come il
+nome suggerisce) eseguirà la funzione **ogni** `X` millisecondi, ma il suo
+utilizzo è sconsigliato.
+
+Quando il codice che viene eseguito blocca la chiamata timeout, `setInterval`
+eseguirà ancora più chiamate alla specifica funzione. Questo può, specialmente
+con intervalli molto brevi, tradursi in chiamate a funzione che si sovrappongono.
+
+    function foo(){
+        // qualcosa che blocca per 1 secondo
+    }
+    setInterval(foo, 1000);
+
+Nel codice precedente, `foo` verrà chiamato una volta e quindi bloccherà per
+un secondo.
+
+Mentre `foo` blocca il codice, `setInterval` continuerà a programmare ulteriori
+chiamate ad essa. Ora, quando `foo` ha finito, ci saranno già **dieci** ulteriori
+chiamate ad essa in attesa per essere eseguite.
+
+### Gestione di potenziale codice bloccante
+
+La soluzione più semplice, come anche la più controllabile, è quella di usare
+`setTimeout` all'interno di se stessa.
+
+    function foo(){
+        // qualcosa che blocca per 1 secondo
+        setTimeout(foo, 1000);
+    }
+    foo();
+
+Non solo questo incapsula la chiamata a `setTimeout`, ma previene anche la
+sovrapposizione delle chiamate e da un controllo addizionale. `foo` stessa
+può ora decidere se vuole continuare ad essere eseguita oppure no.
+
+### Pulizia manuale dei timeout
+
+La pulizia di timeout ed intervalli funziona passando il rispettivo ID a
+`clearTimeout` o `clearInterval`, in base a quale `set` di funzioni è stato
+usato precedentemente.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Pulizia di tutti i timeout
+
+Dato che non c'è un metodo interno per la pulizia di tutti i timeout e/o
+intervalli, è necessario usare la forza bruta per poter raggiungere questo
+scopo.
+
+    // pulisce "tutti" i timeout
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+Ma ci potrebbero ancora essere timeout che non vengono toccati da questo
+numero arbitrario. Un altro modo per ottenere ciò, è considerare che l'ID
+dato ad un timeout viene incrementato di uno ogni volta che si chiama
+`setTimeout`.
+
+    // pulisce "tutti" i timeout
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+Sebbene questo funzioni con la maggior parte dei browser odierni, non è
+specificato che gli ID debbano essere ordinati in quel modo e ciò potrebbe
+anche cambiare in futuro. Perciò, si raccomanda di tener traccia di tutti
+gli ID dei timeout, così che possano essere puliti in modo specifico.
+
+### Uso nascosto di `eval`
+
+`setTimeout` e `setInterval` possono anche accettare una stringa come loro
+primo parametro. Questa caratteristica non dovrebbe essere **mai** usata
+perché internamente fa uso di `eval`.
+
+> **Nota:** L'esatto funzionamento quando viene passata una stringa
+> potrebbe differire nelle varie implementazioni di JavaScript. Per esempio,
+> JScript di Microsoft usa il costruttore `Function` al posto di `eval`.
+
+    function foo() {
+        // verrà chiamata
+    }
+
+    function bar() {
+        function foo() {
+            // non verrà mai chiamata
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Dal momento che `eval` non viene chiamata [direttamente](#core.eval) in questo
+caso, la stringa passata a `setTimeout` verrà eseguita nello *scope globale*.
+Quindi, non verrà usata la variabile locale `foo` dallo scope di `bar`.
+
+Si raccomanda inoltre di **non** usare una stringa per passare argomenti alla
+funzione che verrà chiamata da una delle funzioni di timeout.
+
+    function foo(a, b, c) {}
+
+    // non usare MAI questo
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // Usare invece una funzione anonima
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **Nota:** mentre è ancora possibile usare la sintassi
+> `setTimeout(foo, 1000, 1, 2, 3)`, non la si raccomanda, dato che il suo
+> utilizzo potrebbe portare ad errori subdoli quando usata con i
+> [metodi](#function.this).
+> Inoltre, la sintassi potrebbe non funzionare in alcune implementazioni di
+> JavaScript.
+> Ad esempio, Internet Explorer di Microsoft [**non** passa direttamente gli argomenti al callback](3).
+
+### In conclusione
+
+Una stringa non dovrebbe **mai** essere usata come parametro di `setTimeout` o
+`setInterval`. &Egrave; un chiaro segno di codice **veramente** pessimo, quando
+gli argomenti necessitano di essere passati alla funzione che deve essere
+chiamata. Dovrebbe invece essere passata una *funzione anonima* che si incarichi
+di gestire l'effettiva chiamata.
+
+Inoltre, l'uso di `setInterval` dovrebbe essere evitato perché il suo schedulatore
+non viene bloccato dall'esecuzione di JavaScript.
+
+[1]: http://www.nczonline.net/blog/2009/09/29/web-definitions-dom-ajax-and-more/ "Web definitions: DOM, Ajax, and more"
+[2]: http://www.w3.org/TR/2014/WD-html5-20140617/webappapis.html#timers "6 Web application APIs - HTML5"
+[3]: http://msdn.microsoft.com/en-us/library/ie/ms536753(v=vs.85).aspx "setTimeout method (Internet Explorer)"
diff --git a/doc/it/types/casting.md b/doc/it/types/casting.md
new file mode 100644
index 00000000..5da767f0
--- /dev/null
+++ b/doc/it/types/casting.md
@@ -0,0 +1,75 @@
+## Conversione di tipo (Type Casting)
+
+JavaScript è un linguaggio **debolmente tipizzato**, perciò esso applicherà
+una *conversione di tipo* **ovunque** sia possibile.
+
+    // Queste sono vere
+    new Number(10) == 10; // l'oggetto Number viene convertito
+                          // in una primitiva numero tramite chiamata implicita
+                          // al metodo Number.prototype.valueOf
+
+    10 == '10';           // String viene convertita in Number
+    10 == '+10 ';         // Stringa più assurda
+    10 == '010';          // a ancora di più
+    isNaN(null) == false; // null viene convertito in 0
+                          // che ovviamente non è NaN
+
+    // Queste sono false
+    10 == 010;
+    10 == '-10';
+
+> **ES5 Nota:** i numeri letterali che iniziano per `0` vengono interpretati
+> come ottali (base 8). Il supporto per gli ottali è stato **rimosso** nello
+> strict mode di ECMAScript 5.
+
+Per evitare i problemi appena visti, l'uso
+dell'[operatore di uguaglianza stretta](#types.equality) è **altamente**
+raccomandato. Sebbene questo eviti molti dei comuni problemi, ci sono ancora
+molti ulteriori problemi che possono essere generati dal sistema debolmente
+tipizzato di JavaScript.
+
+### Costruttori di tipi interni
+
+I costruttori dei tipi interni del linguaggio, come `Number` e `String`,
+funzionano in modo differente a seconda che venga usata o meno la
+parola chiave `new`.
+
+    new Number(10) === 10;     // False, Object e Number
+    Number(10) === 10;         // True, Number e Number
+    new Number(10) + 0 === 10; // True, a causa della conversione implicita
+
+L'uso di un tipo di dato interno come `Number` come costruttore, creerà un
+nuovo oggetto `Number`, ma l'omissione della parola chiave `new` farà sì
+che la funzione `Number` agisca da convertitore.
+
+Inoltre, il passaggio di valori letterali o non oggetto risulterà in un'ancora
+maggiore conversione di tipo.
+
+La miglior opzione è quella di fare **esplicitamente** la conversione ad uno
+dei tre possibili tipi.
+
+### Convertire in una stringa
+
+    '' + 10 === '10'; // true
+
+Anteponendo una stringa vuota, un valore può facilmente essere convertito in
+una stringa.
+
+### Convertire in un numero
+
+    +'10' === 10; // true
+
+Usando l'operatore **unario** di addizione, è possibile convertire in un numero.
+
+### Convertire in un booleano
+
+Usando due volte l'operatore **not**, un valore può essere convertito in un
+booleano.
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
diff --git a/doc/it/types/equality.md b/doc/it/types/equality.md
new file mode 100644
index 00000000..9a289190
--- /dev/null
+++ b/doc/it/types/equality.md
@@ -0,0 +1,75 @@
+## Uguaglianza e comparazioni
+
+JavaScript usa due differenti metodi per comparare l'uguaglianza dei
+valori degli oggetti.
+
+### L'operatore di uguaglianza
+
+L'operatore di uguaglianza consiste di due segni di uguaglianza: `==`.
+
+JavaScript supporta la **tipizzazione debole**. Questo significa che
+l'operatore di uguaglianza **converte** i tipi in modo da poterli
+confrontare.
+
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+Questa tabella mostra i risultati della conversione di tipo, ed è il
+principale motivo per cui l'uso di `==` è ampiamente considerato una
+cattiva pratica. Esso introduce bug difficili da rilevare a causa delle
+complesse regole di conversione.
+
+Inoltre, c'è anche un impatto sulla performance quando entra in gioco la
+conversione di tipo. Ad esempio, una stringa deve essere convertita in un
+numero prima di poter essere confrontata con un altro numero.
+
+### L'operatore di uguaglianza stretta
+
+L'operatore di uguaglianza stretta consiste di **tre** segni di uguaglianza: `===`.
+
+Funziona come il normale operatore di uguaglianza, con l'eccezione di
+**non** eseguire la conversione di tipo tra gli operandi.
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+I risultati qui sono più chiari e permettono di identificare subito un problema
+con il codice. Questo rende il codice più solido di un certo grado e fornisce anche
+migliorie alla performance nel caso di operandi di tipo differente.
+
+### Comparazione di oggetti
+
+Nonostante `==` e `===` vengano definiti operatori di **uguaglianza**, essi
+funzionano differentemente quando almeno uno degli operandi è un `Object`.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+Qui, entrambe gli operatori confrontano per **identità** e **non** per
+uguaglianza. Essi confrontano, cioè, che sia la stessa **istanza** dell'oggetto,
+in modo molto simile a `is` in Python e la comparazione di puntatori in C.
+
+### In conclusione
+
+Si raccomanda calorosamente di usare solo l'operatore di **uguaglianza stretta**.
+Nei casi dove è necessario che i tipi vengano convertiti, questa operazione
+dovrebbe essere fatta [esplicitamente](#types.casting) piuttosto che essere
+lasciata alle complesse regole di conversione del linguaggio.
+
diff --git a/doc/it/types/instanceof.md b/doc/it/types/instanceof.md
new file mode 100644
index 00000000..8ff454f4
--- /dev/null
+++ b/doc/it/types/instanceof.md
@@ -0,0 +1,41 @@
+## L'operatore `instanceof`
+
+L'operatore `instanceof` confronta i costruttori dei suoi due operandi.
+&Egrave; utile soltanto per la comparazione di oggetti realizzati dal
+programmatore. Se usato sui tipi interni del linguaggio, esso è
+praticamente inutile alla stregua dell'[operatore typeof](#types.typeof).
+
+### Confronto di oggetti personalizzati
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // Questo imposta Bar.prototype all'oggetto funzione Foo,
+    // ma non ad un'istanza di Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### Uso di `instanceof` con i tipi nativi
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+Un'importante cosa da notare qui è che `instanceof` non funziona con oggetti
+originati da differenti contesti JavaScript (ad esempio, differenti
+documenti in un browser web), dato che i loro costruttori non saranno
+esattamente lo stesso oggetto.
+
+### In conclusione
+
+L'operatore `instanceof` dovrebbe essere usato **solo** quando si ha a che fare
+con oggetti personalizzati creati dal programmatore, che provengono dallo
+stesso contesto JavaScript. Proprio come per l'operatore [`typeof`](#types.typeof),
+ogni altro tipo di utilizzo dovrebbe essere **evitato**.
+
diff --git a/doc/it/types/typeof.md b/doc/it/types/typeof.md
new file mode 100644
index 00000000..4c9732f3
--- /dev/null
+++ b/doc/it/types/typeof.md
@@ -0,0 +1,87 @@
+## L'operatore `typeof`
+
+L'operatore `typeof` (assieme a [`instanceof`](#types.instanceof)) è
+probabilmente il più grande difetto di progettazione di JavaScript,
+dato che è quasi **completamente inusabile**.
+
+Sebbene `instanceof` abbia ancora limitati casi d'uso, `typeof` ha realmente
+un solo caso d'uso, che **non** è quello di verificare il tipo di un oggetto.
+
+> **Nota:** mentre `typeof` può anche essere richiamato usando una sintassi
+> simile a quella di una funzione (ad esempio, `typeof(obj)`), questa non è
+> una funzione. Le parentesi funzionano normalmente e il valore di ritorno
+> viene usato come operando per l'operatore `typeof`. **Non** esiste una
+> funzione `typeof`.
+
+### Tabella dei tipi di JavaScript
+
+    Valore              Classe     Tipo
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+In questa tabella, *Tipo* fa riferimento al valore ritornato dall'operatore `typeof`.
+Come si può chiaramente vedere, questo valore è tutto fuorchè affidabile.
+
+*Classe* si riferisce al valore della proprietà interna `[[Class]]` di un oggetto.
+
+> **Da specifiche:** il valore di `[[Class]]` può essere una delle seguenti
+> stringhe: `Arguments`, `Array`, `Boolean`, `Date`, `Error`, `Function`,
+> `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+Per ottenere il valore di `[[Class]]`, bisogna usare il metodo `toString` di
+`Object.prototype`.
+
+### La classe di un oggetto
+
+Le specifiche forniscono esattamente un modo per accedere al valore di
+`[[Class]]`, con l'uso di `Object.prototype.toString`.
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+Nel esempio qui sopra, `Object.prototype.toString` viene chiamato con il valore
+di [this](#function.this) impostato all'oggetto di cui si vuole ottenere il
+valore di `[[Class]]`.
+
+> **ES5 Nota:** per comodità, il valore di ritorno di `Object.prototype.toString`
+> per `null` e `undefined` è stato **cambiato** da `Object` a `Null` e
+> `Undefined` in ECMAScript 5.
+
+### Testare variabili non definite
+
+    typeof foo !== 'undefined'
+
+Questo esempio verificherà se `foo` è stata attualmente dichiarata oppure no.
+Un semplice referenziamento ad essa risulterebbe in un `ReferenceError`.
+Questo è l'unico caso in cui `typeof` è utile a qualcosa.
+
+### In conclusione
+
+Per verificare il tipo di un oggetto, è altamente raccomandato l'utilizzo di
+`Object.prototype.toString`, dato che questo è il solo modo affidabile per
+fare ciò. Come mostrato nella tabella precedente, alcuni valori di ritorno
+di `typeof` non sono definiti nelle specifiche, e ciò dimostra come essi
+potrebbero differire tra implementazioni differenti.
+
+A meno che non si debba verificare se una variabile è definta, `typeof`
+dovrebbe essere evitato.
+
diff --git a/doc/ja/array/constructor.md b/doc/ja/array/constructor.md
new file mode 100644
index 00000000..17b64718
--- /dev/null
+++ b/doc/ja/array/constructor.md
@@ -0,0 +1,25 @@
+## `Array`コンストラクター
+
+`Array`コンストラクターはそのパラメーターの扱い方が曖昧なので、新しい配列を作る時には、常に配列リテラル - `[]`記法 - を使用する事を強くお勧めします。
+
+    [1, 2, 3]; // 結果: [1, 2, 3]
+    new Array(1, 2, 3); // 結果: [1, 2, 3]
+
+    [3]; // Result: [3]
+    new Array(3); // 結果: []
+    new Array('3') // 結果: ['3']
+
+このケースの場合、`Array`コンストラクターに渡される引数は一つだけですが、その引数は`Number`になります。コンストラクターは、引数に値がセットされた`length`プロパティを伴った新しい*疎*配列を返します。特筆すべきなのは、新しい配列の`length`プロパティ**のみ**が、このようにセットされるという事です。実際の配列のインデックスは初期化されません。
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, インデックスがセットされていない
+
+配列の長さが先行してセットされるという振舞いは、いくつかの場合に便利です。例えば、文字の繰り返しや、`for loop`を使用したコードの回避などの場合です。
+
+    new Array(count + 1).join(stringToRepeat);
+
+### 終わりに
+
+`Array`コンストラクターの使用は出来る限り避けてください。リテラルが当然望ましい形です。それらは、短かく明快な文法をもっている為に、コードの可読性を高めてくれます。
+
diff --git a/doc/ja/array/general.md b/doc/ja/array/general.md
new file mode 100644
index 00000000..7afc71df
--- /dev/null
+++ b/doc/ja/array/general.md
@@ -0,0 +1,41 @@
+## 配列の繰り返しとプロパティ
+
+JavaScriptの配列もまたオブジェクトですが、[`for in ループ`](#object.forinloop)を配列の繰り返し処理で使用することの良い理由は1つもありません。実際、配列に`for in`を使用**しない**為の正当な理由はたくさんあります。
+
+> **注意:** JavaScriptの配列は*連想配列*では**ありません**。JavaScriptは[objects](#object.general)だけがキーバリューをマッピングするものです。
+> また、連想配列は順序を**保持**しますが、オブジェクトは**保持しません**。
+
+`for in`ループはプロトタイプチェーン上の全てのプロパティを列挙するため、[`hasOwnProperty`](#object.hasownproperty)をそれらのプロパティの存在判定に使います。この為、通常の`for`ループよりも**20倍**遅くなります。
+
+### 繰り返し
+
+配列の要素を繰り返すとのに、最高のパフォーマンスを出したければ昔ながらの`for`ループを使うのが一番です。
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+上記の例では1つ追加の仕掛けがありますが、それは`l = list.length`によって配列の長さをキャッシュする部分です。
+
+`length`プロパティは配列自身に定義されてはいますが、ループ中の繰り返しで毎回これを参照してしまうと、やはりオーバーヘッドが存在してしまいます。最近のJavaScriptエンジンはこのような場合に最適化する**はず**ですが、コードが新しいエンジンで実行されるかどうか、知る方法はありません。
+
+実際には、キャッシュを抜きにするとループの結果はキャッシュされたものに比べてたった**半分の速度**にしかなりません。
+
+### `length`プロパティ
+
+`length`プロパティの*ゲッター*は単に配列に含まれる要素の数を返すだけにも関わらず、*セッター*は配列を**トランケート**する為にも使用できます。
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo; // [1, 2, 3]
+
+より小さいlengthを割り当てると配列をトランケートしますが、lengthが大きくなっても配列には何も影響しません。
+
+### 終わりに
+
+最高のパフォーマンスの為には、常に`for`ループを使用し、`length`プロパティをキャッシュする事をお勧めします。`for in`ループを配列で使用するのは、バグや最低のパフォーマンスの傾向があるコードを書く前兆になります。
+
diff --git a/doc/ja/core/delete.md b/doc/ja/core/delete.md
new file mode 100644
index 00000000..424cd336
--- /dev/null
+++ b/doc/ja/core/delete.md
@@ -0,0 +1,75 @@
+## `delete`演算子
+
+端的に言って、JavaScriptの関数やその他の要素は`DontDelete`属性が設定されているので、グローバル変数を消去する事は*不可能*です。
+
+### グローバルコードと関数コード
+
+変数や、関数がグローバルまたは[関数スコープ](#function.scopes)で定義された時は、そのプロパティは有効なオブジェクトかグローバルオブジェクトになります。このようなプロパティは属性のセットを持っていますが、それらの内の1つが`DontDelete`になります。変数や関数がグローバルや関数コードで宣言されると、常に`DontDelete`属性を作るために、消去できません。
+
+    // グローバル変数:
+    var a = 1; // DontDelete属性が設定される
+    delete a; // false
+    a; // 1
+
+    // 通常関数:
+    function f() {} // DontDelete属性が設定される
+    delete f; // false
+    typeof f; // "function"
+
+    // 再代入も役に立たない:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### 明示的なプロパティ
+
+明示的にプロパティを設定することが、通常通りの消去を可能にします。
+
+    // プロパティを明示的に設定する
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+上記の例の中で、`obj.x`と`obj.y`はそれぞれ`DontDelete`属性が無い為に消去できます。これが下記の例でも動作する理由です。
+
+    // IE以外では、これも動作する
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - ただのグローバルのvar
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+ここでは`a`. [`this`](#function.this)を消す為にグローバルオブジェクトと明示的に宣言した`a`をそのプロパティとして参照させて、消去する事を許可するトリックを使います。
+
+IE(最低でも6-8で)は多少のバグがある為に、上記のコードは動作しません。
+
+
+### 関数の引数と組み込み引数
+
+関数の通常の引数である、[`arguments` objects](#function.arguments)と組み込みのプロパティもまた、`DontDelete`が設定されています。
+
+    // 関数の引数とプロパティ:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### ホストオブジェクト
+
+`delete`演算子の挙動はホストオブジェクトにとって予測不可能になりかねません。仕様によりホストオブジェクトは、あらゆる挙動の実行が許可されている為です。
+
+### 終わりに
+
+`delete`演算子は、しばしば予期せぬ挙動をします。唯一安全な使用方法は通常のオブジェクトに明示的に設定されたプロパティを扱う場合だけです。
diff --git a/doc/ja/core/eval.md b/doc/ja/core/eval.md
new file mode 100644
index 00000000..846d32c1
--- /dev/null
+++ b/doc/ja/core/eval.md
@@ -0,0 +1,39 @@
+## なぜ、`eval`を使ってはいけないのか
+
+`eval`関数はローカルスコープ中のJavaScriptコードの文字列を実行します。
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+
+しかし、`eval`は**直接**ローカルスコープから呼ばれて、*かつ*呼んだ関数の名前が実際の`eval`でないと実行しません。
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+`eval`の使用は**全てのコスト**を払ってでも回避するべきです。その「使用法」の99.9%で、これ**無し**でも実装できます。
+
+### 偽装された`eval`
+
+[timeout functions](#other.timeouts)である`setTimeout`と`setInterval`はどちらも最初の引数として文字列を取る事ができます。この文字列は`eval`がこの場合直接呼ばれていないので、**常に**グローバルスコープで実行されてしまいます。
+
+### セキュリティの問題
+
+`eval`はまたセキュリティの問題もあります。なぜなら、**どんな**コードを与えられても実行してしまうからで、**絶対**に不明または信頼できない発行元の文字列は使ってはいけません。
+
+### 終わりに
+
+`eval`は絶対に使用しないでください。これを使用しているどんなコードも、その働き、パフォーマンスやセキュリティについて問われてしまいます。`eval`が必要な場合でも、最初の段階で使用**しない**でください。*より良いデザイン*を使用するべきで、それには`eval`を使う必要性はありません。
+
diff --git a/doc/ja/core/semicolon.md b/doc/ja/core/semicolon.md
new file mode 100644
index 00000000..d3bf4a24
--- /dev/null
+++ b/doc/ja/core/semicolon.md
@@ -0,0 +1,102 @@
+## セミコロン自動挿入
+
+JavaScriptはC言語スタイルのシンタックスを持っていますが、これはソースコードの中でセミコロンの使用を強制している事には**ならない**ので、これらを省略する事も可能です。
+
+JavaScriptはセミコロン無しの言語ではありません。実際に、ソースコードを理解する為にもセミコロンは必要になります。ですので、JavaScriptのパーサーはセミコロンが無い事によるパースエラーを検出する度に、**自動的**にセミコロンを挿入します。
+
+    var foo = function() {
+    } // セミコロンが入っている事が期待されるので、パースエラーになる
+    test()
+
+挿入が起こると、パーサーはもう一度パースします。
+
+    var foo = function() {
+    }; // エラーが無いので、パーサーは次の解析をする
+    test()
+
+セミコロンの自動挿入は、コードの振る舞いを変えられる為に、言語の**最大**の欠陥の内の一つと考えられています。
+
+### どのように動くか
+
+以下のコードはセミコロンが無いので、パーサーはどこにセミコロンを挿入するか決めなくてはなりません。
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+下記がパーサーの「推測」ゲームの結果になります。
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // 行がマージされて、挿入されない
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- 挿入
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- 挿入
+
+            return; // <- inserted, breaks the return statement
+            { // ブロックとして扱われる
+
+                // a label and a single expression statement
+                foo: function() {} 
+            }; // <- 挿入
+        }
+        window.test = test; // <- 挿入
+
+    // 再度行がマージされる
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- 挿入
+
+    })(window); //<- 挿入
+
+> **注意点:** JavaScriptパーサーは、すぐ後に改行が続く return文を正しく扱いません。
+> これは必ずしも自動セミコロン挿入の欠点によるものではありませんが、
+> それもまた望まない副作用となりえます。
+
+
+パーサーは上記のコードの振舞いを劇的に変化させます。あるケースにおいては、**間違っている事**にもなってしまいます。
+
+### 先頭の括弧
+
+先頭に括弧がある場合、パーサーはセミコロンを挿入**しません**。
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+このコードは1つの行に変形します。
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+`log`が関数を返さ**ない**確率は**とても**高いです。しかし、上記では`undefined is not a function`という`TypeError`が繰り返されます。
+
+### 終わりに
+
+セミコロンを省略するのは**絶対**にお勧めしません。括弧を対応する文と同じ行に記述すること、および一行の`if / else`文に対して括弧を省略しないことが推奨されています。これら両方の処理がコードの整合性を高めてくれるだけでなく、JavaScriptパーサーの振舞いを変えてしまうのを防いでくれるでしょう。
diff --git a/doc/ja/core/undefined.md b/doc/ja/core/undefined.md
new file mode 100644
index 00000000..ac8761a4
--- /dev/null
+++ b/doc/ja/core/undefined.md
@@ -0,0 +1,53 @@
+## `undefined`と`null`
+
+JavaScriptは`nothing`を表す2つの別個の値を持っています。これら2つの内で`undefined`はより便利な存在です。
+
+### `undefined`の値
+
+`undefined`はただ1つの値`undefined`を持つ型です。
+
+この言語はまた、`undefined`の値を持つグローバル変数を定義しています。この値もまた`undefined`と呼ばれています。しかし、この変数は **どちらも** 言語のキーワードではなく、定数です。この事はこの*値*は簡単に上書きされてしまうという事になります。
+
+> **ES5での注意点:** ECMAScript 5での`undefined`は **もはや** strict modeでは *書き変えられない*
+> ようになっています。しかし、この名前は`undefined`という名前の関数の例に痕跡が見られるだけです。
+
+`undefined`が返される時の例をいくつか挙げます。
+
+ - (未定義の)グローバル変数`undefined`にアクセスした時
+ - `return`文が無い為に、暗黙のうちに関数が返された時
+ - 何も返されない`return`がある時
+ - 存在しないプロパティを探索する時
+ - 関数のパラメーターで明示的な値が何も無い時
+ - `undefined`が設定された全ての値
+
+### `undefined`の値に変更する処理
+
+グローバル変数`undefined`のみが実際の`undefined`の*値*のコピーを保持するので、これに新しい値を代入しても`undefined`の*型* の値が変更される事は**ありません**。
+
+まだ、`undefined`の値に対して何かしらの比較をしないといけない場合は、最初に`undefined`の値を取得する必要があります。
+
+コードの`undefined`の変数の上書きを可能な限りしないよう保護する為には、一般的なテクニックとして[anonymous wrapper](#function.scopes)の引数にパラメーターを追加するというものがあります。
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // ローカルスコープではundefined。
+        // ここで値に対して参照がされる
+
+    })('Hello World', 42);
+
+同じ効果を得る事ができる別の方法として、ラッパーの内部での宣言を使うものがあります。
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+これらの唯一の違いは、こちらのバージョンの方が4バイト余計に短縮できるという物です。また、他に`var`ステートメントは匿名ラッパーの中にはありません。
+
+### `null`の使用
+
+JavaScriptというプログラム言語のコンテキストの中では、`undefined`は主に伝統的な意味での*null*の意味で使用される事が多いです。実際の`null`(リテラルも型も両方)は多かれ少なかれ、単なるデータ型です。
+
+それはJavaScriptの内部でいくつか使われています(プロトタイプチェーンの終わりに`Foo.prototype = null`という宣言をするようなもの)が、ほとんど全てのケースで、`undefined`に置き替える事が可能です。
diff --git a/doc/ja/function/arguments.md b/doc/ja/function/arguments.md
new file mode 100644
index 00000000..cb0982c9
--- /dev/null
+++ b/doc/ja/function/arguments.md
@@ -0,0 +1,98 @@
+## オブジェクトの`arguments`
+
+JavaScriptの全ての関数スコープは`arguments`と呼ばれる特別な変数にアクセスできます。この変数は関数が受け取った全ての引数を保持する変数です。
+
+> **注意:** `arguments`が既に`var`や正式なパラメーターにより
+> 関数のスコープ内部で定義されている場合は
+> `arguments`オブジェクトは作られません。
+
+`arguments`オブジェクトは`Array`では**ありません**。これは配列と同じような -`length`プロパティと名付けられています- 文法を持っていますが、`Array.prototype`を継承している訳では無いので、実際`Object`になります。
+
+この為、`arguments`で`push`や`pop`、`slice`といった通常の配列メソッドは使用する事が**出来ません**。プレーンな`for`ループのような繰り返しでは上手く動作しますが、通常の`Array`メソッドを使いたい場合は本当の`Array`に変換しなければなりません。
+
+### 配列への変換
+
+下のコードは`arguments`オブジェクトの全ての要素を含んだ新しい`Array`を返します。
+
+    Array.prototype.slice.call(arguments);
+
+この変換は**遅い**です。コードのパフォーマンスに関わる重要な部分での使用は**推奨しません**。
+
+### 引き数の受け渡し
+
+下記の例はある関数から別の関数に引数を引き渡す際に推奨される方法です。
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // do stuff here
+    }
+
+他のテクニックとして、高速で非結合のラッパーとして`call`と`apply`両方を一緒に使用するという物があります。
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // "メソッド"の非結合バージョンを作成する
+    // このメソッドはthis, arg1, arg2...argNのパラメーターを持っている
+    Foo.method = function() {
+
+        // 結果: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### 仮パラメーターと引数のインデックス
+
+`arguments`オブジェクトは*ゲッター*と*セッター*機能を自身のプロパティと同様に関数の仮パラメーターとして作成します。
+
+結果として、仮パラメーターを変更すると`arguments`の対応する値も変更されますし、逆もしかりです。
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### パフォーマンスの神話と真実
+
+`arguments`オブジェクトは、関数の内部の名前宣言と仮パラメーターという2つの例外を常に持ちながら生成されます。これは、使用されているかどうかは関係がありません。
+
+*ゲッター*と*セッター*は両方とも**常に**生成されます。その為これを使用してもパフォーマンスに影響は全くといって言い程ありません。`arguments`オブジェクトのパラメーターに単純にアクセスしているような、実際のコードであれば尚更です。
+
+> **ES5での注意:** strictモードでは、これら*ゲッター*と*セッター*は生成されません。
+
+しかし、一つだけモダンJavaScriptエンジンにおいて劇的にパフォーマンスが低下するケースがあります。そのケースとは`arguments.callee`を使用した場合です。
+
+    function foo() {
+        arguments.callee; // この関数オブジェクトで何かする
+        arguments.callee.caller; // そして関数オブジェクトを呼び出す
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // 通常はインライン展開する
+        }
+    }
+
+上記のコードでは、`foo`は自身と自身の呼び出し元の両方を知らないと[インライン展開][1]の対象になる事が出来ません。この事は、インライン展開によるパフォーマンスの向上の機会を失くす事になり、また、特定のコンテクストの呼び出しに依存する関数のせいで、カプセル化が解除されてしまいます。
+
+この為に`arguments.callee`を使用または、そのプロパティを**決して**使用しない事を**強く推奨**します。
+
+> **ES5での注意:** strictモードでは、`arguments.callee`は推奨されていない為に
+> `Typeerror`が返るようになっています。
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
+
diff --git a/doc/ja/function/closures.md b/doc/ja/function/closures.md
new file mode 100644
index 00000000..718f84c5
--- /dev/null
+++ b/doc/ja/function/closures.md
@@ -0,0 +1,78 @@
+## クロージャと参照
+
+JavaScriptの一番パワフルな特徴の一つとして*クロージャ*が使える事が挙げられます。これはスコープが自身の定義されている外側のスコープに**いつでも**アクセスできるという事です。JavaScriptの唯一のスコープは[関数スコープ](#function.scopes)ですが、全ての関数は標準でクロージャとして振る舞います。
+
+### プライベート変数をエミュレートする
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+ここで`Counter`は**2つ**のクロージャを返します。関数`increment`と同じく関数`get`です。これら両方の関数は`Counter`のスコープを**参照**し続けます。その為、そのスコープ内に定義されている`count`変数に対していつもアクセスできるようになっています。
+
+### なぜプライベート変数が動作するのか？
+
+JavaScriptでは、スコープ自体を参照・代入する事が出来無い為に、外部から変数`count`にアクセスする手段が**ありません**。唯一の手段は、2つのクロージャを介してアクセスする方法だけです。
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+上記のコードは`Counter`のスコープ中にある変数`count`の値を変更する事は**ありません**。`foo.hack`は**その**スコープで定義されていないからです。これは(`Counter`内の変数`count`の変更)の代わりに*グローバル*変数`count`の作成 -または上書き- する事になります。
+
+### ループ中のクロージャ
+
+一つ良くある間違いとして、ループのインデックス変数をコピーしようとしてか、ループの中でクロージャを使用してしまうというものがあります。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);
+        }, 1000);
+    }
+
+上記の例では`0`から`9`の数値が出力される事は**ありません**。もっと簡単に`10`という数字が10回出力されるだけです。
+
+**匿名**関数は`i`への**参照**を維持しており、同時に`forループ`は既に`i`の値に`10`をセットし終った`console.log`が呼ばれてしまいます。
+
+期待した動作をする為には、`i`の値の**コピー**を作る必要があります。
+
+### 参照問題を回避するには
+
+ループのインデックス変数をコピーする為には、[匿名ラッパー](#function.scopes)を使うのがベストです。
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+外部の匿名関数は`i`を即座に第一引数として呼び出し、引数`e`を`i`の**値**のコピーとして受け取ります。
+
+`e`を参照している`setTimeout`を受け取った匿名関数はループによって値が変わる事が**ありません。**
+
+他にこのような事を実現する方法があります。それは匿名ラッパーから関数を返してあげる事です。これは上記のコードと同じ振る舞いをします。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
diff --git a/doc/ja/function/constructors.md b/doc/ja/function/constructors.md
new file mode 100644
index 00000000..94561c08
--- /dev/null
+++ b/doc/ja/function/constructors.md
@@ -0,0 +1,103 @@
+## コンストラクタ
+
+JavaScriptのコンストラクタは色々ある他のプログラム言語とは一味違います。`new`キーワードが付いているどんな関数呼び出しも、コンストラクタとして機能します。
+
+コンストラクタ内部では -呼び出された関数の事です- `this`の値は新規に生成された`Object`を参照しています。この**新規**のオブジェクトの[`prototype`](#object.prototype)は、コンストラクタとして起動した関数オブジェクトの`prototype`に設定されています。
+
+もし呼び出された関数が、`return`ステートメントを明示していない場合は、暗黙の了解で`this`の値を -新規のオブジェクトとして- 返します。
+
+    function Foo() {
+        this.bla = 1;
+    }
+
+    Foo.prototype.test = function() {
+        console.log(this.bla);
+    };
+
+    var test = new Foo();
+
+上記は、`Foo`をコンストラクタとして呼び出し、新規に生成されたオブジェクトの`prototype`を`Foo.prototype`に設定しています。
+
+明示的に`return`ステートメントがある場合、関数は返り値が`Object`である場合に**限り**ステートメントで明示した値を返します。
+
+    function Bar() {
+        return 2;
+    }
+    new Bar(); // 新しいオブジェクト
+
+    function Test() {
+        this.value = 2;
+
+        return {
+            foo: 1
+        };
+    }
+    new Test(); // 返ってきたオブジェクト
+
+`new`キーワードが省略されている場合は、関数は新しいオブジェクトを返す事は**ありません**。
+
+    function Foo() {
+        this.bla = 1; // グローバルオブジェクトに設定される
+    }
+    Foo(); // undefinedが返る
+
+JavaScriptの[`this`](#function.this)の働きのせいで、上記の例ではいくつかのケースでは動作するように見える場合がありますが、それは*グローバルオブジェクト*が`this`の値として使用されるからです。
+
+### ファクトリー
+
+`new`キーワードを省略するためには、コンストラクタ関数が明示的に値を返す必要があります。
+
+    function Bar() {
+        var value = 1;
+        return {
+            method: function() {
+                return value;
+            }
+        }
+    }
+    Bar.prototype = {
+        foo: function() {}
+    };
+
+    new Bar();
+    Bar();
+
+`Bar`で呼び出されたものは両方とも全く同じものものになります。これには、`method`と呼ばれるプロパティを持ったオブジェクトが新しく生成されますが、これは[クロージャ](#function.closures)です。
+
+また、注意する点として呼び出された`new Bar()`は返ってきたオブジェクトのプロトタイプに影響**しません**。プロトタイプは新しく生成されたオブジェクトにセットされはしますが、`Bar`は絶対にその新しいオブジェクトを返さないのです。
+
+上記の例では、`new`キーワードの使用の有無は機能的に違いがありません。
+
+
+### ファクトリーとして新しくオブジェクトを作成する
+
+多くの場合に推奨される事として、`new`の付け忘れによるバグを引き起こしやすいので、`new`を使用**しない**ようにするという事があります。
+
+新しいオブジェクトを作成するためにファクトリーを使用して、そのファクトリー内部に新しいオブジェクトを作成すべきだという事です。
+
+    function Foo() {
+        var obj = {};
+        obj.value = 'blub';
+
+        var private = 2;
+        obj.someMethod = function(value) {
+            this.value = value;
+        }
+
+        obj.getPrivate = function() {
+            return private;
+        }
+        return obj;
+    }
+
+上記の例では`new`キーワードが無いため堅牢になりますし、確実に[プライベート変数](#function.closures)を使用するのが簡単になりますが、いくつかの欠点があります。
+
+ 1. 作られたオブジェクトがプロトタイプ上のメソッドを共有しないために、よりメモリーを消費してしまいます。
+ 2. ファクトリーを継承するために、他のオブジェクトの全てのメソッドをコピーする必要があるか、新しいオブジェクトのプロトタイプ上にそのオブジェクトを設置する必要があります。
+ 3. `new`キーワードが無いという理由だけで、プロトタイプチェーンから外れてしまうのは、どことなく言語の精神に反します。
+
+### 終わりに
+
+`new`キーワードが省略される事によりバグの可能性がもたらされますが、それによりプロトタイプを全く使わないという確かな理由には**なりません**。最終的には、アプリケーションの必要性により、どちらの解決法がより良いかが決まってきます。特に大切なのは、オブジェクトの作成に特定のスタイルを選ぶ事、また**そのスタイルに固執する事**です。
+
+
diff --git a/doc/ja/function/general.md b/doc/ja/function/general.md
new file mode 100644
index 00000000..f53e2dd3
--- /dev/null
+++ b/doc/ja/function/general.md
@@ -0,0 +1,37 @@
+## 関数の宣言と式
+
+関数はJavaScriptの第一級オブジェクトです。この事は、その他の値と同じように渡す事が出来るという事です。この機能で良く使われる一つとして**匿名関数**を他のオブジェクトにコールバックとして渡すというものがあり、これで非同期での実装が可能になります。
+
+### `関数`宣言
+
+    function foo() {}
+
+上記の関数はプログラムの開始時の前に評価されるように[巻き上げ](#function.scopes)られます。従って*定義*されたスコープ内の*どこでも*使用する事が可能になります。ソース内での実際の定義が呼ばれる前でもです。
+
+    foo(); // このコードが動作する前にfooが作られているので、ちゃんと動作する
+    function foo() {}
+
+### `関数`式
+
+    var foo = function() {};
+
+この例では、`foo`という変数に無名で*匿名*の関数が割り当てられています。
+
+    foo; // 'undefined'
+    foo(); // これはTypeErrorが起こる
+    var foo = function() {};
+
+`var`は宣言である為に、変数名`foo`がコードが開始される実際の評価時より前のタイミングにまで巻き上げられています。`foo`は既にスクリプトが評価される時には定義されているのです。
+
+しかし、コードの実行時にのみこの割り当てがされるため、`foo`という変数は対応するコードが実行される前にデフォルト値である[undefined](#core.undefined)が代入されるのです。
+
+### 名前付き関数式
+
+他に特殊なケースとして、名前付き関数があります。
+
+    var foo = function bar() {
+        bar(); // 動作する
+    }
+    bar(); // ReferenceError
+
+この場合の`bar`は`foo`に対して関数を割り当てるだけなので、外部スコープでは使用できません。しかし、`bar`は内部では使用できます。これはJavaScriptの[名前解決](#function.scopes)の方法によるもので、関数名は*いつも*関数自身のローカルスコープ内で有効になっています。
diff --git a/doc/ja/function/scopes.md b/doc/ja/function/scopes.md
new file mode 100644
index 00000000..ddbe08c6
--- /dev/null
+++ b/doc/ja/function/scopes.md
@@ -0,0 +1,195 @@
+## スコープと名前空間
+
+JavaScriptはブロックに2つのペアの中括弧を使うのが素晴しいですが、これはブロックスコープをサポートして**いません**。その為、この言語に残されているのは*関数スコープ*だけです。
+
+    function test() { // スコープ
+        for(var i = 0; i < 10; i++) { // スコープではない
+            // 数える
+        }
+        console.log(i); // 10
+    }
+
+> **注意:** 代入が使用されてない時、return文や関数の引数、`{...}`表記はブロック文として
+> 解釈されて、オブジェクトリテラルとは**なりません**。これは[セミコロン自動挿入](#core.semicolon)
+> と連動して奇妙なエラーを引き起こすことになります。
+
+JavaScriptはまた明確な名前空間を持ちません。この事は全て一つの*グローバルで共有された*名前空間で定義されるという事です。
+
+変数が参照されるまでの間、JavaScriptはスコープ全てを遡って参照を探索します。グローバルスコープまで遡っても要求した名前が無いと`ReferenceError`が発生します。
+
+### グローバル変数の致命傷
+
+    // スクリプト A
+    foo = '42';
+
+    // スクリプト B
+    var foo = '42'
+
+上記の2つのスクリプトは同じ効果を持って**いません**。スクリプト Aは`foo`と呼ばれる変数を、*グローバル*スコープに定義しており、スクリプト Bは`foo`を*現在*のスコープで定義ています。
+
+繰り返しますが、この2つのスクリプトは*同じ影響*を全く持って**いない**スクリプトになります。`var`を使用しない事は重大な意味を持ちます。
+
+    // グローバルスコープ
+    var foo = 42;
+    function test() {
+        // ローカルスコープ
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+`test`関数の中の`var`ステートメントを省略すると`foo`の値をオーバーライドします。最初の内は大した事ではないように思いますが、JavaScriptが何千行規模になると、`var`を使っていない事でバグの追跡が酷く困難になります。
+
+    // グローバルスコープ
+    var items = [/* 何かのリスト */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // サブループのスコープ
+        for(i = 0; i < 10; i++) { // varステートメントが無くなった
+            // 素敵な実装を！
+        }
+    }
+
+外側のループは`subloop`が最初に呼ばれた後に終了します。なぜなら、`subloop`がグローバル変数`i`の値で上書きされているからです。2番目の`for`ループに`var`を使用する事によって簡単にこのエラーを回避する事ができます。*目的とする効果*を外側のスコープに与えようとしない限り、**絶対**に`var`ステートメントは省略してはいけません。
+
+### ローカル変数
+
+JavaScriptのローカル変数の為の唯一の作成方法は[function](#function.general)パラメーターと`var`ステートメントによって宣言された変数になります。
+
+    // グローバルスコープ
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // 関数testのローカル変数
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+`foo`と`i`は、関数`test`のスコープ内のローカル変数ですが、`bar`の代入は同じ名前でグローバル変数で上書きしてしまいます。
+
+### 巻き上げ
+
+JavaScriptは宣言を**巻き上げ**ます。これは`var`ステートメントと`function`宣言が、それらを含むスコープの一番先頭に移動するという事を意味します。
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+上記のコードは、実行を開始する前に変換されてしまいます。JavaScriptは`var`ステートメントと同じように、直近で囲んでいる`function`宣言を先頭に移動させます。
+
+    // varステートメントはここに移動する
+    var bar, someValue; // 'undefined'がデフォルト
+
+    // function宣言もここに移動する
+    function test(data) {
+        var goo, i, e; // 無くなったブロックスコープはこちらに移動する
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // barが'undefined'のままなので、Typeerrorで呼び出し失敗
+    someValue = 42; // 割り当てすると巻き上げの影響を受けない
+    bar = function() {};
+
+    test();
+
+ブロックスコープの欠落は`var`ステートメントをループやボディの外に移動するだけでなく、`if`の構成を直感的ではないものにしてしまいます。
+
+元のコードの中の`if`ステートメントは*グローバル変数*である`goo`も変更しているように見えますが、実際には -巻き上げが適用された後に- *ローカル変数*を変更しています。
+
+*巻き上げ*についての知識がないと、下に挙げたコードは`ReferenceError`になるように見えます。
+
+    // SomeImportantThingが初期化されているかチェックする
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+しかし、勿論上記の動きは`var`ステートメントが*グローバルスコープ*の上に移動しているという事実に基づいています。
+
+    var SomeImportantThing;
+
+    // 他のコードがSomeImportantThingをここで初期化するかもしれないし、しないかもしれない
+
+    // SomeImportantThingがある事を確認してください
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### 名前解決の順序
+
+JavaScriptの*グローバルスコープ*を含む、全てのスコープは、*現在のオブジェクト*を参照している特殊な名前[`this`](#function.this)を持っています。
+
+関数スコープはまた、[`arguments`](#function.arguments)という名前も持っています。それは関数スコープの中で定義され、関数に渡された引数を含んでいます。
+
+例として、関数の中で`foo`と命名された変数にアクセスしようとする場合を考えましょう。JavaScriptは以下の順番で、その名前を探索しようとします。
+
+ 1. `var foo`ステートメントが現在のスコープで使われている場合
+ 2. `foo`という名前の関数パラメーターが存在するかどうか
+ 3. 関数それ自体が`foo`として呼ばれているかどうか
+ 4. 一つ外のスコープに行き、再度**#1**から始める
+
+> **注意:** `arguments`と呼ばれるパラメーターを持つという事は、デフォルトの`arguments`
+> オブジェクトを生成するのを**阻害**します。
+
+
+### 名前空間
+
+一つしかグローバルの名前空間を持たない事による良くある問題は変数名の衝突による問題の起きる可能性です。JavaScriptでは、この問題を*匿名関数ラッパー*の助けで簡単に回避できます。
+
+    (function() {
+        // "名前空間"に自分を含む
+
+        window.foo = function() {
+            // 露出したクロージャ
+        };
+
+    })(); // 即座に関数を実行する
+
+
+無名関数は[expressions](#function.general)とみなされ、呼び出し可能になり最初に評価されます。
+
+    ( // カッコ内の関数が評価される
+    function() {}
+    ) // 関数オブジェクトが返される
+    () // 評価の結果が呼び出される
+
+関数式を評価し、呼び出す別の方法として構文は違いますが、同様の動作をするのが下記です。
+
+    // 2つの別の方法
+    +function(){}();
+    (function(){}());
+
+### 終わりに
+
+自身の名前空間にカプセル化する為に常に*匿名関数ラッパー*を使用する事を推奨します。これは、コードを名前衝突から守る為だけでなく、プログラムのより良いモジュール化の為でもあります。
+
+さらに、グローバル変数の使用は**悪い習慣**と考えられています。**一回**でもグローバル変数を使用するとエラーが発生しやすく、メンテナンスがしにくいコードになってしまいます。
+
diff --git a/doc/ja/function/this.md b/doc/ja/function/this.md
new file mode 100644
index 00000000..88a35390
--- /dev/null
+++ b/doc/ja/function/this.md
@@ -0,0 +1,93 @@
+## `this`はどのように動作するのか
+
+JavaScriptの`this`と名付けられた特殊なキーワードは他のプログラム言語と違うコンセプトを持っています。JavaScriptの`this`は正確に**5個**の別々の使い道が存在しています。
+
+### グローバルスコープとして
+
+    this;
+
+`this`をグローバルスコープ内で使用すると、単純に*グローバル*オブジェクトを参照するようになります。
+
+
+### 関数呼び出しとして
+
+    foo();
+
+この`this`は、再度*グローバル*オブジェクトを参照しています。
+
+> **ES5での注意:** strictモードでは、このグローバルのケースは**もはや**存在していません。
+> この場合`this`は`undefined`値を代わりに持つことになります。
+
+### メソッド呼び出しとして
+
+    test.foo(); 
+
+この例では`this`は`test`を参照します。
+
+### コンストラクター呼び出し
+
+    new foo(); 
+
+`new`キーワードが付いた関数呼び出しは[コンストラクター](#function.constructors)として機能します。関数内部では`this`は*新規に作成された*`Object`を参照します。
+
+### `this`の明示的な設定
+
+    function foo(a, b, c) {}
+
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // 配列は下記で展開される
+    foo.call(bar, 1, 2, 3); // 結果はa = 1, b = 2, c = 3
+
+ `Function.prototype`の`call`や`apply`メソッドを使用した時には、呼び出された関数の内部での`this`の値は、対応する関数呼び出しの最初の引数に**明示的に設定**されます。
+
+結果として、上記の例では*メソッドケース*が適用**されず**、`foo`の内部の`this`は`bar`に設定されます。
+
+> **注意:** `this`は`Object`リテラル内部のオブジェクトを参照**しません**。
+> ですので、`var obj = {me: this}`での`me`は`obj`を参照**しません**。
+> `this`はここで紹介ている5個のケースの内どれか一つに束縛されます。
+
+### 良くある落し穴
+
+これらのケースのほとんどは理にかなったものですが、最初のケースは実際に利用されることが**絶対**にないので、間違った言語設計だとみなせるでしょう。
+
+    Foo.method = function() {
+        function test() {
+            // このファンクションはグローバルオブジェクトに設定される
+        }
+        test();
+    };
+
+良くある誤解として`test`の中の`this`が`Foo`を参照しているというものがありますが、そのような事実は**一切**ありません。
+
+`test`の中の`Foo`にアクセスする為には、`Foo`を参照する`method`のローカル変数を作る必要があります。
+
+    Foo.method = function() {
+        var that = this;
+        function test() {
+            // ここでthisの代わりに使用する
+        }
+        test();
+    };
+
+`that`は通常の変数名ですが、外部の`this`の参照の為に良く使われます。[クロージャ](#function.closures)と組み合わせる事で`this`の値を渡す事ができるようになります。
+
+### メソッドの割り当て
+
+JavaScriptを使用する上で、もう一つ動か**ない**ものが関数のエイリアスです。これは変数へメソッドを**割り当て**する事です。
+
+    var test = someObject.methodTest;
+    test();
+
+最初のケースの`test`は通常の関数呼び出しになる為に、この中の`this`は、もはや`someobject`を参照できなくなってしまいます。
+
+`this`の遅延バインディングは最初見た時にはダメなアイデアに見えますが、[プロトタイプ継承](#object.prototype)により、きちんと動作します。
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+`method`が`Bar`のインスタンスにより呼び出された時に、`this`はまさにそのインスタンスを参照するようになります。
diff --git a/doc/ja/index.json b/doc/ja/index.json
new file mode 100644
index 00000000..00814ba0
--- /dev/null
+++ b/doc/ja/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden in Japanese",
+    "description": "JavaScriptの奇妙さと欠陥についてのガイドライン",
+    "sections": [
+        {
+            "title": "前書き",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "オブジェクト",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "関数",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "配列",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "型",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "コア",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "その他",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/ja/intro/index.md b/doc/ja/intro/index.md
new file mode 100644
index 00000000..9ce45ec0
--- /dev/null
+++ b/doc/ja/intro/index.md
@@ -0,0 +1,38 @@
+## 前書き
+
+**JavaScript Garden** はJavaScriptというプログラム言語の一番奇妙な部分についてのドキュメント集です。
+このドキュメントはJavaScriptという言語に慣れていないプログラマーがこの言語について深く知ろうとする際に遭遇する、良くある間違い・小さなバグ・パフォーマンスの問題・悪い習慣などを避ける為のアドバイスを与えます。
+
+JavaScript GardenはJavaScriptを教える事を**目的にしていません**。このガイドの項目を理解する為には、この言語に対する前提知識がある事を推奨します。この言語の基礎部分についてはMozilla Developer Networkの[ガイド][1] がオススメです。 
+
+## 著者
+
+このガイドは愛すべき[Stack Overflow][2]の2人のユーザー[Ivo Wetzel][3]
+(執筆)と[Zhang Yi Jiang][4] (デザイン)によって作られました。
+
+## 貢献者
+
+- [貢献者](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## ホスティング
+
+JavaScript GardenはGitHubでホスティングされていますが、[Cramer Development][7]が[JavaScriptGarden.info][8]というミラーサイトを作ってくれています。
+
+## ライセンス
+
+JavaScript Gardenは[MIT license][9]の下で公開されており、[GitHub][10]でホスティングされています。もしもエラーやtypoを見つけたら[file an issue][11]に登録するかリポジトリにプルリクエストを送ってください。
+またStack Overflowチャットの[JavaScript room][12]に私達はいます。
+
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/ja/object/forinloop.md b/doc/ja/object/forinloop.md
new file mode 100644
index 00000000..180620be
--- /dev/null
+++ b/doc/ja/object/forinloop.md
@@ -0,0 +1,42 @@
+## `for in`ループ
+
+`in`オペレーターは単に、`for in`ループの中でオブジェクトのプロパティをプロトタイプチェーンの中で繰り返し遡る為にあるものです。
+
+> **注意:** `for in`ループは`enumerable`属性が`false`にセットされているプロパティを反復処理**しません**。;
+> 例えば、配列の`length`プロパティなどがそれに当たります。
+
+    // Object.prototype汚染
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // barとmooが両方とも表示される
+    }
+
+`for in`ループそれ自体の動作を変更する事は不可能ですが、ループ内にある要らないプロパティをフィルタリングする必要があります。そんな時は`Object.prototype`の[`hasOwnProperty`](#object.hasownproperty)メソッドを使うと解決します。
+
+> **注意:** `for in`は常にプロトタイプチェーンを完全に遡ります。これにより
+> オブジェクトに追加されている継承が多ければ多い程、速度は遅くなります。
+
+### `hasOwnProperty`をフィルタリングに使用する
+
+    // 継承されているfoo
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+このループの唯一正しい使い方がこの方法です。`hasOwnProperty`を使用しているので、
+`moo`**のみ**が表示されるようになります。`hasOwnProperty`が省略されている場合は、このコードは
+組み込みのプロトタイプが存在する場合に(特に`Object.prototype`が拡張されている場合)エラーを発生しやすくなります。
+
+一般に広く使用されているJavaScriptフレームワークとして[Prototype][1]が挙げられます。このフレームワークには、
+`for in` 内で`hasOwnProperty`が使用されプロトタプチェーン内を頭まで遡るのを中断する事が保証されています。
+
+### 終わりに
+
+**常に**`hasOwnProperty`を使用する事を推奨します。コードの実行環境や、組み込みのプロトタイプが拡張されているかどうかを仮定して書くようなコードを絶対書いてはいけません。
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/ja/object/general.md b/doc/ja/object/general.md
new file mode 100644
index 00000000..1878247f
--- /dev/null
+++ b/doc/ja/object/general.md
@@ -0,0 +1,83 @@
+## オブジェクトの使用法とプロパティ
+
+JavaScriptの全ての要素は2つの例外を除いて、オブジェクトのように振る舞います。
+その2つとは[`null`](#core.undefined)と[`undefined`](#core.undefined)です。
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+良くありがちな誤解として、数値リテラルがオブジェクトとして使用できないというものがあります。この理由としては、JavaScriptパーサーが浮動小数点のドットを*ドット記法*として解釈しようとしてしまうからです。
+
+    2.toString(); // シンタックスエラーが発生する
+
+数値リテラルをオブジェクトとして使用する為の回避策がいくつかあります。
+
+    2..toString(); // 2つ目のドットが正しく解釈される
+    2 .toString(); // ドットの左隣のスペースがポイント
+    (2).toString(); // 2が一番最初に評価される
+
+### オブジェクトはデータタイプ
+
+JavaScriptのオブジェクトは[*ハッシュマップ*][1]としても使用されます。これは名前付きのプロパティと値として構成されています。
+
+オブジェクトリテラル(`{}`記法)を使用すると、オブジェクトそのものを作る事ができます。この方法で作られたオブジェクトは`Object.prototype`から[継承](#object.prototype)され、[own properties](#object.hasownproperty)が何も設定されてない状態になります。
+
+    var foo = {}; // 新しい空のオブジェクト
+
+    // 12という値の'test'というプロパティを持った新しいオブジェクト
+    var bar = {test: 12}; 
+
+### プロパティへのアクセス
+
+オブジェクトのプロパティには2通りのアクセス方法があります。1つはドット記法によるアクセス、もう1つはブラケット記法です。
+
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+
+    var get = 'name';
+    foo[get]; // kitten
+
+    foo.1234; // シンタックスエラー
+    foo['1234']; // 動作する
+
+どちらの記法も働きとしての違いは無いですが、唯一の違いとしてブラケット記法は通常のプロパティ名と同様に動的にプロパティを設定する事ができます。これ以外で動的にプロパティを設定しようとするとシンタックスエラーになります。
+
+### プロパティの削除
+
+実際にオブジェクトからプロパティを削除する唯一の方法は`delete`演算子を使う事です。プロパティに`undefined`や`null`をセットしても、プロパティ自身ではなく、*キー*に設定された*値*を削除するだけです。
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+上記の例では、`baz`は完全に削除されて出力がされていませんが、それ以外の2つ`bar undefined`と`foo null`はどちらも出力されてしまっています。
+
+### キーの記法
+
+    var test = {
+        'case': 'I am a keyword so I must be notated as a string',
+        delete: 'I am a keyword too so me' // シンタックスエラーが起こる
+    };
+
+オブジェクトのプロパティは普通の文字か文字列として記述する事が出来ます。JavaScriptパーサーの設計ミスが原因ですが、ECMAScript5以前では上記のコードは`シンタックスエラー`を表示するでしょう。
+
+このエラーは`delete`が*予約語*になっているのが原因なので、古いJavaScriptエンジンに正しく解釈させる為には*文字リテラル*を使って記述する事を推奨します。
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/ja/object/hasownproperty.md b/doc/ja/object/hasownproperty.md
new file mode 100644
index 00000000..7b02305f
--- /dev/null
+++ b/doc/ja/object/hasownproperty.md
@@ -0,0 +1,44 @@
+## `hasOwnProperty`
+
+オブジェクトは*自分自身*と**自分以外**のどちらで定義されたプロパティかを[prototype chain](#object.prototype)のどこかでチェックしなくてはなりません。これは`Object.prototype`から継承される全てのオブジェクトの`hasOwnProperty`メソッドを使う必要があります。
+
+> **注意:** この方法はプロパティが`undefined`かどうかを調べるには十分では**無い**方法です。
+> プロパティは、ほとんどのオブジェクトで存在しているはずの物ではありますが、`undefined`が
+> 値に設定される事態は起こり得ます。
+
+`hasOwnProperty`はJavaScriptで唯一プロトタイプチェーン内を**遡らず**にプロパティを扱う事が出来ます。
+
+    // Object.prototype汚染
+    Object.prototype.bar = 1; 
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+`hasOwnProperty`だけが、正しく期待した結果を出すでしょう。これはあらゆるオブジェクトのプロパティの繰り返し処理をする時必須の事です。オブジェクト*自身*に定義されておらず、プロトタイプチェーンのどこかには定義されているというプロパティを除外する手段が他に**ありません**。
+
+### プロパティとしての`hasOwnProperty`
+
+JavaScriptはプロパティ名として`hasOwnProperty`を保護して**いません**。;従って、この名前のプロパティを持ったオブジェクトが存在する事がありえます。正しい結果を得る為には*外部*の`hasOwnProperty`を使う必要があります。
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // 常にfalseを返す
+
+    // 他のオブジェクトのhasOwnPropertyを使い、fooの'this'にセットして呼び出す
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+### 終わりに
+
+オブジェクトのプロパティの存在判定をする時は、`hasOwnProperty`が**唯一**のメソッドになります。
+また、**全て**の[`for in` ループ](#object.forinloop)内で`hasOwnProperty`を使う事を推奨します。
+そうする事により組み込みの[prototypes](#object.prototype)の拡張が原因のエラーを避ける事が出来ます。
+
diff --git a/doc/ja/object/prototype.md b/doc/ja/object/prototype.md
new file mode 100644
index 00000000..a38ff3f5
--- /dev/null
+++ b/doc/ja/object/prototype.md
@@ -0,0 +1,86 @@
+## プロトタイプ
+
+JavaScriptはクラスベース継承モデルは実装されておらず、この代わりに*プロトタイプ*を用いています。
+
+プロトタイプモデルを使っている事が、JavaScriptの弱点の一つになっていると良く考えられがちですが、プロトタイプ継承モデルはクラスベース継承モデルよりパワフルだというのは事実です。この事はちょっとしたものでもクラスベースの継承で実装しようとすると、プロトタイプベースの継承よりも作業が難しくなるという事でも分かります。
+
+JavaScriptはプロトタイプベースが採用されている唯一の広範に使用されている基本的なプログラミング言語という現実があるので、プロトタイプベースとクラスベースの違いを時々調整しないとなりません。
+
+最初の大きな違いはJavaScriptの継承は*プロトタイプチェーン*と呼ばれるもので実行されているという事です。
+
+> **注意:** 単に`Bar.prototype = Foo.prototype`を使った場合、両方のオブジェクトは、
+> **同じ**プロトタイプを共有する事になります。その為、片方のオブジェクトのプロトタイプの変更は
+> もう一方のオブジェクトに影響します。殆どの場合、このような影響を及ぼしたく無いと思います。
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // BarのプロトタイプをFooの新しいインスタンスとしてセットする
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Barを実際のコンストラクタとして確実にする為に代入する
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar() // 新しくbarインスタンスを作成
+
+    // プロトタイプチェーンの結果
+    test [instance of Bar]
+        Bar.prototype [instance of Foo] 
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* その他 */ }
+
+上記では`test`は`Bar.prototype`と`Foo.prototype`の2つのオブジェクトより継承されます。その為`Foo`の中で設定された`method`関数にアクセスできるようになります。また、`Foo`のプロトタイプとしてのインスタンス**それ自体**の`value`プロパティにもアクセスが可能です。`new Bar()`は`Foo`のインスタンスを新しく作**りません**が、プロトタイプに割り合てられた`Foo`インスタンスを再利用している事は注目に値します。従って全ての`Bar`インスタンスは**同じ**`value`プロパティを共有します。
+
+> **注意:** `Bar.prototype = Foo`のような使い方は**しない**で下さい。`Foo`はそのプロトタイプではなく、
+> 関数オブジェクト`Foo`自体を指しているからです。
+> プロトタイプチェーンは`Foo.prototype`ではなく`Function.prototype`まで遡るので、
+> `method`はプロトタイプチェーン上に出現しなくなります。
+
+### プロパティ探索
+
+オブジェクトのプロパティにアクセスする時には、JavaScriptはプロトタイプチェーンを要求された名前を見つけるまで**遡って**探索します。
+
+チェーンの先頭(すなわち`Object.prototype`)に到達した際に、まだ指定されたプロパティが見つからなければ、代わりに[undefined](#core.undefined)という値を返します。
+
+### プロトタイププロパティ
+
+プロトタイププロパティはJavaScriptの中でプロトタイプチェーンを構築する為に使われていますが、**任意**の値を代入する事も可能になっています。しかし、プロトタイプとしてプリミティブが代入された場合は単に無視されるだけです。
+
+    function Foo() {}
+    Foo.prototype = 1; // 効果無し
+
+オブジェクトの代入は上記の例のように動作し、動的にプロトタイプチェーンを作る事ができます。
+
+### パフォーマンス
+
+プロトタイプチェーンの上位にあるプロパティを探索する時間はコードの実行パフォーマンスに重大な悪影響を与えます。特に存在しないプロパティにアクセスしようとすると、プロトタイプチェーンの全てのプロパティを探索してしまいます。
+
+また、オブジェクトのプロパティに対して[反復](#object.forinloop)処理をすると、プロトタイプチェーン上の**全て**のプロパティを列挙してしまいます。
+
+
+### 既存のプロトタイプの拡張
+
+元々組み込まれてるプロトタイプや`Object.prototype`を拡張するのは、良くありがちなイケていない実装方法になります。
+
+このテクニックは[monkey patching][1]と呼ばれるもので*カプセル化*を壊してしまいます。このテクニックは[Prototype][2]のようなフレームワークにより広まりましたが、*非標準*の機能を持っている組み込み型のオブジェクトの乱立という点でも推奨されません。
+
+**唯一**組み込みのプロトタイプを拡張しても良い理由としては、JavaScriptエンジンに将来実装されるであろう機能の移植だけです。
+例えば[`Array.forEach`][3]などが、それに当たります。
+
+### 終わりに
+
+ここまでがプロトタイプベース継承モデルを使って複雑なコードを書く前に**必ず**理解すべき事です。また、プロパティチェーンの長さを観察して、もしパフォーマンスに悪影響を及ぼすのを防ぐ為ならば、これを分割をしなければなりません。さらに組み込みのプロトタイプは新しいJavaScriptの機能と互換性が無い限りは**絶対**に拡張してはいけません。
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/ja/other/timeouts.md b/doc/ja/other/timeouts.md
new file mode 100644
index 00000000..fd8efcd1
--- /dev/null
+++ b/doc/ja/other/timeouts.md
@@ -0,0 +1,125 @@
+### `setTimeout`と`setInterval`
+
+JavaScriptは非同期なので、`setTimeout`と`setInterval`関数を使ってある関数の実行のスケジュールを決める事が可能です。
+
+> **注意点:** タイムアウトはECMAScript標準の一部では**ありません**。
+> これらは[DOM][1]の一部として実装されています。
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // Number > 0を返す
+
+`setTimeout`が呼ばれた時に、タイムアウトのIDを返し、この先**おおよそ**1000ms以内に実行する`foo`をスケジュールします。`foo`は正確に**1度**だけ実行されます。
+
+これは、`setTimeout`関数の呼び出しで指定した遅延時間を正確に間違いなく得られるという**事では決してありません**。コードが実行されているJavaScriptエンジンのタイマー分解能によって決まります。この事実はJavaScriptがシングルスレッドなので、他のスレッドでの実行を妨害してしまう事があるかもしれません。
+
+第一パラメーターを渡された関数は*グローバルオブジェクト*によって呼び出されます。これは呼び出された関数の内部で[`this`](#functionis)がまさにこのオブジェクトを参照しているという事になります。
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // これはグローバルオブジェクトを参照しています
+            console.log(this.value); // undefinedを記録するはずです
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+
+> **注意点:** `setTimeout`は**関数オブジェクト**を第一引数に取ります。
+> 良く間違えてしまう使い方として`setTimeout(foo(), 1000)`というものがあります。
+> `foo`と`foo`**以外**の呼び出しに対する**戻り値**としてしまいます。これは、大体において、
+> 関数が`undefined`になる為に表に出ないエラーになるでしょう。`setTimeout`はどんな
+> エラーも発生`させません`。
+
+### `setInterval`でスタッキングコール
+
+`setTimeout`は関数を一度だけ実行します。`setInterval` - 名前が示すように - **毎回**`X`ミリ秒毎に関数を実行しますが、この使用は推奨されていません。
+
+コードがタイムアウト呼び出しブロックで実行される時に、`setInterval`は指定された関数を呼び出します。これは、特に小さい間隔で、関数の結果をスタックに積む事ができます。
+
+    function foo(){
+        // 1秒おきにブロックの何かを実行
+    }
+    setInterval(foo, 100);
+
+上記のコードでは、`foo`が1回呼び出されて、1秒ブロックされます。
+
+`foo`がコードをブロックしている間、`setInterval`は呼び出される予定を確保しています。`foo`が完了した瞬間に、実行を待っている呼び出しが**10回**以上存在しているでしょう。
+
+### ブロッキング可能なコードの取り扱い
+
+簡単かつ、一番コントロール可能な解決法として、関数自体の中で`setTimeout`を使うという方法があります。
+
+    function foo(){
+        // 1秒ブロックする何か
+        setTimeout(foo, 100);
+    }
+    foo();
+
+このカプセル化は`setTimeout`の呼び出しだけでなく、呼び出しのスタッキングを防止してより詳細なコントロールが出来ます。`foo`それ自身が今や、再度実行するかしないかを決める事が出来るのです。
+
+### 手動でタイムアウトをクリアする
+
+タイムアウトとインターバルのクリアは、`clearTimeout`か`clearInterval`に個別のIDを渡せば出来ます。最初に`set`関数を使った場所に依存します。
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### 全てのタイムアウトをクリアする
+
+全てのタイムアウトや、インターバルをクリアする組み込みメソッドが無い為、機能的にクリアする為には暴力的な手段を使う必要があります。
+
+    // "全ての"タイムアウトをクリアする
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+ここまでもまだ、任意の数字を与えられた為に影響を受けないタイムアウトがあるかもしれません。そのため、代わりに全てのタイムアウトのIDを追跡する事が推奨されます。それで個別にクリアされます。
+
+### 隠された`eval`の使用
+
+`setTimeout`と`setInterval` は、第一引数に文字列を取る事が可能です。この仕様は内部で`eval`を使用する為に、**絶対に**使うべきではありません。
+
+> **注意点:** タイムアウト関数はECMAScript標準では制定されて**いない**為、
+> 文字列を引数にした場合に厳密な動作は色々なJavaScript実装により異なります。
+> 例えば、MicrosoftのJScriptは`eval`の代わりに`Function`コンストラクターを
+> 使用します。
+
+    function foo() {
+        // この先呼ばれる
+    }
+
+    function bar() {
+        function foo() {
+            // 絶対に呼ばれない
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+この場合、`eval`は[直接](#core.eval)呼ばれないので、文字列が渡された`setTimeout`は*global scope*で実行されます。よって、`bar`のスコープから`foo`のローカル変数は使われないのです。
+
+いずれかのタイムアウト関数によって呼び出される関数に引数を渡すために文字列を使わ**ない**という事は、さらに推奨されています。
+
+    function foo(a, b, c) {}
+
+    // 絶対にこのように使わない
+    setTimeout('foo(1,2, 3)', 1000)
+
+    // 匿名関数を代わりに使用する
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **注意点:** `setTimeout(foo, 1000, 1, 2, 3)`のようなシンタックスを使用する事も
+> できますが、[メソッド](#function.this)を使用した際に、分かりにくいエラーが起りえるので
+> 使用はお勧めしません。
+
+### 終りに
+
+`setTimeout`や`setInterval`のパラメーターに文字列を用いては**いけません**。引数が関数に呼び出される必要がある場合**本当**に悪いコードの明確なサインになります。実際の呼び出しには*匿名関数*を渡すべきです。
+
+さらに、`setInterval`の使用はスケジューラーがJavaScriptの実行によってブロックされないので、避けるべきでしょう。
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
+
diff --git a/doc/ja/types/casting.md b/doc/ja/types/casting.md
new file mode 100644
index 00000000..2493b8ea
--- /dev/null
+++ b/doc/ja/types/casting.md
@@ -0,0 +1,60 @@
+## 型変換
+
+JavaScriptは*弱い型付け*の言語なので、可能な**限り**に*型強制*が適用されます。
+
+    // これらはtrueです。
+    new Number(10) == 10; // Number.toString()が変換される
+                          // numberに戻る
+
+    10 == '10';           // StringsがNumberに変換される
+    10 == '+10 ';         // バカみたいに文字列を追加
+    10 == '010';          // もっともっと
+    isNaN(null) == false; // nullが0に変換される
+                          // もちろんNaNではないです
+
+    // これらはfalseです
+    10 == 010;
+    10 == '-10';
+
+> **ES5での注意点:** `0`から始まるNumberリテラルは8進数(基数が8)として解釈されます。
+> このような8進数のサポートはECMAScript5のstrict modeでは**削除されました**。
+
+上記の自体を避ける為に、[厳密等価演算子](#types.equality)を使用する事を**強く**推奨します。また、これはたくさんある落し穴を避けますが、それでもまだJavaScriptの弱い型付けシステムから発生する色々な課題が残っています。
+
+### 組み込み型のコンストラクタ
+
+`Number`や`String`のような組み込み型のコンストラクタは、`new`キーワードの有無で振る舞いが違ってきます。
+
+    new Number(10) === 10;     // False, ObjectとNumber
+    Number(10) === 10;         // True, NumberとNumber
+    new Number(10) + 0 === 10; // True, 暗黙の型変換によります
+
+`Number`のような組み込み型をコンストラクタとして使うと、新しい`Number`オブジェクトが作られますが、`new`キーワードを除外すると`Number`関数がコンバーターのように振る舞います。
+
+加えて、リテラルかオブジェトではない値を持っていると、さらに型強制が多くなります。
+
+最良のオプションは以下の3つの方法の内、1つで型を**明示**してキャストする事になります。
+
+### Stringでキャストする
+
+    '' + 10 === '10'; // true
+
+空の文字列の付加により値を簡単に文字列にキャストできます。
+
+### Numberでキャストする
+
+    +'10' === 10; // true
+
+**単項**プラスオペレーターを使うと数字にキャストする事が可能です。
+
+### Booleanでキャストする
+
+**not**オペレーターを2回使うと、値はブーリアンに変換できます。
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
diff --git a/doc/ja/types/equality.md b/doc/ja/types/equality.md
new file mode 100644
index 00000000..f681e6c2
--- /dev/null
+++ b/doc/ja/types/equality.md
@@ -0,0 +1,58 @@
+## 等価と比較
+
+JavaScriptはオブジェクトの値の等価の比較方法を2種類持っています。
+
+### 等価演算子
+
+等価演算子は2つのイコール記号: `==`から成っています。
+
+JavaScriptは*弱い型付け*を特徴としています。これは等価演算子が比較をする際に型付けを**強制**するという意味です。
+
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+上記の表では型強制の結果が表示されています。`==`の使用が一般に悪い習慣とみなされる大きな理由として、変換ルールが複雑な為、バグの追跡が困難になる事が挙げられます。
+
+加えて、型強制が行なわれるとパフォーマンスにも影響してしまいます。例えば、文字列は他の数字と比較する前に数値に変換されなければなりません。
+
+### 厳密等価演算子
+
+厳密等価演算子は**3つ**のイコール記号:`===`で成っています。
+
+これはオペランドの間で強制的な型変換が**実行されない**事を除けば、通常の等価演算子と同じように正確に動作します。
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+上記の結果は、より明確でコードの早期破損を可能にします。これはある程度までコードを硬化させて、オペランドが別の型の場合にパフォーマンスが向上します。
+
+### オブジェクトの比較
+
+`==`と`===`は両方とも**等価**演算子とされていますが、そのオペランドの少なくとも一つが`Object`の場合は、両者は異なる動きをします。
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+これら2つの演算子は**同一性**を比較していているのであって、等価を比較しているわけでは**ありません**。これは、これらの演算子はPythonの`is`演算子やCのポインター比較と同じように、同じオブジェクトの**インスタンス**を比較するという事になります。
+
+### 終わりに
+
+**厳密等価**演算子だけを使用することを特に推奨します。型を強制的に型変換する場合は[explicitly](#types.casting)であるべきで、言語自体の複雑な変換ルールが残っているべきではありません。
+
diff --git a/doc/ja/types/instanceof.md b/doc/ja/types/instanceof.md
new file mode 100644
index 00000000..82a5b80f
--- /dev/null
+++ b/doc/ja/types/instanceof.md
@@ -0,0 +1,31 @@
+## `instanceof`オペレーター
+
+`instanceof`オペレーターは2つのオペランドのコンストラクタを比較します。これはカスタムで作ったオブジェクトを比較する時にのみ有用です。組み込みの型に使用するのは[typeof operator](#types.typeof)を使用するのと同じくらい意味がありません。
+
+### カスタムオブジェクトの比較
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // これは単に関数オブジェクトFooにBar.prototypeをセットしただけです。
+    // しかし、実際のFooのインスタンスではありません。
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### ネイティブ型で`instanceof`を使用する
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+ここで1つ重要な事は、異なるJavaScriptのコンテキスト(例えば、ブラウザの異なるウィンドウ)を元としたオブジェクトでは、コンストラクタが厳密に同じものでは無い為に`instanceof`は上手く動作しません。
+
+### 終わりに
+
+`instanceof`オペレーターは同じJavaScriptのコンテキストが起源になっているカスタムメイドのオブジェクトを扱う場合**のみ**使うべきです。ちょうど[`typeof`](#types.typeof)オペレーターのように、その他での使用は**避けるべき**です。
diff --git a/doc/ja/types/typeof.md b/doc/ja/types/typeof.md
new file mode 100644
index 00000000..a70ac820
--- /dev/null
+++ b/doc/ja/types/typeof.md
@@ -0,0 +1,71 @@
+## `typeof`演算子
+
+`typeof`演算子([`instanceof`](#types.instanceof)も同様です)は恐らくJavaScriptの最大の設計ミスです。**完全に壊れている**存在に近いものです。
+
+`instanceof`はまだ限られた用途で使用できますが、`typeof`は本当に使用できる実用的なケースはオブジェクトの型を調べるという起こら**ない**ケース一つしかありません。
+
+> **注意点:** `typeof`も関数のような構文で呼ぶ事もできます。(例：`typeof(obj)`)
+> これは関数呼び出しではありません。2つのカッコは通常と同じように
+> `typeof`演算子のオペランドの値を返す振る舞いをします。
+> `typeof`関数は存在**しません**。
+
+### JavaScript の型テーブル
+
+    Value               Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (Nitro/V8ではfunction)
+    new RegExp("meow")  RegExp     object (Nitro/V8ではfunction)
+    {}                  Object     object
+    new Object()        Object     object
+
+上記のテーブルにおいて*Type*は`typeof`演算子が返す値を参照しています。はっきりと分かるように、この値はどれでも一貫しています。
+
+*Class*はオブジェクト内部の`[[Class]]`プロパティの値を参照しています。
+
+> **仕様より:** `[[Class]]`の値は以下の文字列のいずれかになります。
+> `Arguments`, `Array`, `Boolean`, `Date`, `Error`,
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+`[[Class]]`の値を取得する為に、`Object.prototype`メソッドの`toString`を使う事があります。
+
+### オブジェクトのクラス
+
+仕様では`[[Class]]`の値にアクセスするためには`Object.prototype.toString`を使用した厳密な一つの方法が与えられています。
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+上記の例では[this](#function.this)の値と共に`Object.prototype.toString`が呼び出され`[[Class]]`の取得されている値がオブジェクトとして設定されます。
+
+> **ES5での注意点:** 便宜上、ECMAScript 5では
+> `Object.prototype.toString`の
+> `null`と`undefined`の返す値は`Object`から
+> `Null`と`Undefined`に**変更され**ました。
+
+### 未定義変数のテスト
+
+    typeof foo !== 'undefined'
+
+上記では`foo`が実際に宣言されたかどうかを`ReferenceError`の結果を参照してチェックします。これは`typeof`が唯一実際に役に立つ場合です。
+
+### 終わりに
+
+オブジェクトの型をチェックする為には、`Object.prototype.toString`を使用する事を強くお勧めします。これが唯一信頼できる方法だからです。上述の型テーブルでも分かるように、`typeof`の戻り値は仕様で定義されていないものを返します。よって、実装によって別の結果になる事があります。
+
+変数が定義されているかチェックしない限りは、`typeof`は**どんな事をしても**避けるべきです。
diff --git a/doc/ko/array/constructor.md b/doc/ko/array/constructor.md
new file mode 100644
index 00000000..0c60a842
--- /dev/null
+++ b/doc/ko/array/constructor.md
@@ -0,0 +1,24 @@
+## `배열` 생성자
+
+배열을 만들때 `배열` 생성자에 파라미터를 넣어 만드는 방법은 헷갈릴수있다. 그래서 항상 각 괄호(`[]`) 노테이션을 이용해 배열을 만들 것을 권한다
+
+    [1, 2, 3]; // Result: [1, 2, 3]
+    new Array(1, 2, 3); // Result: [1, 2, 3]
+
+    [3]; // Result: [3]
+    new Array(3); // Result: []
+    new Array('3') // Result: ['3']
+
+`배열` 생성자에 숫자를 인자로 넣으면 그 숫자 크기 만큼의 빈 `배열`을 반환한다. 즉 배열의 `length`는 그 숫자가 된다. 이때 생성자는 **단지** `length` 프로퍼티에 그 숫자를 할당하기만 하고 `배열`은 실제로 초기화 하지도 않는다.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, 이 인덱스는 초기화되지 않음.
+
+`for`문을 사용하지 않고 문자열을 더하는 경우에는 length 프로퍼티에 숫자를 할당해주는 기능이 유용할 때도 있다. 
+
+    new Array(count + 1).join(stringToRepeat);
+
+### 결론
+
+`배열` 생성자는 가능하면 사용하지 말고, 각 괄호 (`[]`) 노테이션이을 사용하자. 후자가 더 간략하고 명확할 뿐만 아니라 보기도 좋다.
diff --git a/doc/ko/array/general.md b/doc/ko/array/general.md
new file mode 100644
index 00000000..12f66100
--- /dev/null
+++ b/doc/ko/array/general.md
@@ -0,0 +1,40 @@
+## 배열 순회와 프로퍼티
+
+JavaScript에서는 배열(Array)도 객체(Object)지만 객체 순회(Iterate)를 할 때 [`for in`](#object.forinloop)을 사용해서 좋을 게 없다. 실제로 배열을 탐색할때 `for in`문 사용하지 말아야 할 이유가 매우 많다.
+
+> **Note:** JavaScript의 배열은 *연관 배열(Associative Array)*이 **아니다**. JavaScript는 오직 key/value를 맵핑한 [객체](#object.general)만 있을 뿐이다. 연관 배열은 순서를 보장해주지만 객체는 순서를 보장하지 않는다.
+
+`for in`은 프로토타입 체인에 있는 프로퍼티를 모두 훑는(enumerate) 데다가 객체 자신의 프로퍼티만 훑으려면 [`hasOwnProperty`](#object.hasownproperty)를 사용해야 하기 때문에 `for`보다 20배 느리다.
+
+### 배열 순회
+
+배열을 순회 할때는 일반적인 `for`문을 사용하는 것이 가장 빠르다.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+이 예제에서 `l = list.length`로 배열의 length 값을 캐시해야 한다는 것을 꼭 기억해야 한다.
+
+매번 반복할때마다 배열에 있는 `length` 프로퍼티에 접근하는 것은 좀 부담스럽다. 최신 JavaScript 엔진은 이 일을 알아서 처리해주기도 하지만 코드가 늘 새 엔진에서 실행되도록 보장할 방법이 없다.
+
+실제로 캐시 하지 않으면 성능이 반으로 줄어든다.
+
+### `length` 프로퍼티
+
+`length` 프로퍼티의 *getter*는 단순히 Array 안에 있는 엘리먼트의 개수를 반환하고 *setter*는 배열을 할당한 수만큼 잘라 버린다.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+현재 크기보다 더 작은 값을 할당하면 배열을 자른다. 배열의 크기를 증가시키면 드문드문(sparse)한 배열을 생성한다.
+
+### 결론
+
+최적의 성능을 위해서는 `for`문을 사용하고 `length` 프로퍼티 값을 캐시해야 한다. 배열에 `for in`을 사용하면 성능도 떨어지고 버그 나기도 쉽다.
diff --git a/doc/ko/core/delete.md b/doc/ko/core/delete.md
new file mode 100644
index 00000000..7f008b2c
--- /dev/null
+++ b/doc/ko/core/delete.md
@@ -0,0 +1,76 @@
+## `delete` 연산자
+
+간단히 말해서 전역 변수와 전역 함수 그리고 `DontDelete` 속성을 가진 자바스크립트 객체는 삭제할 수 없다.
+
+### Global 코드와 Function 코드
+
+전역이나 함수 스코프에 정의한 함수나 변수는 모두 Activation 객체나 전역 객체의 프로퍼티다. 이 프로퍼티는 모두 `DontDelete` 속성을 가진다. 전역이나 함수 코드에 정의한 변수와 함수는 항상 `DontDelete` 프로퍼티로 만들어지기 때문에 삭제될 수 없다:
+
+    // Global 변수:
+    var a = 1; // DontDelete가 설정된다.
+    delete a; // false
+    a; // 1
+
+    // Function:
+    function f() {} // DontDelete가 설정된다.
+    delete f; // false
+    typeof f; // "function"
+
+    // 다시 할당해도 삭제할 수 없다:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### 명시적인(Explicit) 프로퍼티
+
+다음 예제에서 만드는 프로퍼티는 delete할 수 있다. 이런 걸 명시적인(Explicit) 프로퍼티라고 부른다:
+
+    // Explicit 프로퍼티를 만든다:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+`obj.x`와 `obj.y`는 `DontDelete` 속성이 아니라서 delete할 수 있다. 하지만 다음과 같은 코드도 잘 동작하기 때문에 헷갈린다:
+
+    // IE를 빼고 잘 동작한다:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - 진짜 Global 변수인지 확인하는 것
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+[`this`](#function.this)가 전역 객체를 가리키는 것을 이용해서 명시적으로 프로퍼티 `a`를 선언하면 삭제할 수 있다. 이것은 꼼수다.
+
+IE (적어도 6-8)는 버그가 있어서 안 된다.
+
+### Argument들과 Function의 기본 프로퍼티
+
+Function의 [`arguments` 객체](#function.arguments)와 기본 프로퍼티도 `DontDelete` 속성이다.
+
+    // Function의 arguments와 프로퍼티:
+    (function (x) {
+    
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Host 객체
+
+> **역주:** Host 객체는 document같은 DOM 객체를 말한다.
+
+Host 객체를 delete하면 어떻게 될지 알 수 없다. 표준에는 어떻게 Host 객체를 delete해야 하는지 정의하지 않았다.
+
+### 결론
+
+`delete` 연산자는 엉뚱하게 동작할 때가 많다. 명시적으로 정의한 일반 객체의 프로퍼티만 delete하는 것이 안전하다.
diff --git a/doc/ko/core/eval.md b/doc/ko/core/eval.md
new file mode 100644
index 00000000..2a97ebea
--- /dev/null
+++ b/doc/ko/core/eval.md
@@ -0,0 +1,38 @@
+## 왜 `eval`을 사용하면 안 될까?
+
+`eval` 함수는 JavaScript 문자열을 지역 스코프에서 실행한다.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+`eval`함수는 `eval`이라는 이름으로 **직접** 실행할 때에만 지역 스코프에서 실행된다. 그리고 `eval`이라는 이름에 걸맞게 악명또한 높다.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+어쨌든 `eval`은 사용하지 말아야 한다. eval을 사용하는 99.9%는 사실 eval 없이도 만들수있다.
+
+### 가짜 `eval`
+
+[`setTimeout`과 `setInterval`](#other.timeouts)은 첫 번째 인자로 스트링을 입력받을 수 있다. 이 경우에는 `eval`을 직접 호출하는 것이 아니라서 항상 Global Scope에서 실행된다.
+
+### 보안 이슈
+
+`eval`은 어떤 코드라도 **무조건** 실행하기 때문에 보안 문제도 있다. 따라서 신뢰하지 못하거나 모르는 코드가 포함되어 있을 경우 **절대로** 사용해서는 안된다.
+
+### 결론
+
+`eval`은 사용하지 않는 게 좋다. `eval`을 사용하는 모든 코드는 성능, 보안, 버그 문제를 일으킬 수 있다. 만약 `eval`이 필요해지면 *설계를 변경*하여 `eval`이 필요 없게 만들어야 한다.
diff --git a/doc/ko/core/semicolon.md b/doc/ko/core/semicolon.md
new file mode 100644
index 00000000..7a384caa
--- /dev/null
+++ b/doc/ko/core/semicolon.md
@@ -0,0 +1,99 @@
+## 자동으로 삽입되는 쎄미콜론
+
+JavaScript는 C와 문법이 비슷하지만, 꼭 코드에 쎄미콜론을 사용하도록 강제하지는 않는다. 그래서 생략할 수 있다.
+
+사실 JavaScript는 쎄미콜론이 꼭 있어야 하고 없으면 이해하지 못한다. 그래서 JavaScript 파서는 쎄미콜론이 없으면 **자동으로** 쎄미콜론을 추가한다. 
+
+    var foo = function() {
+    } // 쎄미콜론이 없으니 에러 난다.
+    test()
+
+파서는 쎄미콜론을 삽입하고 다시 시도한다.
+
+    var foo = function() {
+    }; // 에러가 없어짐.
+    test()
+
+쎄미콜론을 자동으로 삽입한 것이 **대표적인** JavaScript 설계 오류다. 쎄미콜론 유무에 따라 *전혀* 다른 코드가 될 수 있다.
+
+### 어떻게 다를까?
+
+코드에 쎄미콜론이 없으면 파서가 어디에 넣을지 결정한다.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+파서는 이 코드에 쎄미콜론을 다음과 같이 삽입한다.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // 쎄미콜론을 넣는 것이 아니라 줄을 합친다.
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- 여기
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- 여기
+
+            return; // <- 여기에 넣어서 그냥 반환시킨다.
+            { // 파서는 단순 블럭이라고 생각하고
+
+                // 단순한 레이블과 함수
+                foo: function() {}
+            }; // <- 여기
+        }
+        window.test = test; // <- 여기
+
+    // 이 줄도 합쳐진다.
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- 여기
+
+    })(window); //<- 여기에 파서는 쎄미콜론을 넣는다.
+
+> **주의:** JavaScript 파서는 new line 문자가 뒤따라 오는 return 구문을 제대로 처리하지 못한다. 자동으로 쎄미콜론을 넣는 것 자체의 문제는 아니지만 어쨌든 여전히 문제다.
+
+파서는 완전히 다른 코드로 만들어 버린다. 이것은 **오류**다.
+
+### 괄호 해석
+
+파서는 괄호에는 쎄미콜론을 넣지 않는다.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+그래서 다음과 같이 한줄로 코드를 바꾼다.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+이렇게 한줄로 바뀌면 `log` 함수가 함수를 반환할 가능성이 거의 없으므로 `undefined is not a function`이라는 `TypeError`가 발생한다.
+
+### 결론
+
+쎄미콜론은 반드시 사용해야 한다. 그리고 `{}`도 생략하지 않고 꼭 사용하는 것이 좋다. 한 줄밖에 안 되는 `if` / `else` 블럭에서도 꼭 사용해야 한다. 이 두 가지 규칙을 잘 지키면 JavaScript 파서가 잘못 해석하는 일을 미리 방지하고 코드도 튼튼해진다.
diff --git a/doc/ko/core/undefined.md b/doc/ko/core/undefined.md
new file mode 100644
index 00000000..2bacc83b
--- /dev/null
+++ b/doc/ko/core/undefined.md
@@ -0,0 +1,56 @@
+## `undefined`와 `null`
+
+JavaScript는 `nothing`을 표현할때 `null`과 `undefined` 두 가지로 표현할 수 있고 그중 `undefined`가 더 유용하다.
+
+### `undefined`도 변수
+
+`undefined`는 `undefined`라는 값을 가지는 데이터 형식이다.
+
+`undefined`는 상수도 아니고 JavaScript의 키워드도 아니다. 그냥 `undefined`라는 이름의 Global 변수이고 이 변수에는 `undefined`라고 할당돼 있다. 그래서 이 Global 변수의 값을 쉽게 바꿀 수 있다.
+
+> **ES5 Note:** ECMAScript 5의 strict 모드에서는 `undefined`를 더는 바꿀 수 없도록 했다. 하지만 `undefined`라는 함수를 만들면 여전히 할당할 수 있다.
+
+`undefined` 값이 반환될 때:
+
+ - global 변수 `undefined`에 접근할 때.
+ - 선언은 했지만 아직 초기화하지 않은 변수에 접근할 때.
+ - `return` 구문이 없는 함수는 암묵적으로 `undefined`를 반환함.
+ - `return` 구문으로 아무것도 반환하지 않을 때.
+ - 없는 프로퍼티를 찾을 때.
+ - 함수 인자가 생략될 때.
+ - `undefined`가 할당된 모든 것.
+ - `void(expression)` 형식으로 된 표현
+
+> **역주:** 예를 들어 CoffeeScript Compliler는 CoffeeScript의 `undefined`를 JavaScript의 `void 0`로 컴파일한다.
+
+### `undefined`가 바뀔 때를 대비하기
+
+global 변수 `undefined`는 `undefined`라는 객체를 가리키는 것뿐이기 때문에 새로운 값을 할당한다고 해도 `undefined`의 값 자체가 바뀌는 것이 아니다.
+
+그래서 `undefined`와 비교하려면 먼저 `undefined`의 값을 찾아와야 한다.
+
+`undefined` 변수가 바뀔 때를 대비해서 `undefined`라는 변수를 인자로 받는 [anonymous wrapper](#function.scopes)로 감싸고 인자를 넘기지 않는 꼼수를 사용한다. 
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // Local Scope에 undefined를 만들어서
+        // 원래 값을 가리키도록 했다.
+
+    })('Hello World', 42);
+
+wrapper 안에 변수를 새로 정의하는 방법으로도 같은 효과를 볼 수 있다.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+이 두 방법의 차이는 minified했을 때 4바이트만큼 차이 난다는 것과 한쪽은 wrapper 안에 var 구문이 없다는 것밖에 없다. 
+
+### `Null` 객체의 용도
+
+JavaScript 언어에서는 `undefined`를 다른 언어의 *null* 처럼 쓴다. 진짜 `null`은 그냥 데이터 타입 중 하나일 뿐이지 더도덜도 아니다.
+
+JavaScript를 깊숙히 건드리는 것이 아니면 null 대신 `undefined`를 사용해도 된다(`Foo.prototype = null`같이 프로토타입 체인을 끊을 때는 null을 사용한다).
diff --git a/doc/ko/function/arguments.md b/doc/ko/function/arguments.md
new file mode 100644
index 00000000..288928f5
--- /dev/null
+++ b/doc/ko/function/arguments.md
@@ -0,0 +1,108 @@
+## `arguments` 객체
+
+JavaScript의 모든 함수 스코프에는 `arguments`라는 특별한 변수가 있다. 이 변수는 함수에 넘겨진 모든 인자에 대한 정보가 담겨 있다.
+
+> **Note:** `arguments` 변수는 Function 안에서 다시 정의할 수 없다. `var` 구문이나 파라미터에 `arguments`라는 이름으로 변수를 정의해도 변수가 재정의되지 않는다.
+
+`arguments` 객체는 `Array`가 아니다. 물론 `length` 프로퍼티도 있고 여러모로 Array와 비슷하게 생겼지만 Array.prototype을 상속받지는 않았다.
+
+그래서 `arguments`에는 `push`, `pop`, `slice` 같은 표준 메소드가 없다. 일반 `for`문을 이용해 순회는 할수 있지만, `Array`의 메소드를 이용하려면 `arguments`를 Array로 변환해야 한다.
+
+### Array로 변환하기
+
+다음 코드는 arguments에 있는 객체를 새로운 Array에 담아 반환한다.
+
+    Array.prototype.slice.call(arguments);
+
+이 변환 과정은 **느리기** 때문에 성능이 중요한 부분에 사용하는 것은 **별로 바람직하지** 못 하다.
+
+### arguemnts 객체 넘기기
+
+어떤 함수에서 다른 함수로 arguments 객체를 넘길 때에는 다음과 같은 방법을 권한다. (역주: foo 함수는 bar 함수 한번 랩핑한 함수다. )
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // 내곡동에 땅이라도 산다.
+    }
+
+또 다른 트릭은 `call`과 `apply`를 함께 사용하여 메소드(`this`의 값과 인자들을 사용하는 함수)를 
+단지 인자들만 사용하는 일반 함수로 바꾸는 것이다.
+
+    function Person(first, last) {
+      this.first = first;
+      this.last = last;
+    }
+
+    Person.prototype.fullname = function(joiner, options) {
+      options = options || { order: "western" };
+      var first = options.order === "western" ? this.first : this.last;
+      var last =  options.order === "western" ? this.last  : this.first;
+      return first + (joiner || " ") + last;
+    };
+
+    // "fullname" 메소드의 비결합(unbound) 버전을 생성한다.
+    // 첫번째 인자로 'first'와 'last' 속성을 가지고 있는 어떤 객체도 사용 가능하다.
+    // "fullname"의 인자 개수나 순서가 변경되더라도 이 랩퍼를 변경할 필요는 없을 것이다.
+    Person.fullname = function() {
+      // 결과: Person.prototype.fullname.call(this, joiner, ..., argN);
+      return Function.call.apply(Person.prototype.fullname, arguments);
+    };
+
+    var grace = new Person("Grace", "Hopper");
+
+    // 'Grace Hopper'
+    grace.fullname();
+
+    // 'Turing, Alan'
+    Person.fullname({ first: "Alan", last: "Turing" }, ", ", { order: "eastern" });
+
+### 일반 파라미터와 arguments 객체의 인덱스
+
+일반 파라미터와 `arguments` 객체의 프로퍼티는 모두 *getter*와 *setter*를 가진다.
+
+그래서 파라미터나 `arguments` 객체의 프로퍼티의 값을 바꾸면 둘 다 바뀐다.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### 성능에 대한 오해와 진실.
+
+`arguments` 객체는 항상 만들어지지만 두가지 예외사항이 있다. `arguments`라는 이름으로 변수를 함수 안에 정의하거나 arguments 객체로 넘겨받는 인자중 하나라도 정식 인자로 받아서 사용하면 `arguemnts` 객체는 만들어지지 않는다. 하지만 뭐 이런 경우들은 어차피 arguments 객체를 안쓰겠다는 의미니까 상관 없다.
+
+그리고 *getter*와 *setter*는 항상 생성되기 때문에 getter/setter를 사용하는 것은 성능에 별 영향을 끼치지 않는다. 예제처럼 단순한 코드가 아니라 `arguments` 객체를 다방면으로 활용하는 실제 코드에서도 마찬가지다.
+
+> **ES5 Note:** strict 모드에서는 *getter*와 *setter*가 생성되지 않는다.
+
+그러나 예외도 있다. 최신 JavaScript 엔진에서 `arguments.callee`를 사용하면 성능이 확 떨어진다.
+
+    function foo() {
+        arguments.callee; // 이 함수를 가리킨다.
+        arguments.callee.caller; // 이 함수를 호출한 부모함수를 가리킨다.
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // 원래 인라인 돼야 하는디...
+        }
+    }
+
+위 코드에서 'foo' 함수는 자기 자신과 자신을 호출한 함수를 알아야 하기 때문에 더이상 [인라인][1]되지 않는다. 이렇게 쓰면 인라인이 주는 성능상 장점을 포기해야 하는데다가 이 함수가 호출되는 상황(calling context)에 의존하게 돼 버려서 캡슐화(Encapsulation)도 해친다. 
+(역주: 보통 코드가 컴파일 될때 코드를 인라인 시키면서 최적화 하는데, 위와 같이 arguments.callee나 caller를 사용하게 되면 런타임시에 해당 함수가 결정되므로 인라인 최적화를 할수가 없다.)
+
+`arguments.callee`와 arguments.callee의 프로퍼티들은 **절대** 사용하지 말자!.
+
+> **ES5 Note:** strict 모드에서 `arguments.callee`는 deprecated됐기 때문에 사용하면 `TypeError`가 난다.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
diff --git a/doc/ko/function/closures.md b/doc/ko/function/closures.md
new file mode 100644
index 00000000..4e5631fa
--- /dev/null
+++ b/doc/ko/function/closures.md
@@ -0,0 +1,95 @@
+## 클로져(Closure)와 참조(Reference)
+
+*클로져*는 JavaScript의 특장점 중 하나다. 클로저를 만들면 클로저 스코프 안에서 클로저를 만든 외부 스코프(Scope)에 항상 접근할 있다. JavaScript에서 스코프는 [함수 스코프](#function.scopes)밖에 없기 때문에 기본적으로 모든 함수는 클로저가 될수있다.
+
+### private 변수 만들기
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+여기서 `Counter`는 `increment` 클로저와 `get` 클로저 두 개를 반환한다. 이 두 클로저는 `Counter` 함수 스코프에 대한 **참조**를 유지하고 있기 때문에 이 함수 스코프에 있는 count 변수에 계속 접근할 수 있다.
+
+### Private 변수의 동작 원리
+
+JavaScript에서는 스코프(Scope)를 어딘가에 할당해두거나 참조할수 없기 때문에 스코프 밖에서는 count 변수에 직접 접근할 수 없다. 접근할수 있는 유일한 방법은 스코프 안에 정의한 두 클로저를 이용하는 방법밖에 없다. 
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+위 코드에서 `foo.hack` 함수는 Counter 함수 안에서 정의되지 않았기 때문에 이 함수가 실행되더라도 `Counter` 함수 스코프 안에 있는 count 값은 변하지 않는다. 대신 foo.hack 함수의 `count`는 *Global* 스코프에 생성되거나 이미 만들어진 변수를 덮어쓴다.
+
+### 반복문에서 클로저 사용하기
+
+사람들이 반복문에서 클로저를 사용할 때 자주 실수를 하는 부분이 있는데 바로 인덱스 변수를 복사할때 발생한다.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+이 코드는 `0`부터 `9`까지의 수를 출력하지 않고 `10`만 열 번 출력한다.
+
+타이머에 설정된 *익명* 함수는 변수 `i`에 대한 참조를 들고 있다가 `console.log`가 호출되는 시점에 `i`의 값을 사용한다. `console.log`가 호출되는 시점에서 `for loop`는 이미 끝난 상태기 때문에 `i` 값은 10이 된다.
+
+기대한 결과를 얻으려면 `i` 값을 복사해 두어야 한다.
+
+### 앞의 참조 문제 해결하기
+
+반복문의 index 값을 복사하는 가장 좋은 방법은 익명함수로 랩핑[Anonymous Wrapper](#function.scopes)하는 방법이다.
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+이 익명 함수에 `i`를 인자로 넘기면 이 함수의 파라미터 e에 i의 **값**이 복사되어 넘어갈 것이다.
+
+그리고 `setTimeout`는 익명 함수의 파라미터인 `e`에 대한 참조를 갖게 되고 `e`값은 복사되어 넘어왔으므로 loop의 상태에 따라 변하지 않는다.
+
+또다른 방법으로 랩핑한 익명 함수에서 출력 함수를 반환하는 방법도 있다. 아래 코드는 위 코드와 동일하게 동작한다.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+즐겨 쓰이는 또 하나의 방법은 `setTimeout` 함수에 세번째 인자를 추가하는 방법이다. 
+추가된 인자는 콜백 함수에 전달된다.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function(e) {
+            console.log(e);  
+        }, 1000, i);
+    }
+
+레거시 JS 환경(Internet Explorer 9 이하)은 이 방법을 지원하지 않는다.
+
+`.bind`를 사용하는 방법도 있다. `.bind`는 `this` 컨텍스트와 인자들을 함수에 결속(bind)시킨다. 
+아래 코드는 위 코드와 동일하게 동작한다.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
diff --git a/doc/ko/function/constructors.md b/doc/ko/function/constructors.md
new file mode 100644
index 00000000..2b26dc24
--- /dev/null
+++ b/doc/ko/function/constructors.md
@@ -0,0 +1,104 @@
+## 생성자
+
+JavaScript의 생성자는 다른 언어들과 다르게 `new` 키워드로 호출되는 함수가 생성자가 된다.
+
+생성자로 호출된 함수의 this 객체는 새로 생성된 객체를 가리키고, **새로 만든** 객체의 [prototype](#object.prototype)에는 생성자의 prototype이 할당된다.
+
+그리고 생성자에 명시적인 `return` 구문이 없으면 this가 가리키는 객체를 반환한다.
+
+    function Person(name) {
+        this.name = name;
+    }
+
+    Person.prototype.logName = function() {
+        console.log(this.name);
+    };
+
+    var sean = new Person();
+
+위 코드는 `Person`을 생성자로 호출하고 새로 생성된 객체의 `prototype`을 `Person.prototype`으로 설정한다.
+
+아래 코드와 같이 생성자에 명시적인 `return` 문이 있는 경우에는 반환하는 값이 객체인 경우에만 그 값을 반환한다.
+
+    function Car() {
+        return 'ford';
+    }
+    new Car(); // 'ford'가 아닌 새로운 객체를 반환
+
+    function Person() {
+        this.someValue = 2;
+
+        return {
+            name: 'Charles'
+        };
+    }
+    new Person(); // someValue가 포함되지 않은 ({name:'Charles'}) 객체 반환
+
+new 키워드가 없으면 그 함수는 객체를 반환하지 않는다.
+
+    function Pirate() {
+        this.hasEyePatch = true; // 전역 객체를 준비!
+    }
+    var somePirate = Pirate(); // somePirate = undefined
+
+위 예제는 그때그때 다르게 동작한다. 그리고 [`this`](#function.this) 객체의 동작 원리에 따라서 Foo 함수안의 `this`의 값은 *Global 객체*를 가리키게된다. 
+(역주: 결국 new 키워드를 빼고, 코드를 작성할 경우 원치 않은 this 참조 오류가 발생할 수 있다.)
+
+### 팩토리
+
+생성자가 객체를 반환하면 `new` 키워드를 생략할 수 있다.
+
+    function Robot() {
+        var color = 'gray';
+        return {
+            getColor: function() {
+                return color;
+            }
+        }
+    }
+    Robot.prototype = {
+        someFunction: function() {}
+    };
+
+    new Robot();
+    Robot();
+
+new 키워드의 유무과 관계없이 `Robot` 생성자의 동작은 동일하다. 즉 [클로저](#function.closures)가 할당된 method 프로퍼티가 있는 새로운 객체를 만들어 반환한다.
+
+`new Robot()`으로 호출되는 생성자는 반환되는 객체의 prototype 프로퍼티에 아무런 영향을 주지 않는다. 객체를 반환하지 않는 생성자로 만들어지는 경우에만 객체의 prototype이 생성자의 것으로 할당된다.
+
+그러니까 이 예제에서 `new` 키워드의 유무는 아무런 차이가 없다.
+(역주: 생성자에 객체를 만들어 명시적으로 반환하면 new 키워드에 관계없이 잘 동작하는 생성자를 만들수있다. 즉, new 키워드가 빠졌을때 발생하는 this 참조 오류를 방어해준다.)
+
+### 팩토리로 객체 만들기
+
+`new` 키워드를 빼먹었을 때 버그가 생긴다는 이유로 **아예 new를 사용하지 말 것**을 권하기도 한다.
+
+객체를 만들고 반환해주는 팩토리를 사용하여 `new` 키워드 문제를 회피할 수 있다.
+
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
+
+        var milesPerGallon = 2;
+
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
+        }
+
+        car.getMPG = function() {
+            return milesPerGallon;
+        }
+
+        return car;
+    }
+
+`new` 키워드가 없어도 잘 동작하고 [private 변수](#function.closures)를 사용하기도 쉽다. 그렇지만, 단점도 있다.
+
+ 1. prototype으로 메소드를 공유하지 않으므로 메모리를 좀 더 사용한다.
+ 2. 팩토리를 상속하려면 모든 메소드를 복사하거나 객체의 prototype에 객체를 할당해 주어야 한다.
+ 3. `new` 키워드를 누락시켜서 prototype chain을 끊어버리는 것은 아무래도 언어의 의도에 어긋난다.
+
+### 결론
+
+`new` 키워드가 생략되면 버그가 생길 수 있지만 그렇다고 prototype을 사용하지 않을 이유가 되지 않는다. 애플리케이션에 맞는 방법을 선택하는 것이 나을 거고 어떤 방법이든 **엄격하고 한결같이* 지켜야 한다.
diff --git a/doc/ko/function/general.md b/doc/ko/function/general.md
new file mode 100644
index 00000000..091fd105
--- /dev/null
+++ b/doc/ko/function/general.md
@@ -0,0 +1,37 @@
+## 함수 선언과 함수 표현식
+
+JavaScript에서 함수는 First Class Object다. 즉, 함수 자체가 또 다른 함수의 인자될 수 있다는 말이다. 그래서 익명 함수를 비동기 함수의 콜백으로 넘기는 것도 이런 특징을 이용한 일반적인 사용법이다.
+
+### `함수` 선언
+
+    function foo() {}
+
+위와 같이 선언한 함수는 프로그램이 실행하기 전에 먼저 [호이스트(Hoist)](#function.scopes) (스코프가 생성)되기 때문에 정의된 스코프(Scope) 안에서는 어디서든 이 함수를 사용할 수 있다. 심지어 함수를 정의하기 전에 호출해도 된다.
+
+    foo(); // 이 코드가 실행되기 전에 foo가 만들어지므로 잘 동작한다.
+    function foo() {}
+
+### `함수` 표현식
+
+    var foo = function() {};
+
+위 예제는 `foo` 변수에 *익명* 함수를 할당한다.
+
+    foo; // 'undefined'
+    foo(); // TypeError가 난다.
+    var foo = function() {};
+
+'var'문을 이용해 선언하는 경우, 코드가 실행되기 전에 'foo' 라는 이름의 변수를 스코프의 맨 위로 올리게 된다.(호이스트 된다) 이때 foo 값은 undefiend로 정의된다. 
+
+하지만 변수에 값을 할당하는 일은 런타임 상황에서 이루어지게 되므로 실제 코드가 실행되는 순간의 `foo`변수는 기본 값인 [undefined](#core.undefined)이 된다.
+
+### 이름있는 함수 표현식
+
+이름있는 함수를 할당할때도 특이한 경우가 있다.
+
+    var foo = function bar() {
+        bar(); // 이 경우는 동작 하지만, 
+    }
+    bar(); // 이 경우는 참조에러를 발생시킨다. 
+
+foo 함수 스코프 밖에서는 foo 변수 외에는 다른 값이 없기 때문에 `bar`는 함수 밖에서 사용할 수 없지만 함수 안에서는 사용할 수 있다. [이와 같은 방법](#function.scopes)으로 자바스크립트에서 어떤 함수의 이름은 항상 그 함수의 지역 스코프 안에서 사용할수있다. 
\ No newline at end of file
diff --git a/doc/ko/function/scopes.md b/doc/ko/function/scopes.md
new file mode 100644
index 00000000..b94dc10e
--- /dev/null
+++ b/doc/ko/function/scopes.md
@@ -0,0 +1,191 @@
+## 스코프와 네임스페이스
+
+JavaScript는 '{}' Block이 배배 꼬여 있어도 문법적으로는 잘 처리하지만, Block Scope은 지원하지 않는다. 그래서 JavaScript에서는 항상 *함수 스코프*를 사용한다.
+
+    function test() { // Scope
+        for(var i = 0; i < 10; i++) { // Scope이 아님
+            // count
+        }
+        console.log(i); // 10
+    }
+
+> **Note:** 할당할 때, 반환할 때, Function 인자에서 사용되는 것을 제외하면 `{...}`는 모두 객체 리터럴이 아니라 Block 구문으로 해석된다. 그래서 [세미콜론을 자동으로 넣어주면](#core.semicolon) 에러가 생길 수 있다.
+
+그리고 JavaScript에는 Namepspace 개념이 없기 때문에 모든 값이 하나의 *전역* 스코프에 정의된다.
+
+변수를 참조 할 때마다 JavaScript는 해당 변수를 찾을 때까지 상위 방향으로 스코프를 탐색한다. 변수 탐색하다가 전역 스코프에서도 찾지 못하면 `ReferenceError`를 발생시킨다.
+
+### 전역 변수 문제.
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+이 두 스크립트는 전혀 다르다. Script A는 *전역* 스코프에 `foo`라는 변수를 정의하는 것이고 Script B는 *현* 스코프에 변수 `foo`를 정의하는 것이다.
+
+다시 말하지만, 이 둘은 전혀 다르고 `var`가 없을 때 특별한 의미가 있다.
+
+    // Global Scope
+    var foo = 42;
+    function test() {
+        // local Scope
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+test 함수 안에 있는 'foo' 변수에 `var` 구문을 빼버리면 Global Scope의 `foo`의 값을 바꿔버린다. '뭐 이게 뭐가 문제야'라고 생각될 수 있지만 수천 줄인 JavaScript 코드에서 `var`를 빼먹어서 생긴 버그를 해결하는 것은 정말 어렵다.
+
+    // Global Scope
+    var items = [/* some list */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // Scope of subLoop
+        for(i = 0; i < 10; i++) { // var가 없다.
+            // 내가 for문도 해봐서 아는데...
+        }
+    }
+
+subLoop 함수는 전역 변수 `i`의 값을 변경해버리기 때문에 외부에 있는 for문은 `subLoop`을 한번 호출하고 나면 종료된다. 두 번째 `for`문에 `var`를 사용하여 `i`를 정의하면 이 문제는 생기지 않는다. 즉, 의도적으로 외부 스코프의 변수를 사용하는 것이 아니라면 `var`를 꼭 넣어야 한다.
+
+### 지역 변수
+
+JavaScript에서 지역 변수는 [함수의 파라미터](#function.general)와 `var`로 정의한 변수밖에 없다.
+
+   // 전역 공간
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // test 함수의 지역 공간
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+`foo` 변수와 `i` 변수는 `test`함수 스코프에 있는 지역 변수라서 전역 공간에 있는 `foo`, `i` 값은 바뀌지 않는다. 하지만 `bar`는 전역 변수이기 때문에 전역 공간에 있는 `bar`의 값이 변경된다.
+
+### 호이스팅(Hoisting)
+
+JavaScript는 선언문을 모두 **호이스트(Hoist)**한다. 호이스트란 `var` 구문이나 `function` 선언문을 해당 스코프의 맨 위로 옮기는 것을 말한다.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+코드를 본격적으로 실행하기 전에 JavaScript는 `var` 구문과 `function` 선언문을 해당 스코프의 맨위로 옮긴다.
+
+    // var 구문이 여기로 옮겨짐.
+    var bar, someValue; // default to 'undefined'
+
+    // function 선언문도 여기로 옮겨짐
+    function test(data) {
+        var goo, i, e; // Block Scope은 없으므로 local 변수들은 여기로 옮겨짐
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // bar()가 아직 'undefined'이기 때문에 TypeError가 남
+    someValue = 42; // Hoisting은 할당문은 옮기지 않는다.
+    bar = function() {};
+
+    test();
+
+블록 스코프(Block Scope)는 없으므로 for문과 if문 안에 있는 `var` 구문들까지도 모두 함수 스코프 앞쪽으로 옮겨진다. 그래서 `if` Block의 결과는 좀 이상해진다.
+
+원래 코드에서 `if` Block은 *전역 변수* `goo`를 바꾸는 것처럼 보였지만 호이스팅(Hoisting) 후에는 *지역 변수*를 바꾼다.
+
+*호이스팅*을 모르면 다음과 같은 코드는 `ReferenceError`를 낼 것으로 생각할 것이다.
+
+    // SomeImportantThing이 초기화됐는지 검사한다.
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+`var` 구문은 *전역 스코프*의 맨위로 옮겨지기 때문에 이 코드는 잘 동작한다.
+
+    var SomeImportantThing;
+
+    // SomeImportantThing을 여기서 초기화하거나 말거나...
+
+    // SomeImportantThing는 선언돼 있다.
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### 이름 찾는 순서
+
+JavaScript의 모든 Scope은 *현 객체*를 가리키는 [`this`](#function.this)를 가지고 있다. *전역 스코프*에도 this가 있다.
+
+함수 스코프에는 [`arguments`](#function.arguments)라는 변수가 하나 더 있다. 이 변수는 함수에 인자로 넘겨진 값들이 담겨 있다.
+
+예를 들어 함수 스코프에서 `foo`라는 변수에 접근할 때 JavaScript는 다음과 같은 순서로 찾는다.
+
+ 1. 해당 Scope에서 `var foo` 구문으로 선언된 것을 찾는다.
+ 2. Function 파라미터에서 `foo`라는 것을 찾는다.
+ 3. 해당 Function 이름이 `foo`인지 찾는다.
+ 4. 상위 Scope으로 있는지 확인하고 있으면 **#1**부터 다시 한다.
+ 
+> **Note:** `arguments`라는 파라미터가 있으면 Function의 기본 객체인 `arguments`가 생성되지 않는다.
+
+### 네임스페이스
+
+JavaScript에서는 전역 공간(Namepspace) 하나밖에 없어서 변수 이름이 중복되기 쉽다. 하지만 *이름없는 랩퍼(Anonymous Wrappers)*를 통해 쉽게 피해갈 수 있다.
+
+    (function() {
+        // 일종의 네임스페이스라고 할 수 있다.
+        
+        window.foo = function() {
+            // 이 클로저는 전역 스코프에 노출된다.
+        };
+
+    })(); // 함수를 정의하자마자 실행한다.
+
+이름없는 함수는 [표현식(expressions)](#function.general)이기 때문에 호출되려면 먼저 평가(Evaluate)돼야 한다.
+
+    ( // 소괄호 안에 있는 것을 먼저 평가한다.
+    function() {}
+    ) // 그리고 함수 객체를 반환한다.
+    () // 평가된 결과를 호출한다.
+
+함수를 평가하고 바로 호출하는 방법이 몇가지 더 있다. 문법은 다르지만 똑같다.
+
+    // 함수를 평가하자마자 호출하는 방법들...
+    !function(){}();
+    +function(){}();
+    (function(){}());
+    // 등등...
+
+### 결론
+
+코드를 캡슐화할 때는 항상 *이름없는 랩퍼(Anonymous Wrapper)*로 네임스페이스를 만들어 사용할 것을 추천한다. 이 래퍼(Wrapper)는 이름이 중복되는 것을 막아 주고 더 쉽게 모듈화할 수 있도록 해준다.
+
+그리고 전역 변수를 사용하는 것은 좋지 못한 습관이다. 이유야 어쨌든 에러 나기 쉽고 관리하기도 어렵다.
diff --git a/doc/ko/function/this.md b/doc/ko/function/this.md
new file mode 100644
index 00000000..0ad51ad9
--- /dev/null
+++ b/doc/ko/function/this.md
@@ -0,0 +1,99 @@
+## `this`의 동작 원리
+
+다른 프로그래밍 언어에서 `this`가 가리키는 것과 JavaScript에서 `this`가 가리키는 것과는 좀 다르다. `this`가 가리킬 수 있는 객체는 정확히 5종류나 된다.
+
+### Global Scope에서
+
+    this;
+
+Global Scope에서도 this가 사용될 수 있고 이때에는 *Global* 객체를 가리킨다.
+
+### 함수를 호출할 때
+
+    foo();
+
+이때에도 `this`는 *Global* 객체를 가리킨다.
+
+> **ES5 Note:** strict 모드에서 더는 Global 객체를 가리키지 않고 대신 `undefined`를 가리킨다.
+
+### 메소드로 호출할 때
+
+    test.foo(); 
+
+이 경우에는 `this`가 `test`를 가리킨다.
+
+### 생성자를 호출할 때
+
+    new foo(); 
+
+`new` 키워드로 [생성자](#function.constructors)를 실행시키는 경우에 이 생성자 안에서 `this`는 새로 만들어진 객체를 가리킨다.
+
+### `this`가 가리키는 객체 정해주기.
+
+    function foo(a, b, c) {}
+
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // a = 1, b = 2, c = 3으로 넘어간다.
+    foo.call(bar, 1, 2, 3); // 이것도... 
+
+`Function.prototype`의 `call`이나 `apply` 메소드를 호출하면 `this`가 무엇을 가리킬지 *정해줄 수 있다*. 호출할 때 첫 번째 인자로 `this`가 가리켜야 할 객체를 넘겨준다.
+
+그래서 `foo` Function 안에서 `this`는 위에서 설명했던 객체 중 하나를 가리키는 것이 아니라 `bar`를 가리킨다.
+
+> **Note:** 객체 리터럴에서 this는 그 객체를 가리키지 않는다. 예를 들어 `var obj= {me:this}`에서 `me`가 `obj`를 가리키는 것이 아니라 위에 설명한 5가지 객체 중 하나를 가리킨다.
+
+### 대표적인 함정
+
+`this`가 Global 객체를 가리키는 것도 잘못 설계된 부분 중 하나다. 괜찮아 보이지만 실제로는 전혀 사용하지 않는다.
+
+    Foo.method = function() {
+        function test() {
+            // 여기에서 this는 Global 객체를 가리킨다.
+        }
+        test();
+    };
+
+`test` 에서 `this`가 `Foo`를 가리킬 것으로 생각할 테지만 틀렸다. 실제로는 그렇지 않다.
+
+`test`에서 `Foo`에 접근하려면 method에 Local 변수를 하나 만들고 `Foo`를 가리키게 하여야 한다.
+
+    Foo.method = function() {
+        var self = this;
+        function test() {
+            // 여기에서 this 대신에 self를 사용하여 Foo에 접근한다
+        }
+        test();
+    };
+
+`self`는 통상적인 변수 이름이지만, 바깥쪽의 `this`를 참조하기 위해 일반적으로 사용된다. 
+또한 [클로저](#function.closures)와 결합하여 `this`의 값을 주고 받는 용도로 사용할 수도 있다.
+
+ECMAScript 5부터는 익명 함수와 결합된 `bind` 메소드를 사용하여 같은 결과를 얻을 수 있다. 
+
+    Foo.method = function() {
+        var test = function() {
+            // this는 이제 Foo를 참조한다
+        }.bind(this);
+        test();
+    };
+
+### Method 할당하기
+
+JavaScript의 또다른 함정은 바로 함수의 별칭을 만들수 없다는 점이다. 별칭을 만들기 위해 메소드를 변수에 넣으면 자바스크립트는 별칭을 만들지 않고 바로 *할당*해 버린다.  
+
+    var test = someObject.methodTest;
+    test();
+
+첫번째 코드로 인해 이제 `test`는 다른 함수와 똑같이 동작한다. 그래서 test 함수 내부의 `this`도 더이상 someObject를 가리키지 않는다. (역주: test가 methodTest의 별칭이라면 methodTest 함수 내부의 this도 someObject를 똑같이 가리켜야 하지만 test의 this는 더이상 someObject가 아니다.)
+
+이렇게 `this`를 늦게 바인딩해서 나타나는 약점때문에 늦은 바인딩이 나쁜 거라고 생각할수도 있지만, 사실 이런 특징으로 인해 [프로토타입 상속(prototypal inheritance)](#object.prototype)도 가능해진다.
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+`Bar` 인스턴스에서 `method`를 호출하면 `method`에서 `this`는 바로 그 인스턴스를 가리킨다.
diff --git a/doc/ko/index.json b/doc/ko/index.json
new file mode 100644
index 00000000..6d22a896
--- /dev/null
+++ b/doc/ko/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden",
+    "description": "A Guide to JavaScript's Quirks and Flaws.",
+    "sections": [
+        {
+            "title": "소개",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "객체",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "함수",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Array",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "타입",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "핵심",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "기타",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/ko/intro/index.md b/doc/ko/intro/index.md
new file mode 100644
index 00000000..ea8da0ca
--- /dev/null
+++ b/doc/ko/intro/index.md
@@ -0,0 +1,41 @@
+## Intro
+
+JavaScript 언어의 핵심에 대한 내용을 모아 **JavaScript Garden**을 만들어 었다. 이 글이 초보자가 JavaScript 익히면서 자주 겪는 실수, 미묘한 버그, 성능 이슈, 나쁜 습관들 줄일 수 있도록 도와줄 것이다.
+
+JavaScript Garden은 단순히 JavaScript 언어 자체를 설명하려 만들지 않았다. 그래서 이 글에서 설명하는 주제들을 이해하려면 반드시 언어에 대한 기본 지식이 필요하다. 먼저 Mozilla Developer Network에 있는 [문서][1]로 JavaScript 언어를 공부하기 바란다.
+
+## 저자들
+
+이 글은 [Stack Overflow][2]에서 사랑받는 두 사람 [Ivo Wetzel][3]과 [Zhang Yi Jiang][4]의 작품이다. Ivo Wetzel이 글을 썼고 Zhang Yi jiang이 디자인을 맡았다.
+
+## 기여자들
+
+- [기여자들](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## 번역
+ - [박창우][]
+ - [손병대][]
+
+[박창우]: https://github.com/pismute
+[손병대]: https://github.com/miconblog
+
+## 호스팅
+
+JavaScript Garden은 Github에서 호스팅하고 있고 [Cramer Development][7]가 [JavaScriptGarden.info][8]에서 미러링해주고 있다.
+
+## 저작권
+
+JavaScript Garden은 [MIT license][9]를 따르고 [GitHub][10]에서 호스팅하고 있다. 문제를 발견하면 [이슈를 보고][11]하거나 수정해서 Pull Request를 하라. 아니면 Stack Overflow 채팅 사이트의 [Javascript room][12]에서 우리를 찾으라.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/ko/object/forinloop.md b/doc/ko/object/forinloop.md
new file mode 100644
index 00000000..fd05cedb
--- /dev/null
+++ b/doc/ko/object/forinloop.md
@@ -0,0 +1,36 @@
+## `for in` Loop
+
+객체의 프로퍼티를 탐색할때 `in` 연산자와 마찬가지로 `for in` 문도 프로토타입 체인까지 탐색한다.
+
+> **Note:** `for in`문은 배열의 `length`프로퍼티처럼 `enumerable` 속성이 `false`인 프로퍼티는 탐색하지 않는다. 
+
+    // Object.prototype을 오염시킨다.
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // bar와 moo 둘 다 출력한다.
+    }
+
+`for in`문에 정의된 기본 동작을 바꿀순 없기 때문에 루프 안에서 불필요한 프로퍼티를 필터링 해야한다. 그래서 `Object.prototype`의 [`hasOwnProperty`](#object.hasownproperty)메소드를 이용해 본래 객체의 프로퍼티만 골라낸다.
+
+> **Note:** `for in`은 프로토타입 체인을 모두 탐색하기 때문에 상속할 때마다 더 느려진다.
+
+### `hasOwnProperty`로 필터링 하기
+
+    // 위의 예제에 이어서 
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+위와 같이 사용해야 올바른 사용법이다. `hasOwnProperty` 때문에 **오직** `moo`만 출력된다. `hasOwnProperty`가 없으면 이 코드는 `Object.prototype`으로 네이티브 객체가 확장될 때 에러가 발생할 수 있다.
+
+따라서 [Proptotype 라이브러리][1]처럼 네이티브 객체를 프로토타입으로 확장한 프레임워크를 사용할 경우 `for in` 문에 `hasOwnProperty`를 사용하지 않을 경우 문제가 발생할 수 있다.
+
+### 결론
+
+`hasOwnProperty`를 항상 사용하길 권한다. 실제 코드가 동작하는 환경에서는 절대로 네이티브 객체가 프로토타입으로 확장됐다 혹은 확장되지 않았다를 가정하면 안된다.
+
+[1]: http://www.prototypejs.org/
diff --git a/doc/ko/object/general.md b/doc/ko/object/general.md
new file mode 100644
index 00000000..55041eb9
--- /dev/null
+++ b/doc/ko/object/general.md
@@ -0,0 +1,82 @@
+## 객체와 프로퍼티
+
+JavaScript에서 [`null`](#core.undefined)과 [`undefined`](#core.undefined)를 제외한 모든 것들은 객체처럼 동작한다.
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+숫자 리터럴은 객체처럼 사용되지 못할꺼라는 오해가 있는데 이것은 단지 JavaScript 파서의 문제일 뿐이다. JavaScript 파서는 숫자에 *Dot Notation*이 들어가면 오류라고 생각한다.
+
+    2.toString(); // SyntaxError가 난다.
+
+하지만, 숫자를 객체처럼 사용할수 있는 꼼수가 몇 가지 있다.
+
+    2..toString(); // 두 번째 점은 잘 된다.
+    2 .toString(); // 왼쪽 공백이 있으면 잘 된다.
+    (2).toString(); // 2를 먼저 해석한다.
+
+### Object 타입
+
+JavaScript 객체는 name/value 쌍으로 된 프로퍼티로 구성되기 때문에 [*Hashmap*][1]처럼 사용될 수도 있다. 
+
+객체 리터럴인 Object Notation으로 객체를 만들면 `Object.prototype`을 상속받고 [프로퍼티를 하나도 가지지 않은](#object.hasownproperty) 객체가 만들어진다.
+
+    var foo = {}; // 깨끗한 새 객체를 만든다.
+
+    // 값이 12인 'test' 프로퍼티가 있는 객체를 만든다.
+    var bar = {test: 12}; 
+
+### 프로퍼티 접근
+
+객체의 프로퍼티는 객체이름 다음에 점을 찍어(Dot Notation) 접근하거나 각괄호를 이용해(Square Bracket Notation) 접근할 수 있다.
+
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+
+    var get = 'name';
+    foo[get]; // kitten
+
+    foo.1234; // SyntaxError
+    foo['1234']; // works
+
+두 방식 모두 거의 동일하게 동작한다. 다만 차이가 있다면 각괄호 방식은 프로퍼티 이름을 동적으로 할당해서 값에 접근 할수 있지만 점을 이용한 방식은 구문 오류를 발생시킨다.
+
+### 프로퍼티 삭제
+
+객체의 프로퍼티를 삭제하려면 `delete`를 사용해야만 한다. 프로퍼티에 `undefined`나 `null`을 할당하는 것은 프로퍼티를 삭제하는 것이 아니라 프로퍼티에 할당된 *value*만 지우고 *key*는 그대로 두는 것이다.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+
+위 코드의 출력 결과는 `baz`만 제거했기 때문에 `bar undefined`와 `foo null`은 출력되고 `baz`와 관련된 것은 출력되지 않는다.
+
+### Notation of Keys
+
+    var test = {
+        'case': 'I am a keyword, so I must be notated as a string',
+        delete: 'I am a keyword, so me too' // SyntaxError가 난다.
+    };
+
+프로퍼티는 따옴표 없는 문자열(plain characters)과 따옴표로 감싼 문자열(strings)을 모두 Key 값으로 사용할 수 있다. 하지만 위와 같은 코드는 JavaScript 파서의 잘못된 설계 때문에 구버전(ECMAScript 5 이전 버전)에서는 `SystaxError`가 발생할 것이다.
+
+위 코드에서 문제가 되는 `delete` 키워드를 따옴표로 감싸면 구버전의 JavaScript 엔진에서도 제대로 해석될 것이다.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
diff --git a/doc/ko/object/hasownproperty.md b/doc/ko/object/hasownproperty.md
new file mode 100644
index 00000000..fa36645e
--- /dev/null
+++ b/doc/ko/object/hasownproperty.md
@@ -0,0 +1,43 @@
+## `hasOwnProperty`
+
+어떤 객체의 프로퍼티가 자기 자신의 프로퍼티인지 아니면 [프로토타입 체인](#object.prototype)에 있는 것인지 확인하려면 `hasOwnProperty` 메소드를 사용한다. 그리고 이 메소드는 `Object.prototype`으로 부터 상속받아 모든 객체가 가지고 있다.
+
+> **Note:** hasOwnProperty 메소드로는 어떤 프로퍼티가 존재하는지 확인하는 용도로는 사용할수 있지만, 그 값이 `undefined`일 수 있기 때문에 어떤 프로퍼티의 값이 `undefined`인지 확인하는 용도로 사용하긴 어렵다.
+
+`hasOwnProperty`메소드는 프로토타입 체인을 탐색하지 않고, 프로퍼티를 다룰수있는 유일한 방법이다.
+
+    // Object.prototype을 오염시킨다.
+    Object.prototype.bar = 1; 
+    var foo = {goo: undefined};
+    
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+`hasOwnProperty` 메소드는 어떤 프로퍼티가 자기 자신의 프로퍼티인지 아닌지 정확하게 알려주기 때문에 객체의 프로퍼티를 순회할때 꼭 필요하다. 그리고 프로토타입 체인 어딘가에 정의된 프로퍼티만을 제외하는 방법은 없다.  
+
+### `hasOwnProperty` 메소드도 프로퍼티다
+
+JavaScript는 `hasOwnProperty`라는 이름으로 프로퍼티를 덮어 쓸수도 있다. 그래서 객체 안에 같은 이름으로 정의된 `hasOwnProperty`가 있을 경우, 본래 `hasOwnProperty`의 값을 정확하게 얻고 싶다면 다른 객체의 `hasOwnProperty` 메소드를 빌려써야 한다.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // 항상 false를 반환한다.
+
+    // 다른 객체의 hasOwnProperty를 사용하여 foo 객체의 프로퍼티 유무를 확인한다.
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+    // Object에 있는 hasOwnProperty를 사용해도 된다.
+    Object.prototype.hasOwnProperty.call(obj, 'bar'); // true
+
+
+### 결론
+
+어떤 객체에 원하는 프로퍼티가 있는지 확인하는 가장 확실한 방법은 `hasOwnProperty`를 사용하는 것이다. [`for in` loop](#object.forinloop)에서 네이티브 객체에서 확장된 프로퍼티를 제외하고 순회하려면 `hasOwnProperty`와 함께 사용하길 권한다. 
diff --git a/doc/ko/object/prototype.md b/doc/ko/object/prototype.md
new file mode 100644
index 00000000..606d8105
--- /dev/null
+++ b/doc/ko/object/prototype.md
@@ -0,0 +1,79 @@
+## Prototype
+
+Javascript는 클래스 스타일의 상속 모델을 사용하지 않고 *프로토타입* 스타일의 상속 모델을 사용한다.
+
+'이 점이 JavaScript의 약점이다.'라고 말하는 사람들도 있지만 실제로는 prototypal inheritance 모델이 훨씬 더 강력하다. 그 이유는 프로토타입 모델에서 클래스 모델을 흉내 내기는 매우 쉽지만, 반대로 클래스 모델에서 프로토타입 모델을 흉내 내기란 매우 어렵기 때문이다.
+
+실제로 Prototypal Inheritance 모델을 채용한 언어 중에서 JavaScript만큼 널리 사용된 언어가 없었기 때문에 두 모델의 차이점이 다소 늦게 정리된 감이 있다.
+
+먼저 가장 큰 차이점은 *프로토타입 체인*이라는 것을 이용해 상속을 구현한다는 점이다.
+
+> **Note:** 간단히 말해서 `Bar.prototype = Foo.prototype`은 두 객체가 **하나의 프로토타입**을 공유하는 것이다. 그래서 한 객체의 프로토타입을 변경하면 그 프로토타입 객체를 사용하는 다른 객체도 영향을 받는다. 따라서 대부분의 경우 프로토타입을 변경하지는 않는다.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Foo의 인스턴스를 만들어 Bar의 prototype에 할당한다.
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Bar 함수를 생성자로 만들고
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar() // bar 인스턴스를 만든다.
+
+    // 결과적으로 만들어진 프로토타입 체인은 다음과 같다. 
+    test [instance of Bar]
+        Bar.prototype [instance of Foo] 
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* etc. */ }
+
+위 코드에서 `test` 객체는 `Bar.prototype`과 `Foo.prototype`을 둘 다 상속받았기 때문에 Foo에 정의한 `method` 함수에 접근할 수 있다. 그리고 프로토타입 체인에 있는 `Foo` 인스턴스의 `value` 프로퍼티도 사용할 수 있다. `new Bar()`를 해도 `Foo` 인스턴스는 새로 만들어지지 않고 Bar의 prototype에 있는 것을 재사용한다. 그래서 모든 Bar 인스턴스는 **같은** `value` 프로퍼티를 공유한다.
+
+> **Note:** `Bar.prototype = Foo`라고 하는 것은 `Foo`의 prototype을 가리키는 것이 아니라 Foo라는 Function의 prototype을 가리키는 것이다. 그래서 프로토타입 체인에 `Foo.prototype` 대신 `Function.prototype`이 들어가 있기 때문에 `method` 프로퍼티는 찾지 못한다.
+
+### 프로토타입 탐색
+
+객체의 프로퍼티에 접근하려고 하면 JavaScript는 해당 이름의 프로퍼티를 찾을 때까지 프로토타입 체인을 거슬러 올라가면서 탐색하게 된다.
+
+프로토타입 체인을 끝까지 탐색했음에도(보통은 `Object.prototype`임) 불구하고 원하는 프로퍼티를 찾지 못하면 [undefined](#core.undefined)를 반환한다.
+
+### prototype 프로퍼티
+
+prototype 프로퍼티는 프로토타입 체인을 만드는 데 사용하고 어떤 값이든 할당할 수 있지만, primitive 값을 할당되면 무시한다.
+
+    function Foo() {}
+    Foo.prototype = 1; // 무시됨
+
+반면에 위 예제처럼 객체를 할당하면 프로토타입 체인이 동적으로 잘 만들어진다.
+
+### 성능
+
+프로토타입 체인을 탐색하는 시간이 오래걸릴수록 성능에 부정적인 영향을 줄수있다. 특히 성능이 중요한 코드에서 프로퍼티 탐색시간은 치명적인 문제가 될수있다. 가령, 없는 프로퍼티에 접근하려고 하면 항상 프로토타입 체인 전체를 탐색하게 된다.
+
+뿐만아니라 객체를 [순회(Iterate)](#object.forinloop)할때도 프로토타입 체인에 있는 **모든** 프로퍼티를 탐색하게 된다.
+
+### 네이티브 프로토타입의 확장
+
+종종 `Object.prototype`을 이용해 내장 객체를 확장하는 경우가 있는데, 이것도 역시 잘못 설계된 것중에 하나다.
+
+위와 같이 확장하는 것을 [Monkey Patching][1]라고 부르는데 *캡슐화*를 망친다. 물론 [Prototype][2]같은 유명한 프레임워크들도 이런 확장을 사용하지만, 기본 타입에 표준도 아닌 기능들을 너저분하게 추가하는 이유를 여전히 설명하지 못하고 있다.
+
+기본 타입을 확장해야하는 유일한 이유는 [`Array.forEach`][3]같이 새로운 JavaScript 엔진에 추가된 기능을 대비해 미리 만들어 놓는 경우 말고는 없다.
+
+### 결론
+
+프로토타입을 이용해 복잡한 코드를 작성하기 전에 반드시 프로토타입 상속 (Prototypal Inheritance) 모델을 완벽하게 이해하고 있어야 한다. 뿐만아니라 프로토타입 체인과 관련된 성능 문제로 고생하지 않으려면 프로토타입 체인이 너무 길지 않도록 항상 주의하고 적당히 끊어줘야 한다. 마지막으로 새로운 JavaScript 기능에 대한 호환성 유지 목적이 아니라면 절대로 네이티브 프로토타입을 확장하지마라.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
diff --git a/doc/ko/other/timeouts.md b/doc/ko/other/timeouts.md
new file mode 100644
index 00000000..b41df30b
--- /dev/null
+++ b/doc/ko/other/timeouts.md
@@ -0,0 +1,123 @@
+### `setTimeout`과 `setInterval`
+
+JavaScript는 `setTimeout`과 `setInterval`함수를 이용해 비동기로 함수를 실행시킬수있다.
+
+> **Note:** Timeout은 ECMAScript 표준이 아니라 [DOM][1]때문에 구현됐다.
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // 0보다 큰 수를 반환한다.
+
+`setTimeout`을 호출하면 타이머의 ID를 반환하고 **대략** 1,000밀리 초 후에 `foo`를 실행시킨다. `foo`는 **딱 한 번만** 실행한다.
+
+JS엔진은 타이머에 설정한 시간(timer resolution)에 따라서 코드를 실행하지만 단일 쓰레드이기 때문에 특정 코드는 실행이 지연 될수도 있다. 따라서 `setTimeout`으로 코드가 실행돼야 할 시간을 정해줘도 **정확하게 그 시간에 실행되지 않을수도 있다.**.
+
+첫 번째 인자로 넘긴 함수는 전역 객체가 실행시킨다. 따라서 인자로 넘겨진 함수 내부의 [`this`](#function.this)는 *전역* 객체를 가리키게 된다.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this는 전역 객체를 가리키기 때문에 
+            console.log(this.value); // undefined를 출력한다.
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+> **Note:** `setTimeout`의 첫 번째 파라미터에 **함수** 객체를 넘겨야 하는 데 `setTimeout(foo(), 1000)`처럼 함수의 실행 결과를 넘기는 실수를 저지를 때가 잦다. 이럴 때 `setTimeout`은 그냥 `undefined`를 반환할 뿐이지 에러를 발생시키지 않는다.
+
+### 함수 호출을 쌓는(Stacking) `setInterval`함수.
+
+`setTimeout`은 딱 한 번 함수를 호출하지만 `setInterval`은 이름처럼 **지정한 시간마다** 함수를 실행시켜준다. 하지만 이 함수의 사용은 좀 생각해봐야한다.
+
+`setInterval`은 실행하는 코드가 일정시간 동안 블럭되도 계속해서 함수를 호출하기 때문에 주기가 짧은 경우 함수 호출이 쉽게 쌓여버린다.
+
+    function foo(){
+        // 1초 동안 블럭함.
+    }
+    setInterval(foo, 100);
+
+위 코드에서 `foo`함수는 호출될 때마다 1초씩 실행을 지연시킨다.
+
+하지만 `foo`함수가 블럭되더라도 `setInterval`함수는 계속해서 함수 호출을 쌓기 때문에 `foo`함수 호출이 끝나면 *10번* 이상의 함수 호출이 쌓여서 대기하고 있을수도 있다.
+(역주: 따라서 함수 호출이 쌓이게 되면 원래 기대했던 실행 주기를 보장받지 못한다.)
+
+### 블럭되는 코드 해결법
+
+앞에 문제를 해결하는 가장 쉽고 일반적인 방법은 `setTimeout` 함수에서 자기 자신을 다시 호출하는 방법이다.
+
+    function foo(){
+        // something that blocks for 1 second
+        setTimeout(foo, 100);
+    }
+    foo();
+
+이 방법은 함수 호출이 쌓이지도 않을 뿐만 아니라 `setTimeout` 호출을 해당 함수 안에서 관리하기 때문에 `foo` 함수에서 계속 실행할지 말지도 조절할 수 있다.
+
+### 타이머 없애기
+
+`clearTimeout`과 `clearInterval` 함수로 setTimeout과 setInterval로 등록한 timeout과 interval을 삭제할 수 있다. `set` 함수들이 반환한 id를 저장했다가 `clear` 함수를 호출해서 삭제한다.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### 모든 타이머 없애기
+
+등록한 timeout과 interval을 한꺼번에 제거하는 내장 함수는 없다. 따라서 좀 무식하지만 직접 구현해야 한다.
+
+    // "모든" 타이머 지우기
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+위와 같은 방법은 숫자가 미치지 못하는 타이머는 여전히 남아있을수 있다는 단점이 있다. 또 다른 해결 방법은 타이머가 반환하는 값이 항상 전보다 1만큼 큰 수를 반환한다는 점을 착안한 방법이다.
+
+    // "모든" 타이머 지우기
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+이 방법은 모든 주요 브라우저에서 문제없이 잘 동작하지만 ID가 항상 순차적이어야 한다고 표준에 명시된 것이 아니다. 그러므로 timeout ID를 모두 저장했다가 삭제하는 것이 가장 안전하다. 그러면 전부 깨끗하게 제거할 수 있다.
+
+### 보이지 않게 사용되는 `eval`함수
+
+`setTimeout`과 `setInterval`의 첫 파라미터로 문자열을 넘길 수 있다. 하지만 내부적으로 `eval`을 사용하는 것이기 때문에 절대 사용해서는 안된다.
+
+> **Note:** timeout 함수는 ECMAScript 표준이 아니기 때문에 문자열로 넘어오는 첫번째 인자에 대한 해석은 구현체마다 다르다. 예를 들어, Microsoft의 JScript는 `eval`이 아니라 `Function` 생성자를 사용한다.
+
+    function foo() {
+        // 이게 호출됨
+    }
+
+    function bar() {
+        function foo() {
+            // 이것은 절대 호출 안 됨
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+이 경우 `eval`이 [그냥(directly)](#core.eval) 호출되는 것이 아니다. `setTimeout`에 인자로 넘어간 문자열은 *전역* 스코프에서 실행되기 때문에 `bar`함수 영역에 있는 지역 변수 `foo`가 실행되는 것이 아니라 *전역* 스코프에 있는 `foo`가 실행된다.
+
+함수에 파라미터를 넘겨야 하면 스트링을 사용하지 말아야 한다.
+
+    function foo(a, b, c) {}
+    
+    // 절대 사용하면 안 됨
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // 대신 익명 함수를 사용하는 게 좋다.
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **Note:** `setTimeout(foo, 1000, 1, 2, 3)`처럼 사용하는 것도 가능하지만, 이것도 권장하지 않는다. [메소드](#function.this)를 사용할 때 잡아내기 어려운 에러가 날 수 있다.
+
+### 결론
+
+`setTimeout`과 `setInterval`함수에 문자열 인자를 절대 사용해서는 안된다. 핸들러 함수에 인자를 넘기는 코드도 **절대** 좋은 코드가 아니다. *익명 함수*을 사용해서 호출해야 한다.
+
+그리고 `setInterval`은 해당 핸들러가 블럭되든 말든 상관하지 않기 때문에 되도록이면 쓰지말자.
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
diff --git a/doc/ko/types/casting.md b/doc/ko/types/casting.md
new file mode 100644
index 00000000..7a6e28ea
--- /dev/null
+++ b/doc/ko/types/casting.md
@@ -0,0 +1,58 @@
+## 타입 캐스팅
+
+JavaScript는 Weak Typing 언어이기 때문에 필요할 때마다 알아서 타입을 변환한다.
+
+    // 다음은 모두 true
+    new Number(10) == 10; // Number.toString()이 호출되고 
+                          // 다시 Number로 변환된다.
+
+    10 == '10';           // 스트링은 Number로 변환된다.
+    10 == '+10 ';         // 이상한 스트링
+    10 == '010';          // 엉뚱한 스트링
+    isNaN(null) == false; // null은 NaN이 아녀서 0으로 변환된다.
+
+    // 다음은 모두 false
+    10 == 010;
+    10 == '-10';
+
+> **ES5 Note:** `0`으로 시작하는 숫자 리터럴은 8진수다. 하지만, ECMAScript 5의 strict 모드에서는 8진수로 더이상 해석하지 않는다.
+
+위와 같은 문제들은 ***반드시** [삼중 등호 연산자](#types.equality)를 이용해 해결하길 권한다. 물론 삼중 등호로 많은 결점을 보완할 수 있지만, 여전히 weak typing 시스템 때문에 생기는 많은 문제가 남아있다.
+
+### 기본 타입 생성자
+
+`Number`나 `String` 같은 기본 타입들의 생성자는 `new` 키워드가 있을 때와 없을 때 다르게 동작한다.
+
+    new Number(10) === 10;     // False, Object와 Number
+    Number(10) === 10;         // True, Number와 Number
+    new Number(10) + 0 === 10; // True, 타입을 자동으로 변환해주기 때문에 
+
+`new` 키워드와 함께 `Number` 같은 기본 타입의 생성자를 호출하면 객체를 생성하지만 `new` 없이 호출하면 형 변환만 시킨다.
+
+그리고 객체가 아니라 단순히 값이나 리터럴을 사용하면 타입 변환이 더 많이 일어난다.
+
+가능한 정확하게 타입을 변환해주는 것이 최선이다.
+
+### 스트링으로 변환하기
+
+    '' + 10 === '10'; // true
+
+숫자를 빈 스트링과 더하면 쉽게 스트링으로 변환할 수 있다.
+
+### 숫자로 변환하기
+
+    +'10' === 10; // true
+
+`+` 연산자만 앞에 붙여주면 스트링을 쉽게 숫자로 변환할 수 있다.
+
+### Boolean으로 변환하기
+
+'!' 연산자를 두 번 사용하면 쉽게 Boolean으로 변환할 수 있다.
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
diff --git a/doc/ko/types/equality.md b/doc/ko/types/equality.md
new file mode 100644
index 00000000..a9daccb5
--- /dev/null
+++ b/doc/ko/types/equality.md
@@ -0,0 +1,57 @@
+## 객체 비교하기
+
+JavaScript에서 객체를 비교하는 방법은 두 가지가 있다. 
+
+### 이중 등호 연산자
+
+이중 등호 연산자는 `==`을 말한다.
+
+JavaScript는 Weak Typing을 따르기 때문에 이중 등호를 이용해 비교할 때 두 객체의 자료형을 **강제로** 변환한다.
+
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+이 표는 이중 등호를 사용하면 왜 안되는지를 보여준다. 이 복잡한 변환 규칙은 실제로 골치 아픈 버그를 만들어 낸다.
+
+게다가 강제로 타입을 변환하게 되면 성능에도 영향을 준다. 예를 들어 문자와 숫자를 비교하려면 반드시 먼저 문자를 숫자로 변환해야 한다.
+
+### 삼중 등호 연산자
+
+삼중 등호 연산자는 `===`을 말한다.
+
+삼중 등호는 강제로 타입을 변환하지 않는다는 사실을 제외하면 이중 등호와 동일하다. 
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+위 결과가 훨씬 더 명확하고 문제가 쉽게 드러난다. 삼중 등호를 사용하면 코드를 좀 더 튼튼하게 만들수 있고, 비교하는 두 객체의 타입이 다르면 더 좋은 성능을 얻을 수도 있다.
+
+### 객체 비교하기
+
+이중 등호와(`==`)와 삼중 등호(`===`)는 둘 다 **값을 비교하는** 연산이지만 피연산자중에 Object 타입이 하나라도 있으면 다르게 동작한다.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+두 연산자 모두 두 객체의 값이 같은지를 비교하지 않고, 두 객체가 **같은 객체(identity)**인지를 비교한다. C에서 포인터를 비교하거나 Python의 is처럼 같은 인스턴스인지 비교하는 것이다.
+
+### 결론
+
+**삼중 등호 연산자**를 사용할 것을 강력하게 권한다. 비교하기 위해서 타입 변환이 필요하면 언어의 복잡한 변환 규칙에 맡기지 말고 꼭 명시적으로 변환한 후에 비교해야 한다.
diff --git a/doc/ko/types/instanceof.md b/doc/ko/types/instanceof.md
new file mode 100644
index 00000000..621f8121
--- /dev/null
+++ b/doc/ko/types/instanceof.md
@@ -0,0 +1,31 @@
+## `instanceof` 연산자
+
+`instanceof`연산자는 두 피연산자의 생성자를 비교할때 사용하고 직접 만든 객체를 비교할 때 매우 유용하다. 내장 타입에 쓰는 경우에는 [typeof](#types.typeof)처럼 거의 쓸모가 없다.
+
+### 커스텀 객체를 `intanceof`로 비교하기
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // Bar.prototype에 함수 객체인 Foo를 할당하면
+    // Bar의 인스턴스는 Foo의 인스턴스가 아니다.
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### 기본 내장 객체 타입을 `intanceof`로 비교하기
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+JavaScript 컨텍스트마다(웹 브라우저의 도큐먼트 같은) 객체의 생성자는 다를 수밖에 없어서 `instanceof`는 다른 JavaScript 컨텍스트에 있는(웹 브라우저의 다른 도큐먼트에 있는) 객체와는 비교할 수 없다.
+
+### 결론
+
+`instanceof`는 한 JavaScript 컨텍스트 내에서 사용자가 만든 타입의 객체를 비교할 때에만 유용하다. [`typeof`](#types.typeof)처럼 다른 목적으로는 사용하지 않는 것이 좋다.
diff --git a/doc/ko/types/typeof.md b/doc/ko/types/typeof.md
new file mode 100644
index 00000000..a2db9595
--- /dev/null
+++ b/doc/ko/types/typeof.md
@@ -0,0 +1,63 @@
+## `typeof` 연산자
+
+`typeof` 연산자도 [`instanceof`](#types.instanceof) 연산자와 함께 JavaScript에서 치명적으로 잘못 설계된 부분이다. 이건 정말이지 아무짝에도 쓸모가 없다.
+
+`instanceof` 연산자는 그래도 여전히 쓸만한 데가 좀 있는데 `typeof` 연산자는 객체의 타입을 검사하는 것 외에는 쓸만한데가 없고, 이마저도 거의 쓸일이 없다.
+
+> **Note:** `typeof` 연산자는 함수처럼 `typeof(obj)`로 사용할수 있지만 함수 호출은 아니다. 괄호 안의 값은 `typeof`의 피연산자로 적용되고 그 결과가 반환된다. `typeof`라는 함수는 **없다**.
+
+### JavaScript 타입 표
+
+    Value               Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+위 표에서 *Type*은 `typeof`가 반환하는 값이다. 위 표에서처럼 일치되는 값이 거의 없다.
+
+위 표에서 *Class*는 객체 내부에 있는 `[[Class]]` 프로퍼티의 값을 말한다.
+
+> **표준**에는 `[[Class]]`의 값은 `Arguments`, `Array`, `Boolean`, `Date`, `Error`, `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`중 하나라고 나와있다.
+
+`[[Class]]` 프로퍼티의 값을 가져다 쓰려면 `Object.prototype`의 `toString` 메소드를 사용한다.
+
+### 객체의 클래스
+
+표준에 의하면 `[[Class]]` 값을 얻는 방법은 `Object.prototype.toString` 하나뿐이다.
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+`Object.prototype.toString`은 [this](#function.this)의 `[[Class]]` 값을 가져오는 것이니까 this를 obj로 바꾸어 사용한다.
+
+> **ES5 Note:** ECMAScript 5에서 `Object.prototype.toString`의 컨텍스트가 `null`과 `undefined`일 때 `Object`가 아니라 각각 `Null`과 `Undefined`를 반환하도록 수정됐다.
+
+### 변수가 Undefined인지 확인하기
+
+    typeof foo !== 'undefined'
+
+위 코드는 `foo`가 정의됐는지 아닌지를 확인해준다. 정의되지 않은 변수에 접근하면 `ReferenceError` 나는데 이것을 방지할 수 있다. `typeof`가 유용한 건 이때뿐이다.
+
+### 결론
+
+객체의 타입을 검사하려면 `Object.prototype.toString`를 사용해야 한다. 다른 방법은 신뢰할 수 없다. 위 표에서 보여준 것처럼 typeof가 반환하는 값은 표준에 나와 있지 않기 때문에 구현방법도 제각각이다.
+
+변수가 정의됐는지 확인할 때를 제외하고 **가급적** `typeof`는 피해야한다.
\ No newline at end of file
diff --git a/doc/language.json b/doc/language.json
index 1c1bdffc..df12ab7d 100644
--- a/doc/language.json
+++ b/doc/language.json
@@ -1,5 +1,4 @@
 {
     "default": "en",
-    "listed": ["en", "fi", "ru", "zh", "tr", "pl"]
+    "listed": ["by","en","es","fi","fr","hu","it","ja","ko","pl","ptbr","ru","tr","zh","zhtw"]
 }
-
diff --git a/doc/pl/array/constructor.md b/doc/pl/array/constructor.md
index 79772f43..e715c840 100644
--- a/doc/pl/array/constructor.md
+++ b/doc/pl/array/constructor.md
@@ -2,7 +2,7 @@
 
 Zaleca się zawsze korzystać z literału tablicy - notacja `[]` - podczas tworzenia 
 nowych tablic, ponieważ konstruktor `Array` niejednoznacznie interpretuje 
-parametry do niego przekazane.
+przekazane do niego parametry.
 
     [1, 2, 3]; // Rezultat: [1, 2, 3]
     new Array(1, 2, 3); // Rezultat: [1, 2, 3]
@@ -11,18 +11,18 @@ parametry do niego przekazane.
     new Array(3); // Rezultat: []
     new Array('3') // Rezultat: ['3']
 
-W przypadku gdy tylko jeden argument zostanie przekazany do kostruktora `Array` i 
+W przypadku, gdy tylko jeden argument zostanie przekazany do kostruktora `Array` i 
 ten argument jest typu `Number`, konstruktor zwróci nową *dziwną* tablicę 
-z ustawioną właściwością `length` na wartość przekazaną jako argument. Należy 
-zauważyć, że **tylko** właściwość `length` zostanie ustawiona w ten sposób,
-rzeczywiste indeksy w tej tablicy nie zostaną zainicjalizowane.
+z właściwością `length` ustawioną na wartość przekazaną jako argument. Należy 
+zauważyć, że **tylko** właściwość `length` zostanie ustawiona w ten sposób.
+Rzeczywiste indeksy w tej tablicy nie zostaną zainicjalizowane.
 
     var arr = new Array(3);
     arr[1]; // undefined
     1 in arr; // zwraca false, indeks nie został ustawiony
 
-Możliwość ustanienia z góry długości tablicy jest użyteczna tylko w kilku 
-przypadkach, jak powtarzanie ciągu znaków, w którym unika się stosowania 
+Możliwość ustalenia z góry długości tablicy jest użyteczna tylko w kilku 
+przypadkach, jak np. powtarzanie ciągu znaków, w którym unika się stosowania 
 pętli `for`.
 
     // count - ilosc powtorzen
@@ -31,7 +31,7 @@ pętli `for`.
 
 ### Wnioski
 
-W miare możliwości należy unikać używania konstruktora `Array`. Literały są 
-zdecydowanie lepszym rozwiązaniem, są krótsze i mają bardziej precyzyjną składnię.
+W miarę możliwości należy unikać używania konstruktora `Array`. Literały są 
+zdecydowanie lepszym rozwiązaniem. Są krótsze i mają bardziej precyzyjną składnię.
 Zwiększają również czytelność kodu.
 
diff --git a/doc/pl/array/general.md b/doc/pl/array/general.md
index c30056d7..499e0d62 100644
--- a/doc/pl/array/general.md
+++ b/doc/pl/array/general.md
@@ -1,17 +1,17 @@
-## Iterowanie po tablicach oraz właściwości tablic
+## Iterowanie po tablicach oraz właściwościach tablic
 
-Mimo, że tablice w JavaScript są obiektami, nie ma dobrych powodów do używania 
-[`pętli for in`](#object.forinloop) do iteracji po nich. W rzeczywiści istnieje 
-wiele dobrych powodów **przeciwko** wykorzystania `for in` na tablicach.
+Mimo, że tablice w JavaScript są obiektami, nie ma dobrych powodów, aby używać 
+[`pętli for in`](#object.forinloop) do iteracji po nich. W rzeczywstości istnieje 
+wiele dobrych powodów **przeciwko** wykorzystaniu `for in` na tablicach.
 
 > **Uwaga:** Tablice JavaScriptowe **nie** są *tablicami asocjacyjnymi*. JavaScript
 > posiada tylko [obiekty](#object.general) do mapowania kluczy do wartości. Jednakże 
 > tablice asocjacyjne **zachowują** porządek, natomiast obiekty **nie zachowują**.
 
 Ponieważ pętla `for in` wylicza wszystkie właściwości, które są wewnątrz 
-łańcucha prototypów i jedynym sposobem aby wykluczyć te właściwości to użycie 
-[`hasOwnProperty`](#object.hasownproperty), ale wówczas pętla staje się 
-**dwadzieście razy** wolniejsza od normalnej pętli `for`.
+łańcucha prototypów, jedynym sposobem, aby wykluczyć te właściwości, jest użycie 
+[`hasOwnProperty`](#object.hasownproperty). Wówczas pętla staje się jednak
+**dwadzieścia razy** wolniejsza od normalnej pętli `for`.
 
 ### Iteracja
 
@@ -23,22 +23,22 @@ użyć klasycznej pętli `for`.
         console.log(list[i]);
     }
 
-Jest tam jeszcze jeden dodatkowy haczyk w przykładzie powyżej. Jest to zbuforowanie 
+W powyższym przykładzie jest jeszcze jeden dodatkowy haczyk. Jest to zbuforowanie 
 długości tablicy poprzez `l = list.length`.
 
-Mimo, że właściwość `length` jest zdefiniowana w wewnątrz tablicy, istnieje nadal 
-dodatkowy koszt na wyszukiwanie tej właściwości przy każdej iteracji w pętli. 
-Chociaż najnowsze silniki JavaScript **mogą** zastosować optymalizację w tym 
-przypadku. Nie ma jednak możliwość ustalenia czy kod będzie wykonywany w jednym 
-z tych nowych silników czy też nie.
+Mimo, że właściwość `length` jest zdefiniowana wewnątrz tablicy, istnieje nadal 
+dodatkowy koszt wyszukiwania tej właściwości przy każdej iteracji w pętli. 
+Najnowsze silniki JavaScript **mogą** zastosować w tym 
+przypadku optymalizację. Nie ma jednak możliwości ustalenia, czy kod będzie wykonywany w jednym 
+z tych nowych silników, czy też nie.
 
-W rzeczywistości pomijając buforowanie długości tablicy może spowodować, że pętla 
+W rzeczywistości pominięcie buforowania długości tablicy może spowodować, że pętla 
 będzie tylko **w połowie tak szybka** jak ta z buforowaniem długości.
 
 ### Właściwość `length`
 
-Mimo, że *getter* właściwości `length` po prostu zwraca liczbę elementów, które są 
-zawarte w tablicy, to *setter* może być użyta do **skracania** tablicy.
+Mimo, że *getter* właściwości `length` zwraca po prostu liczbę elementów, które są 
+zawarte w tablicy, to *setter* może być użyty do **skracania** tablicy.
 
     var foo = [1, 2, 3, 4, 5, 6];
     foo.length = 3;
@@ -54,5 +54,5 @@ Przypisanie mniejszej długości spowoduje skrócenie tablicy, ale zwiększenie
 
 Aby uzyskać najlepszą wydajność zaleca się, aby zawsze używać zwykłej pętli `for`
 i zbuforowanie właściwości `length`. Korzystanie z pętli `for in` na tablicy jest 
-znakiem źle napisanego kodu, który jest podatny na błędy i ma słabą wydajność.
+oznaką źle napisanego kodu, który jest podatny na błędy i ma słabą wydajność.
 
diff --git a/doc/pl/core/eval.md b/doc/pl/core/eval.md
index 6b66b37c..9a0ae0d6 100644
--- a/doc/pl/core/eval.md
+++ b/doc/pl/core/eval.md
@@ -1,4 +1,4 @@
-## Dlaczego nie należy używać `eval`
+## Dlaczego nie należy używać `eval`?
 
 Funkcja `eval` uruchomi podany string jako kod JavaScript w lokalnym zasięgu (scopie).
 
@@ -11,8 +11,8 @@ Funkcja `eval` uruchomi podany string jako kod JavaScript w lokalnym zasięgu (s
     test(); // 3
     foo; // 1
 
-Niestaty `eval` zostanie wykonana w lokalnym zasięgu tylko jeżeli została wywołana 
-**bezpośrednio** *i* nazwa wołanej funkcji równa sie `eval`.  
+Niestaty, `eval` zostanie wykonana w lokalnym zasięgu tylko wtedy, gdy zostanie wywołana 
+**bezpośrednio** *i* nazwa wywoływanej funkcji równa się `eval`.  
 
     var foo = 1;
     function test() {
@@ -30,20 +30,19 @@ osiągnąć ten sam efekt **nie** używając `eval`.
 ### `eval` w przebraniu
 
 [Funkcje wykonywane po upływie czasu](#other.timeouts) `setTimeout` i `setInterval` 
-mogą przyjąć string jako pierwszy argument. String ten zostanie **zawsze** wykonany 
-w globalnym zasięgu, ponieważ funkcja `eval` zostanie wywołana niebezpośrednio w tym 
-przypadku.
+mogą przyjąć string jako pierwszy argument. String ten **zawsze** będzie wykonywany 
+w globalnym zasięgu, ponieważ funkcja `eval` jest w tym wypadku wywoływana pośrednio.
 
 ### Problemy z bezpieczeństwem
 
 Funkcja `eval` jest również problematyczna od strony bezpieczeństwa, ponieważ 
-wykonuje **każdy** kod, który zostanie do niej przekazany i nie należy **nigdy** 
-używać jej na stringach nieznanego lub niezaufanego pochodzenia.
+wykonuje **każdy** kod, który zostanie do niej przekazany i **nigdy** nie należy
+jej używać na stringach nieznanego lub niezaufanego pochodzenia.
 
 ### Wnioski
 
-Funkcja `eval` nie powinna być w ogole używana, każdy kod, który ją wykorzystuje 
+Funkcja `eval` nie powinna być w ogóle używana. Każdy kod, który jej używa
 powinien zostać sprawdzony pod względem działania, wydajności i bezpieczeństwa. 
 W przypadku gdy użycie `eval` jest niezbędne do działania, wówczas taki kod 
-należy przemyśleć raz jeszcze i *ulepszyć* kod aby nie wymagał użycia `eval`. 
+należy ponownie przemyśleć i *ulepszyć* aby nie wymagał użycia `eval`. 
 
diff --git a/doc/pl/core/semicolon.md b/doc/pl/core/semicolon.md
index 6dcaf9cb..7f1410cf 100644
--- a/doc/pl/core/semicolon.md
+++ b/doc/pl/core/semicolon.md
@@ -1,9 +1,9 @@
 ## Automatyczne wstawianie średnika
 
-Mimo, że JavaScript ma składnię podobną do języka C, to **nie** wymusza stosowania 
+Mimo że JavaScript ma składnię podobną do języka C, to **nie** wymusza stosowania 
 średników w kodzie źródłowym. Istnieje możliwość ich pominięcia.  
 
-Lecz JavaScript nie jest językiem bez średników, tak na prawdę potrzebuje 
+JavaScript nie jest językiem bez średników, tak na prawdę potrzebuje 
 średników aby zinterpretować kod źródłowy. Jednakże parser JavaScript 
 **automatycznie** wstawia średniki o ile napotka błąd parsowania związany z 
 brakiem średnika.
@@ -19,7 +19,7 @@ Parser dodaje średnik, i próbuje jeszcze raz sparsować skrypt.
     test()
 
 Automatyczne wstawianie średników jest uważane za jeden z **największych** błędów 
-konstrukcji języka, ponieważ *może* ono zachowanie kodu.
+konstrukcji języka, ponieważ *może* ono zmienić zachowanie kodu.
 
 ### Jak działa wstawianie
 
@@ -84,11 +84,11 @@ Poniżej znajduje się rezultat "zgadywania" parsera.
     })(window); //<- wstawiony
 
 > **Uwaga:** Parser JavaScript nie potrafił "odpowiednio" zinterpretować 
-> deklaracji return, po którje został dodany znak nowej linii. Mimo, że 
+> deklaracji return, po której został dodany znak nowej linii. Mimo że 
 > niekoniecznie jest to błąd automatycznego wstawiania średników, to może to 
 > jednak powodować niechciane efekty uboczne 
 
-Parser drastycznie zmienił działanie powyższego kodu, w niektórych przypadkach 
+Parser drastycznie zmienił działanie powyższego kodu. W niektórych przypadkach 
 **zmienił go źle**.
 
 ### Nawiasy
@@ -99,19 +99,19 @@ W przypadku, gdy w następnej linii znajduje się nawias, parser **nie** wstawi
     log('testing!')
     (options.list || []).forEach(function(i) {})
 
-Ten kod zostanie zmieniony w poniższą jedną linię.
+Kod ten zostanie zmieniony w poniższą linię.
 
     log('testing!')(options.list || []).forEach(function(i) {})
 
-Jest **bardzo** prawdopodobne, że `log` **nie** zwróci fukcji, co za tym idzie 
+Jest **bardzo** prawdopodobne, że `log` **nie** zwróci fukcji. Co za tym idzie 
 powyższy kod wyrzuci błąd `TypeError` oznajmując, że `undefined is not a 
 function` - `undefined` nie jest funkcją.
 
 ### Wnioski
 
-Zaleca się aby **nigdy** nie pomijać średników, pozostawiać nawias otwierający 
+Zaleca się, aby **nigdy** nie pomijać średników, pozostawiać nawias otwierający 
 w tej samej linii co odpowiadająca mu definicja i nigdy nie pozostawiać deklaracji 
-`if` / `else` bez nawiasów nawet jeżeli są jednolinijkowe. Wszystkie te uwagi nie 
-tylko pomagają poprawić spójność kodu, ale również zapobiegają parser JavaScript 
-przed zmianą działania kod.
+`if` / `else` bez nawiasów - nawet, jeżeli są jednolinijkowe. Wszystkie te uwagi nie 
+tylko pomagają poprawić spójność kodu, ale też zapobiegają zmianie działania 
+kodu przez parser JavaScript.
 
diff --git a/doc/pl/core/undefined.md b/doc/pl/core/undefined.md
index b938ead3..6fb9ac95 100644
--- a/doc/pl/core/undefined.md
+++ b/doc/pl/core/undefined.md
@@ -7,45 +7,44 @@ z tych dwóch jest `undefined`.
 
 `undefined` jest typem z dokładnie jedną wartością: `undefined`.
 
-Język również definiuje globalną zmienną, która ma wartość `undefined`, zmienna 
-ta jest nazwana `undefined`. Jednakże jest to zmienna a **nie** stała czy słowo 
-kluczowe w języku. Oznacza to że możliwe jest nadpisanie *wartości* tej zmiennej.
+Język również definiuje globalną zmienną, która ma wartość `undefined` - zmienna 
+ta jest nazwana `undefined`. Jednakże jest to zmienna a **nie** stała, czy słowo 
+kluczowe. Oznacza to, że możliwe jest nadpisanie *wartości* tej zmiennej.
 
 > Uwaga ES55: `undefined` w ECMAScript 5 **nie będzie już** *nadpisywalna* w trybie
-> strict mode, ale jej nazwa może zostać przysłonona przez na przykład funkcję o 
+> strict mode, ale jej nazwa może zostać przesłoniona przez na przykład funkcję o 
 > nazwie `undefined`.
 
 Kilka przykładów kiedy wartość `undefined` jest zwracana:
 
- - Dostęp do (niemodyfikowalnej) zmiennej globalnej `undefined`.
- - Wyjście z funkcji, która nie ma deklaracji `return`.
- - Deklaracja `return`, która nic jawnie nie zwraca.
- - Poszukiwanie nieistniejącej właściwości.
- - Parametr funkcji, który nie został jawnie przekazany podczas wywołania funkcji
- - Wszystko co zostało ustawione na wartość `undefined`
+ - dostęp do (niemodyfikowalnej) zmiennej globalnej `undefined`,
+ - wyjście z funkcji, która nie ma deklaracji `return`,
+ - deklaracja `return`, która nic jawnie nie zwraca,
+ - poszukiwanie nieistniejącej właściwości,
+ - parametr funkcji, który nie został jawnie przekazany podczas wywołania funkcji,
+ - wszystko czemu została przypisana wartość `undefined`.
 
 ### Obsługa przypadku zmiany wartości `undefined`
 
-Ponieważ globalna zmienna `undeined` tylko zawiera kopię prawdziwej *wartości* typu 
+Ponieważ globalna zmienna `undefined` zawiera tylko kopię prawdziwej *wartości* typu 
 `undefined`, przypisanie nowej wartości do tej zmiennej **nie** zmienia wartości 
 *typu* `undefined`.
 
-Jednak, aby porównać coś do wartości `undefined` potrzebne jest odczytanie wartości 
-`undefined`.
+Jednak aby porównać coś z wartością `undefined`, trzeba odczytać wartość `undefined`.
 
-Aby uchronić swój kod przeciwko możliwemu nadpisaniu zmiennej `undefined`, korzysta 
+Aby uchronić swój kod przed możliwym nadpisaniem zmiennej `undefined`, korzysta 
 się z powszechnej techniki dodania dodatkowego parametru do 
 [anonimowego wrappera](#function.scopes), do którego nie zostanie przekazany 
 argument.
 
     var undefined = 123;
     (function(something, foo, undefined) {
-        // undefined lokalnym zasięgu znowu 
+        // undefined o lokalnym zasięgu znowu 
         // odnosi się do poprawnej wartości
 
     })('Hello World', 42);
 
-Kolejnym sposobem aby osiągnąć ten sam efekt jest użycie deklaracji zmiennej 
+Kolejnym sposobem na osiągnięcie tego samego efektu jest użycie deklaracji zmiennej 
 wewnątrz wrappera.
 
     var undefined = 123;
@@ -55,13 +54,13 @@ wewnątrz wrappera.
 
     })('Hello World', 42);
 
-Jedyną różnicą pomięcy tymi sposobami są dodatkowe 4 bajty przeznaczone na słowo 
+Jedyną różnicą pomiędzy tymi sposobami są dodatkowe 4 bajty przeznaczone na słowo 
 kluczowe `var` i spację po nim.
 
 ### Zastosowanie `null`
 
 Podczas gdy `undefined` w kontekście języka jest używany jak *null* w sensie 
-tradycyjnych języków, to `null` w JavaScript (jako literał i jako typ) jest po 
+tradycyjnych języków, `null` w JavaScript (jako literał i jako typ) jest po 
 prostu kolejnym typem danych.
 
 Jest wykorzystywany we wnętrzu JavaScript (np. deklaracji końca łańcucha prototypów 
diff --git a/doc/pl/function/arguments.md b/doc/pl/function/arguments.md
index 9f5d7476..098c2de9 100644
--- a/doc/pl/function/arguments.md
+++ b/doc/pl/function/arguments.md
@@ -1,18 +1,18 @@
 ## Obiekt `arguments`
 
-Każda zasięg funkcyjny w języku JavaScript ma dostęp do specjalnej zmiennej `arguments`. 
+Każdy zasięg funkcyjny w języku JavaScript ma dostęp do specjalnej zmiennej `arguments`. 
 Ta zmienna trzyma listę wszystkich argumentów przekazanych do funkcji.
 
-> **Uwaga:** W przypadku gdy `arguments` zostanie zadeklarowana wewnatrz funkcji
+> **Uwaga:** W przypadku gdy `arguments` zostanie zadeklarowana wewnątrz funkcji
 > poprzez `var` lub jako nazwa jednego z formalnych parametrów, obiekt `arguments` 
 > nie zostanie utworzony.
 
-Obiekt `arguments` **nie** jest typu `Array`. Mimo, że posiada pewne cechy 
-semantyki tablic - właściwość `length` - to nie dziedziczy on z `Array.prototype`,
-ale w rzeczywistości z `Object`.
+Obiekt `arguments` **nie** jest typu `Array`. Mimo że posiada pewne cechy 
+semantyki tablic - właściwość `length` - to w rzeczywistości nie dziedziczy 
+on z `Array.prototype`, tylko z `Object`.
 
-Ze względu na to **nie** można używać standardowych dla tablic metod takich jak
-`push`, `pop` czy `slice` na obiekcie `arguments`. Mimo, że iteracja przy pomocy 
+Ze względu na to, na obiekcie `arguments` **nie** można używać standardowych dla tablic metod, 
+takich jak `push`, `pop` czy `slice`. Mimo że iteracja przy pomocy 
 pętli `for` działa dobrze, to aby skorzystać ze standardowych metod tablicowych 
 należy skonwertować `arguments` do prawdziwego obiekt `Array`.
 
@@ -29,7 +29,7 @@ które mają duży wpływ na wydajność.
 ### Przekazywanie argumentów
 
 Zalecany sposób przekazywania argumentów z jednej funkcji do następnej 
-wyglada następująco.
+wyglada następująco:
 
     function foo() {
         bar.apply(null, arguments);
@@ -58,11 +58,11 @@ szybkich i nieograniczonych wrapperów.
 
 ### Parametry formalne i indeksy argumentów
 
-Obiekt `arguments` tworzy funckje *getter* i *setter* nie tylko dla swoich 
+Obiekt `arguments` tworzy funkcje *getter* i *setter* nie tylko dla swoich 
 właściwości, ale również dla parametrów formalnych funkcji.
 
 W rezultacie zmiana wartości parametru formalnego zmieni również wartość 
-odpowiadającemu mu wpisowi w obiekcie `arguments`, zachodzi to również w drugą stronę.
+odpowiadającemu mu wpisowi w obiekcie `arguments`. Zachodzi to również w drugą stronę.
 
     function foo(a, b, c) {
         arguments[0] = 2;
@@ -79,7 +79,7 @@ odpowiadającemu mu wpisowi w obiekcie `arguments`, zachodzi to również w drug
 
 ### Mity i prawdy o wydajności
 
-Obiekt `arguments` jest zawsze tworzony z wyjątkiem dwóch przypadków, gdy
+Obiekt `arguments` jest tworzony zawsze, z wyjątkiem dwóch przypadków, gdy
 zmienna o takiej nazwie jest zdefiniowana wewnątrz funkcji lub jeden z parametrów 
 formalnych funkcji ma taką nazwę. Nie ma znaczenia czy obiekt `arguments` jest 
 używany czy nie.
@@ -108,9 +108,8 @@ nowoczesnych silnikach JavaScript. Ten przypadek to wykorzystanie
 W powyższym przykładzie `foo` nie może zostać wykorzystana metoda [inline][1] 
 ponieważ potrzebne są nie tylko informacje na własny temat ale również 
 na temat funkcji wywołującej. Takie użycie nie tylko uniemożliwia 
-inlining i korzyści z niej wynikające, ale również stanowi złamanie 
-zasad enkapsulacji ponieważ ta funkcja jest zależna od kontekstu 
-w jakim została wywołana.
+inlining i korzyści z niego wynikające, ale też łamie zasady enkapsulacji, 
+ponieważ ta funkcja jest zależna od kontekstu w jakim została wywołana.
 
 **Mocno zalecane** jest aby **nigdy** nie korzystać z `arguments.callee` 
 i żadnej jej własności.
diff --git a/doc/pl/function/closures.md b/doc/pl/function/closures.md
index c8e45b99..df782104 100644
--- a/doc/pl/function/closures.md
+++ b/doc/pl/function/closures.md
@@ -1,9 +1,9 @@
 ## Domknięcia i referencje
 
-Jedną z najpotężniejszych funkcjonalności języka JavaScript są *domknięcia*, 
-oznacza to że zasięg **zawsze** posiada dostęp do zewnętrznego zasięgu w którym 
+Jedną z najpotężniejszych funkcjonalności języka JavaScript są *domknięcia*. 
+Oznacza to że zasięg **zawsze** posiada dostęp do zewnętrznego zasięgu, w którym 
 został zdefiniowany. Ponieważ zasięg w JavaScript można definiować tylko poprzez 
-[funckję](#function.scopes), wszystkie funkcje domyślnie zachowują się jak domknięcia.
+[funkcję](#function.scopes), wszystkie funkcje domyślnie zachowują się jak domknięcia.
 
 ### Emulowanie prywatnych zmiennych
 
@@ -24,16 +24,16 @@ został zdefiniowany. Ponieważ zasięg w JavaScript można definiować tylko po
     foo.increment();
     foo.get(); // 5
 
-Tutaj `Counter` zwraca **dwa** domknięcia: funkcję `increment` oraz funckję `get`. 
-Obie te funkcję trzymają **referencję** do zasięgu `Counter` a co za tym idzie 
+Tutaj `Counter` zwraca **dwa** domknięcia: funkcję `increment` oraz funkcję `get`. 
+Obie te funkcje trzymają **referencję** do zasięgu `Counter`, a co za tym idzie 
 zawsze posiadają dostęp do zmiennej `count` tak, jakby ta zmienna była zdefiniowana 
 w zasięgu tych funkcji.
 
-### Dlaczego zmienne przywatne działają
+### Dlaczego zmienne prywatne działają?
 
-Ponieważ nie ma możliwości wskazania lub przypisania zasięgu w JavaScript, to 
-**nie** istnieje sposób aby uzyskać dostęp do zmiennej `count` z zewnątrz. 
-Wykorzystanie tych dwóch domkinęć jest jedynym sposobem na interakcję z tą zmienną.
+Ponieważ nie ma możliwości wskazania lub przypisania zasięgu w JavaScript, 
+**nie** istnieje sposób, aby uzyskać dostęp do zmiennej `count` z zewnątrz. 
+Wykorzystanie tych dwóch domknięć jest jedynym sposobem na interakcję z tą zmienną.
 
     var foo = new Counter(4);
     foo.hack = function() {
@@ -47,8 +47,8 @@ Zamiast tego funkcja utworzy lub nadpisze *globalną* zmienną `count`.
 
 ### Domknięcia wewnątrz pętli
 
-Jednym z częstrzych błędów jest wykorzystywanie domknięć wewnątrz pętli, 
-aby wartość zmiennej po której odbywa się iteracja był kopiowana do 
+Jednym z częstszych błędów jest wykorzystywanie domknięć wewnątrz pętli, 
+aby wartość zmiennej po której odbywa się iteracja była kopiowana do 
 wewnętrznej funkcji.
 
     for(var i = 0; i < 10; i++) {
@@ -80,8 +80,8 @@ z [anonimowego wrappera](#function.scopes).
         })(i);
     }
 
-Zewnętrzna anonimowa funkcja zostaje wywołana od razu z parametrem `i` 
-jako pierwszym argumentem i otrzyma kopię **wartości** zmiennej `i` jako 
+Zewnętrzna anonimowa funkcja zostanie wywołana od razu z parametrem `i` 
+jako pierwszym argumentem oraz otrzyma kopię **wartości** zmiennej `i` jako 
 zmienną `e`.
 
 Anonimowa funkcja która zostaje przekazana do `setTimeout` teraz posiada 
diff --git a/doc/pl/function/constructors.md b/doc/pl/function/constructors.md
index 4cb7bd12..d9be52a0 100644
--- a/doc/pl/function/constructors.md
+++ b/doc/pl/function/constructors.md
@@ -1,7 +1,7 @@
 ## Konstruktory 
 
-Konstruktory w JavaScript również wyglądają inaczej niż innych języka. Każde 
-wywołanie funkcji, które jest poprzedone słowem kluczowym `new` zachowuje się 
+Konstruktory w JavaScript również wyglądają inaczej niż innych językach. Każde 
+wywołanie funkcji, które jest poprzedone słowem kluczowym `new`, zachowuje się 
 jak konstruktor. 
 
 Wewnątrz konstruktora - wywoływanej fukcji - wartość `this` wskazuje na 
@@ -22,7 +22,7 @@ fukcja domyślnie zwraca wartość `this` - nowy obiekt.
 
     var test = new Foo();
 
-Powyżej wywołanya została funkcja `Foo` jako konstruktor oraz ustawia 
+Powyżej wywołana została funkcja `Foo` jako konstruktor oraz ustawia 
 nowo utworzonemu obiektowi właściwość `prototype` na `Foo.prototype`.
 
 W tym przypadku jawna deklaracja `return` w funkcji zwraca wartość 
@@ -43,7 +43,7 @@ obiekt `Object`.
     }
     new Test(); // zwrócony obiekt
 
-Jeżeli słowo kluczowe `new` zostanie pominięte funkcja **nie** zwróci nowego 
+Jeżeli słowo kluczowe `new` zostanie pominięte, funkcja **nie** zwróci nowego 
 obiektu.
 
     function Foo() {
@@ -51,13 +51,13 @@ obiektu.
     }
     Foo(); // undefined
 
-Mimo, że powyższy kod może zadziałać w pewnych przypadkach, w związku 
-z działaniem [`this`](#function.this) w języku JavaScript to jako 
-wartość `this`zostanie wykorzystany **obiekt global**.
+Mimo że powyższy kod może zadziałać w pewnych przypadkach, w związku 
+z działaniem [`this`](#function.this) w języku JavaScript, to jako 
+wartość `this` zostanie wykorzystany **obiekt global**.
 
 ### Fabryki
 
-Aby móc ominąć słowo kluczowe `new` konstruktor musi jawnie zwracać wartość.
+Aby móc ominąć słowo kluczowe `new`, konstruktor musi jawnie zwracać wartość.
 
     function Bar() {
         var value = 1;
@@ -74,13 +74,13 @@ Aby móc ominąć słowo kluczowe `new` konstruktor musi jawnie zwracać wartoś
     new Bar();
     Bar();
 
-Oba wywołania `Bar` zwrócą tą samą rzecz, nowo utworzony obiekt, który posiada 
-właściwość nazwaną `method` w sobie, dla którego `Bar` jest [Domknięciem](#function.closures).
+Oba wywołania `Bar` zwrócą tę samą rzecz, nowo utworzony obiekt, który posiada 
+właściwość nazwaną `method` i dla którego `Bar` jest [Domknięciem](#function.closures).
 
 Należy również pamiętać, że wywołanie `new Bar()` **nie** ma wpływu na 
 prototyp zwróconego obiektu (prototypem będzie `object.prototype` a nie `Bar.prototype`). 
-Podczas gdy prototyp zostanie przypisany do nowo utworzonego obiektu, to jednak `Bar` 
-nidgy nie zwróci tego nowego obiektu `Bar`, ale literał obiektu, który jest po 
+Kiedy prototyp zostanie przypisany do nowo utworzonego obiektu, `Bar` nidgy 
+nie zwróci tego nowego obiektu `Bar`, tylko literał obiektu, który jest po 
 słowie kluczowym `return`.
 
 W powyższym przykładzie nie ma żadnej różnicy w działaniu pomiędzy użyciem 
@@ -88,8 +88,8 @@ i nieużyciem słowa kluczowego `new`.
 
 ### Tworzenie nowych obiektów korzystając z fabryk
 
-Często zaleca się **nie** korzystać z operatora `new` ponieważ zapominając 
-go zastosować może prowadzić do błędów.
+Często zaleca się **nie** korzystać z operatora `new`, ponieważ zapominanie
+o jego stosowaniu może prowadzić do błędów.
 
 W celu stworzenia nowego obiektu, powinno się używać fabryki i konstruować 
 nowy obiekt wewnątrz tej fabryki.
@@ -110,14 +110,12 @@ nowy obiekt wewnątrz tej fabryki.
     }
 
 
-Mimo, że powyższy kod jest odporny na brak słowa kluczowego `new` i ułatwia 
+Mimo że powyższy kod jest odporny na brak słowa kluczowego `new` i ułatwia 
 korzystanie ze [zmiennych prywatnych](#function.closures), to posiada 
 pewne wady.
-While the above is robust against a missing `new` keyword and certainly makes 
-the use of [private variables](#function.closures) easier, it comes with some 
-downsides.
+
  1. Zużywa więcej pamięci, ponieważ tworzony obiekt **nie** współdzieli metod 
-    poprzez prototyp
+    poprzez prototyp.
  2. Aby móc dziedziczyć fabryka musi skopiować wszystkie metody z dziedziczonego 
     obiektu lub przypisać ten obiekt, z którego się dziedziczy, jako prototyp 
     do nowo utworzonego obiektu.
@@ -129,5 +127,5 @@ downsides.
 Pominięcie słowa kluczowego `new` może prowadzić do błędów, ale na pewno nie 
 powinno to być powodem odrzucenia używania prototypów w ogóle. Sprowadza się to 
 do wyboru rozwiązania, które bardziej pasuje do potrzeb aplikacji. Szczególnie 
-ważne jest aby wybrać określony styl tworzenia obiektów i się go **trzymać**.
+ważne jest, aby wybrać określony styl tworzenia obiektów i **trzymać** się go.
 
diff --git a/doc/pl/function/general.md b/doc/pl/function/general.md
index d55153c3..f9c3247c 100644
--- a/doc/pl/function/general.md
+++ b/doc/pl/function/general.md
@@ -1,17 +1,17 @@
 ## Deklaracje funkcji i wyrażenia funkcyjne
 
-Funcje w języku JavaScript są [typami pierwszoklasowymi][1]. Co oznacza, że mogą 
+Funkcje w języku JavaScript są [typami pierwszoklasowymi][1], co oznacza, że mogą 
 być przekazywane jak każda inna wartość. Jednym z typowych zastosowań tej cechy 
 jest przekazywanie *anonimowej funkcji* jako callback do innej, prawdopodobnie 
 asynchronicznej funkcji.
 
-### Deklaracja funckcji
+### Deklaracja funkcji
 
     function foo() {}
 
-Powyższa funkcja zostaje [wyniesiona](#function.scopes) zanim program wystartuje, dzięki temu 
+Powyższa funkcja zostaje [wyniesiona](#function.scopes) zanim program wystartuje. Dzięki temu 
 jest dostępna *wszędzie* w ramach zasięgu, w którym została *zadeklarowana*,
-nawet jeżeli ta funkcja została wywołana przed faktyczną definicją w kodzie źródłowym.
+nawet, jeżeli ta funkcja została wywołana przed faktyczną definicją w kodzie źródłowym.
 
     foo(); // Działa ponieważ definicja funkcji została wyniesiona 
            // na początek zasięgu przed uruchomieniem kodu
@@ -27,7 +27,7 @@ Ten przykład przypisuje nienazwaną i *anonimową* funkcję do zmiennej `foo`.
     foo(); // wyrzuca błąd TypeError
     var foo = function() {};
 
-Ze względu na fakt, że deklaracja `var` wynosi zmienną `foo` na początek zasięgu, 
+Ze względu na fakt, że deklaracja `var` wynosi zmienną `foo` na początek zasięgu 
 zanim kod faktycznie zostanie uruchomiony, `foo` będzie zdefiniowane kiedy skrypt 
 będzie wykonywany.
 
@@ -35,7 +35,7 @@ Ale ponieważ przypisania robione są dopiero podczas wykonania, wartość `foo`
 ustawiona na domyślną wartość [undefined](#core.undefined) zanim powyższy kod 
 zostanie uruchomiony.
 
-### Nazwane wyrażenia funkdyjne
+### Nazwane wyrażenia funkcyjne
 
 Kolejnym specjalnym przypadkiem jest przypisanie nazwanej funkcji. 
 
@@ -44,10 +44,10 @@ Kolejnym specjalnym przypadkiem jest przypisanie nazwanej funkcji.
     }
     bar(); // wyrzuca ReferenceError
 
-W zewnętrznym zakresie `bar` nie będzie dostępne, ponieważ funkcja zostaje 
+W zewnętrznym zakresie `bar` nie będzie dostępna, ponieważ funkcja zostaje 
 przypisana do `foo`, jednakże w wewnętrznym zakresie `bar` będzie dostępna.
 Jest to spowodowane tym, jak działa [rozwiązywanie nazw](#function.scopes) 
 w języku JavaScript. Nazwa funkcji jest *zawsze* dostępna w lokalnym 
 zakresie tej funkcji.
 
-[1]: http://pl.wikipedia.org/wiki/Typ_pierwszoklasowy
\ No newline at end of file
+[1]: http://pl.wikipedia.org/wiki/Typ_pierwszoklasowy
diff --git a/doc/pl/function/scopes.md b/doc/pl/function/scopes.md
index a06eba05..bb43387b 100644
--- a/doc/pl/function/scopes.md
+++ b/doc/pl/function/scopes.md
@@ -1,6 +1,6 @@
 ## Zasięg zmiennych i przestrzenie nazw
 
-Mimo, że JavaScript radzi sobie dobrze ze składnią, opisującą dwa pasujące 
+Mimo że JavaScript radzi sobie dobrze ze składnią opisującą dwa pasujące 
 nawiasy klamrowe jako blok, to jednak **nie** wspiera zasięgu blokowego. 
 Jedynym zasięgiem jaki istnieje w JavaScript jest *zasięg funkcyjny*.
 
@@ -12,17 +12,16 @@ Jedynym zasięgiem jaki istnieje w JavaScript jest *zasięg funkcyjny*.
     }
 
 > **Uwaga:** Jeżeli notacja `{...}` nie jest użyta w przypisaniu, deklaracji return
-> lub jako argument funkcji to zostanie zinterpretowana jako deklaracja bloku, a 
-> **nie** jako literał obiektu. W połączeniu z [automatycznym wstawianiem średnika](#core.semicolon), 
+> lub jako argument funkcji, to zostanie zinterpretowana jako deklaracja bloku, 
+> a **nie** jako literał obiektu. W połączeniu z [automatycznym wstawianiem średnika](#core.semicolon), 
 > może prowadzić do subtelnych błędów.
 
 W JavaScripcie nie ma również przestrzeni nazw, co oznacza, że wszystko jest 
 definiowane w jednej *globalnie współdzielonej* przestrzeni nazw. 
 
-Za każdym razem gdy zmienna jest 
-Z każdym odwołaniem do zmiennej JavaScript przeszukuje w górę wszystkie zasięgi 
-dopóki nie znajdzie tej zmiennej. W przypadku gdy przeszukiwanie dotrze do globalnego 
-zasięgu i nadal nie znajdzie żądanej nazwy to wyrzuca błąd `ReferenceError`.
+Z każdym odwołaniem do zmiennej, JavaScript przeszukuje w górę wszystkie zasięgi 
+dopóki nie znajdzie tej zmiennej. W przypadku, gdy przeszukiwanie dotrze do globalnego 
+zasięgu i nadal nie znajdzie żądanej nazwy, wyrzuca błąd `ReferenceError`.
 
 ### Zmora globalnych zmiennych
 
@@ -32,11 +31,11 @@ zasięgu i nadal nie znajdzie żądanej nazwy to wyrzuca błąd `ReferenceError`
     // script B
     var foo = '42'
 
-Powyższe dwa skrypty **nie** dają tego samego efektu. Skrypt A definiuje zmienna 
-nazwaną `foo` w *globalnym* zasięgu natomiast skrypt B definiuje `foo` 
+Powyższe dwa skrypty **nie** dają tego samego efektu. Skrypt A definiuje zmienną 
+nazwaną `foo` w *globalnym* zasięgu, natomiast skrypt B definiuje `foo` 
 w *aktualnym* zasięgu.
 
-Jeszcze raz, to wcale nie daje *tego samego efektu*, nie użycie `var` może mieć 
+Jeszcze raz, to wcale nie daje *tego samego efektu*. Brak użycia `var` może mieć 
 poważne konsekwencje.
 
     // globalny zasięg
@@ -49,8 +48,8 @@ poważne konsekwencje.
     foo; // 21
 
 Pominięcie słowa `var` w deklaracji wewnątrz funkcji `test` nadpisze wartość 
-zmiennej globalnej `foo`. Mimo, że nie wygląda to na początku jak duży problem, 
-to posiadając wiele tysięcy linii kodu w JavaScript i nie korzystanie z `var` 
+zmiennej globalnej `foo`. Mimo, że nie wygląda to na początku na duży problem, 
+w przypadku kodu, który posiada wielu tysięcy linii, brak `var` 
 wprowadzi straszne i trudne do wyśledzenia błędy.
     
     // globalny zasięg 
@@ -68,9 +67,9 @@ wprowadzi straszne i trudne do wyśledzenia błędy.
 
 Zewnętrzna pętla zakończy działanie po pierwszym wywołaniu `subLoop`, ponieważ 
 `subLoop` nadpisuje wartość globalnej zmiennej `i`. Użycie `var` w drugiej pętli 
-`for` pozwoliło by łatwo uniknąć problemu. Słowo kluczowe `var` nie powinno być 
-**nigdy** pominięte w deklaracji, chyba że *pożądanym skutkiem* jest wpłynięcie na 
-zewnętrzny zasięg.
+`for` pozwoliłoby łatwo uniknąć problemu. Słowo kluczowe `var` nie powinno być 
+**nigdy** pominięte w deklaracji, chyba że *pożądanym skutkiem* jest modyfikacja  
+zewnętrznego zasięgu.
 
 ### Lokalne zmienne
 
@@ -91,7 +90,7 @@ oraz zmienne zadeklarowane poprzez deklaracje `var` wewnątrz funkcji.
     }
     test(10);
 
-Zmienne `foo` oraz `i` są lokalnymi zmiennymi wewnątrz zasiegu funkcji `test`, 
+Zmienne `foo` oraz `i` są lokalnymi zmiennymi wewnątrz zasięgu funkcji `test`, 
 natomiast przypisanie wartości do `bar` nadpisze zmienną globalną o tej samej nazwie.
  
 ### "Hoisting" - wywindowanie, podnoszenie 
@@ -144,17 +143,17 @@ najbliższego zasięgu.
 
     test();
 
-Brak blokowego zasięgu nie tylko przeniesie deklaracje `var` poza ciało pętle,
+Brak blokowego zasięgu nie tylko przeniesie deklaracje `var` poza ciało pętli,
 ale również spowoduje, że niektóre porównania `if` staną się nieintuicyjne.
 
-W oryginalnym kodzie wewnątrz deklaracja `if` zdaje się modyfikować *zmienną 
+W oryginalnym kodzie instrukcja warunkowa `if` zdaje się modyfikować *zmienną 
 globalną* `goo`, podczas gdy faktycznie modyfikuje ona *zmienną lokalną* - po tym 
 jak zostało zastosowane windowanie (hoisting).
 
-Bez wiedzy na temat podnoszenia (hoistingu), poniższy kod może wydawać się 
-wyrzucać błąd `ReferenceError`.
+Analizując poniższy kod bez wiedzy na temat hoistingu możemy odnieść wrażenie,
+że zobaczymy błąd `ReferenceError`.
 
-    // sprawdz czy SomeImportantThing zostało zainicjalizowane
+    // sprawdź, czy SomeImportantThing zostało zainicjalizowane
     if (!SomeImportantThing) {
         var SomeImportantThing = {};
     }
@@ -164,9 +163,9 @@ przeniesiona na początek *globalnego zasięgu*.
 
     var SomeImportantThing;
 
-    // inny kod który może ale nie musi zainicjalizować SomeImportantThing
+    // inny kod, który może, ale nie musi zainicjalizować SomeImportantThing
 
-    // upewnienie sie że SomeImportantThing zostało zainicjalizowane
+    // upewnij się, że SomeImportantThing zostało zainicjalizowane
     if (!SomeImportantThing) {
         SomeImportantThing = {};
     }
@@ -174,7 +173,7 @@ przeniesiona na początek *globalnego zasięgu*.
 ### Kolejność rozwiązywania nazw
 
 Wszystkie zasięgi w JavaScripcie, włączając *globalny zasięg*, posiadają 
-zdefiniowana wewnątrz specjalną nazwę [`this`](#function.this), która wskazuje 
+zdefiniowaną wewnątrz specjalną nazwę [`this`](#function.this), która wskazuje 
 na *aktualny obiekt*. 
 
 Zasięg funkcyjny posiada również zdefiniowaną wewnętrznie nazwę 
@@ -183,19 +182,21 @@ funkcji.
 
 Na przykład, kiedy próbujemy odczytać zmienną `foo` wewnątrz zasięgu funkcji, 
 JavaScript będzie szukać nazwy w określonej kolejności:
- 1. Jeżeli wewnątrz aktualnego zasięgu znajduje się deklaracja `var foo` skorzystaj z niej.
- 2. Jeżeli jeden z parametrów fukcji został nazwany `foo` użyj go.
- 3. Jeżeli fukcja została nazwana `foo` skorzystaj z tego.
- 4. Przejdz do zewnętrznego zasięgu i przejdz do kroku **#1**.
 
-> **Uwaga:** Jeżeli jeden z parametrów fukcji został nazwany `arguments` zapobiegnie 
-> to utworzenia domyślnego obiektu `arguments`.
+ 1. Jeżeli wewnątrz aktualnego zasięgu znajduje się deklaracja `var foo`, skorzystaj z niej.
+ 2. Jeżeli jeden z parametrów fukcji został nazwany `foo`, użyj go.
+ 3. Jeżeli funkcja została nazwana `foo`, skorzystaj z tego.
+ 4. Przejdź do zewnętrznego zasięgu i przejdź do kroku **#1**.
+
+> **Uwaga:** Jeżeli jeden z parametrów fukcji został nazwany `arguments`, 
+> nie zostanie utworzony domyślny obiekt `arguments`.
 
 ### Przestrzenie nazw
 
 Powszechnym problemem posiadania tylko jednej globalnej przestrzeni nazw jest 
 prawdopodobieństwo wystąpienia kolizji nazw. W JavaScripcie, można łatwo uniknąć 
-tego problemu korzystając z *anonimowych wrapperów*.
+tego problemu korzystając z *anonimowych wrapperów* (inaczej: Immediately-Invoked 
+Function Expression - IIFE).
 
     (function() {
         // autonomiczna "przestrzeń nazw"
@@ -206,16 +207,16 @@ tego problemu korzystając z *anonimowych wrapperów*.
 
     })(); // natychmiastowe wykonanie funkcji
 
-Nienazwane funkcje są rozpoznane jako [wyrażenia](#function.general), więc 
+Anonimowe funkcje są rozpoznane jako [wyrażenia](#function.general), więc 
 aby mogły zostać wywołane muszą zostać zewaluowane.
 
-    ( // zewaluowanie fukcji znajdującej się wewnątrz nawiasów
+    ( // zewaluowanie funkcji znajdującej się wewnątrz nawiasów
     function() {}
     ) // zwrócenie obiektu funkcji
     () // wywołanie rezultatu ewaluacji
 
-Istnieją inne sposoby aby zewaluować i wykonać wyrażenie funkcyjne. Mimo, że 
-mają inną składnie, zachowują się dokładnie tak samo.
+Istnieją inne sposoby aby zewaluować i wykonać wyrażenie funkcyjne. Mimo że 
+mają inną składnię, zachowują się dokładnie tak samo.
 
     // Trzy inne sposoby
     !function(){}();
@@ -224,11 +225,11 @@ mają inną składnie, zachowują się dokładnie tak samo.
 
 ### Wnioski
 
-Zaleca się aby zawsze używać *anonimowych wrapperów* do hermetyzacji kodu wewnątrz 
+Zaleca się, aby zawsze używać *anonimowych wrapperów* do hermetyzacji kodu wewnątrz 
 jego własnej przestrzeni nazw. To nie tylko chroni kod przed kolizją nazw, ale 
 również wprowadza lepszą modularyzację programów.
 
 Ponadto, stosowanie zmiennych globalnych jest uznawane za złą praktykę. 
-Jakiekolwiek wykorzystanie zmiennych globalnych wskazuje na źle napisany kod, 
-który jest podatny na błędy i trudny do utrzymania.
+Wykorzystanie zmiennych globalnych wskazuje na źle napisany kod, który 
+jest podatny na błędy i trudny do utrzymania.
 
diff --git a/doc/pl/function/this.md b/doc/pl/function/this.md
index 8fc8564d..adf7e1d0 100644
--- a/doc/pl/function/this.md
+++ b/doc/pl/function/this.md
@@ -1,25 +1,20 @@
 ## Jak działa `this`
 
-JavaScript posiada inną koncepcję odnośnie tego na co wskazuje specjalna 
-nazwa `this`, niż większość innych języków programowania. Istnieją dokładnie 
-**pięć** różnych sytuacji w których wartość `this` zostaje przypisana w języku JavaScript.
-
-JavaScript has a different concept of what the special name `this` refers to 
-than most other programming languages do. There are exactly **five** different 
-ways in which the value of `this` can be bound in the language.
+JavaScript posiada inną koncepcję odnośnie tego na co wskazuje słowo kluczowe 
+`this`, niż większość innych języków programowania. Istnieje dokładnie 
+**pięć** różnych sytuacji, w których wartość `this` jest przypisana w języku JavaScript.
 
 ### Zasięg globalny
 
     this;
 
-Używanie `this` w globalnym zasięgu, zwróci po prostu referencje do obiektu *global*.
-
+Używanie `this` w globalnym zasięgu, zwróci po prostu referencję do obiektu *global*.
 
 ### Wywołanie funkcji
 
     foo();
 
-Tutaj `this` również będzie wkazywało na obiekt *global*
+Tutaj `this` również będzie wskazywało na obiekt *global*
 
 > **Uwaga ES5:** W trybie strict mode, przypadki z globalnym zasięgiem nie mają miejsca.
 > W tym przypadku `this` zwróci `undefined` zamiast wartości.
@@ -34,7 +29,7 @@ W tym przypadku `this` będzie wskazywało na `test`.
 
     new foo(); 
 
-Wywołanie funkcji, które jest poprzedzone słowem kluczowym `new` zachowuje się 
+Wywołanie funkcji, które jest poprzedzone słowem kluczowym `new`, zachowuje się 
 jak [konstruktor](#function.constructors). Wewnątrz funkcji `this` będzie 
 wskazywało na *nowo utworzony* obiekt.
 
@@ -60,7 +55,7 @@ miejsca i `this` wewnątrz `foo` będzie wskazywać na `bar`.
 ### Częste pułapki
 
 Mimo iż Większość z tych przypadków ma sens, to pierwszy przypadek powinien być 
-traktorany jako błąd podczas projektowania języka i **nigdy** nie wykorzystywany 
+traktowany jako błąd podczas projektowania języka i **nigdy** nie wykorzystywany 
 w praktyce.
 
     Foo.method = function() {
@@ -68,12 +63,12 @@ w praktyce.
             // wewnątrz tej funkcji this wskazuje na obiekt global
         }
         test();
-    }
+    };
 
-Powszechnym nieporozumieniem jest, że `this` wewnątrz `test` wskazuje na `Foo`, 
+Powszechnym błędem jest myślenie, że `this` wewnątrz `test` wskazuje na `Foo`, 
 podczas gdy w rzeczywistości tak **nie jest**.
 
-Aby uzyskać dostęp do `Foo` wewnątrz `test` niezbędne jest stworzenie wewnątrz 
+Aby uzyskać dostęp do `Foo` wewnątrz `test`, niezbędne jest stworzenie wewnątrz 
 metody lokalnej zmiennej, która będzie wskazywała na `Foo`.
 
     Foo.method = function() {
@@ -82,15 +77,15 @@ metody lokalnej zmiennej, która będzie wskazywała na `Foo`.
             // Należy używać that zamiast this wewnątrz tej funkcji
         }
         test();
-    }
+    };
 
-`that` jest zwykłą zmienną, ale jest to powszechnie stosowana konwencja, aby otrzymać 
-wartość zewnętrznego `this`. W połączeniu z [domknięciami(closures)](#function.closures) 
-jest to sposób na przekazywanie wartości `this` wokoło.
+`that` jest zwykłą zmienną, ale jest to powszechnie stosowana konwencja otrzymywania  
+wartości zewnętrznego `this`. W połączeniu z [domknięciami(closures)](#function.closures), 
+jest to sposób na przekazywanie wartości `this` wokół.
 
 ### Metody przypisywania
 
-Kolejną rzeczą, która **nie** działa w języku JavaScript jest nadawanie aliasów 
+Kolejną rzeczą, która **nie** działa w języku JavaScript, jest nadawanie aliasów 
 funkcjom, co oznacza **przypisanie** metody do zmiennej.
 
     var test = someObject.methodTest;
@@ -100,7 +95,7 @@ Podobnie jak w pierwszym przypadku `test` zachowuje się jak wywołanie zwykłej
 funkcji, a zatem wewnątrz funkcji `this` już nie będzie wskazywało `someObject`.
 
 Podczas gdy późne wiązanie `this` może się na początku wydawać złym pomysłem, 
-to w rzeczywistości jest to rzecz, która powoduje że 
+to w rzeczywistości jest to rzecz, która sprawia, że 
 [dziedziczenie prototypowe](#object.prototype) działa.
 
     function Foo() {}
@@ -112,5 +107,5 @@ to w rzeczywistości jest to rzecz, która powoduje że
     new Bar().method();
 
 Kiedy metoda `method` zostanie wywołana na instancji `Bar`, `this` będzie 
-wskazywało właśnie tą instancję.
+wskazywało właśnie tę instancję.
 
diff --git a/doc/pl/intro/contributors.md b/doc/pl/intro/contributors.md
index a71575a1..64ae249c 100644
--- a/doc/pl/intro/contributors.md
+++ b/doc/pl/intro/contributors.md
@@ -1,7 +1,4 @@
-## Kontrybutorzy
+## Współtwórcy
 
- - [Caio Romão][1] (Poprawki pisowni)
- - [Andreas Blixt][2] (Poprawki językowe)
+- [Współtwórcy](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
 
-[1]: https://github.com/caio
-[2]: https://github.com/blixt
diff --git a/doc/pl/intro/hosting.md b/doc/pl/intro/hosting.md
index 96bc2a1d..19ac9028 100644
--- a/doc/pl/intro/hosting.md
+++ b/doc/pl/intro/hosting.md
@@ -1,6 +1,6 @@
 ## Hosting
 JavaScript Garden znajduje się na serwerach GitHub, ale dzięki wsparciu 
-[Cramer Rozwoju] [1] posiadamy mirror na serwerze [JavaScriptGarden.info] [2].
+[Cramer Development] [1] posiadamy również mirror na serwerze [JavaScriptGarden.info] [2].
 
 [1]: http://cramerdev.com/
 [2]: http://javascriptgarden.info/
diff --git a/doc/pl/intro/license.md b/doc/pl/intro/license.md
index 7e2c77d0..5b0e855d 100644
--- a/doc/pl/intro/license.md
+++ b/doc/pl/intro/license.md
@@ -1,8 +1,8 @@
 ## Licencja
 
 JavaScript Garden jest publikowany w ramach [licencji MIT] [1] i kod źródłowy znajduje 
-się na serwerze [GitHub] [2]. Jeśli znajdziesz jakieś błędy lub literówek zgłoś proszę 
-[problem] [3] lub rozwiązag go i zglosić pull request ze swojego repozytorium. 
+się na serwerze [GitHub] [2]. Jeśli znajdziesz jakieś błędy lub literówki, zgłoś proszę 
+[problem] [3] lub rozwiąż go i zgloś pull request ze swojego repozytorium. 
 Możesz nas także znaleźć w pokoju [JavaScript] [4] na chacie Stack Overflow. 
 
 [1]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
diff --git a/doc/pl/intro/translators.md b/doc/pl/intro/translators.md
index 60b3626e..5197a9fd 100644
--- a/doc/pl/intro/translators.md
+++ b/doc/pl/intro/translators.md
@@ -1,5 +1,7 @@
 ## Tłumaczenie
 
  - [Łukasz Kufel][1]
+ - [Maciej Ciemborowicz][2]
  
-[1]: http://qfel13.pl
\ No newline at end of file
+[1]: http://qfel13.pl
+[2]: http://blog.ciemborowicz.pl
diff --git a/doc/pl/object/forinloop.md b/doc/pl/object/forinloop.md
index a2e2b5fe..9a6654a6 100644
--- a/doc/pl/object/forinloop.md
+++ b/doc/pl/object/forinloop.md
@@ -1,11 +1,11 @@
-## The `for in` Loop
+## Pętla `for in`
 
 Podobnie jak operator `in`, pętla `for in` przeszukuje łańcuch prototypów 
 podczas iteracji po właściwościach obiektu.
 
 > **Uwaga:** pętla `for in` **nie** będzie iterować po właściwościach, które
-> mają ustawiony atrybut `enumerable` na `false` na przykład właściwość 
-> `length` tablicy.
+> mają ustawiony atrybut `enumerable` na `false` (na przykład właściwość 
+> `length` tablicy).
     
     // Zatrucie Object.prototype
     Object.prototype.bar = 1;
@@ -15,15 +15,15 @@ podczas iteracji po właściwościach obiektu.
         console.log(i); // wyświetla obie właściwości: bar i moo
     }
 
-Ponieważ nie jest możliwe, aby zmienić zachowanie pętli `for in` to niezbędne 
+Ponieważ zmiana zachowania pętli `for in` nie jest możliwa, niezbędne 
 jest odfiltrowanie niechcianych właściwości wewnątrz ciała pętli, korzystając 
 z metody [`hasOwnProperty`](#object.hasownproperty) z `Object.prototype`.
 
-> **Uwaga:** Ponieważ pętla `for in` zawsze przeszukuje cały łańcuch prototypów 
+> **Uwaga:** Ponieważ pętla `for in` zawsze przeszukuje cały łańcuch prototypów, 
 > będzie się ona stawała coraz wolniejsza przy dodaniu każdej kolejnej warstwy 
 > dziedziczenia do obiektu. 
 
-### Korzystanie z `hasOwnProperty` do odfiltrowania
+### Filtrowania przy użyciu `hasOwnProperty`
 
     // foo z przykładu powyżej
     for(var i in foo) {
@@ -32,19 +32,19 @@ z metody [`hasOwnProperty`](#object.hasownproperty) z `Object.prototype`.
         }
     }
 
-To jest jedyna poprawna wersja, którą należy używać. Ze względu na użycie 
-`hasOwnProperty` zostanie wypisane **jedynie** `moo`. Gdy opuścimy `hasOwnProperty` 
-kod będzie podatny na błędy, gdy natywne prototypy np. `Object.prototype` 
-zostanie rozszerzony.
+To jest jedyna poprawna wersja, której należy używać. Ze względu na użycie 
+`hasOwnProperty` zostanie wypisane **jedynie** `moo`. Gdy opuścimy `hasOwnProperty`, 
+kod będzie podatny na błędy, gdy natywne prototypy (np. `Object.prototype`) 
+zostaną rozszerzone.
 
-[Prototype][1] jest jednym z szeroko rozpowszechniony frameworków, który dokonuje 
-takiego rozszerzenia. Używanie tego frameworku oraz nie używanie w pętle `for in` 
+[Prototype][1] jest jednym z popularniejszych frameworków, które dokonują 
+takiego rozszerzenia. Używanie tego frameworku oraz nie stosowanie w pętli `for in` 
 metody `hasOwnProperty` gwarantuje błędy w wykonaniu.
 
 ### Wnioski
 
-Zaleca się aby zawsze używać metody `hasOwnProperty`. Nigdy nie powinno się dokonywać
-żadnych założeń na temat środowiska, w którym kod będzie wykonywany i czy natywne 
-prototypy zostały rozszerzone czy nie.
+Zaleca się, aby zawsze używać metody `hasOwnProperty`. Nigdy nie powinno się dokonywać
+żadnych założeń na temat środowiska, w którym kod będzie wykonywany ani tego, czy 
+natywne prototypy zostały rozszerzone, czy nie.
 
 [1]: http://www.prototypejs.org/
diff --git a/doc/pl/object/general.md b/doc/pl/object/general.md
index 24a074e3..b3b05e5c 100644
--- a/doc/pl/object/general.md
+++ b/doc/pl/object/general.md
@@ -1,50 +1,50 @@
 ## Wykorzystanie obiektów i ich właściwości
 
-Wszystko w JavaScripcie zachowuje sie jak obiekt, z dwoma wyjątkami
+Wszystko w JavaScripcie zachowuje się jak obiekt, z dwoma wyjątkami
 [`null`](#core.undefined) oraz [`undefined`](#core.undefined). 
 
-    false.toString() // 'false'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
     
     function Foo(){}
     Foo.bar = 1;
     Foo.bar; // 1
 
-Popularnym błędem jest wykorzystanie literałów liczbowych jako obiektu.
-Spowodowanie jest to usterką w parserze JavaScript, który interpretuje kropkę
-po literale liczbowym jako rozdzielenie części całkowitej od części po przecinku 
+Popularnym błędem jest traktowanie literałów liczbowych jak obiektu.
+Spowodowane jest to specyfiką parsera JavaScript, który interpretuje kropkę
+po literale liczbowym jako rozdzielenie części całkowitej od części ułamkowej 
 liczby.
 
     2.toString(); // wyrzuca błąd SyntaxError
 
-Istnieje kilka rozwiązań, dzieki którym literał liczbowy będzie zachowywał się 
+Istnieje kilka rozwiązań, dzięki którym literał liczbowy będzie zachowywał się 
 jak obiekt.
 
     2..toString(); // druga kropka jest poprawnie rozpoznana
     2 .toString(); // zauważ, że pozostawiona jest spacja przed kropką
-    (2).toString(); // 2 zostanie zewaluowane najpiewr
+    (2).toString(); // 2 zostanie najpierw zewaluowane
 
 ### Obiekty jako typy danych
 
-Obiekty w języku JavaScript mogą być używana jako [*tablice asocjacyjne*][1]. 
-Ponieważ obiekty głównie składają się z mapowań pomiędzy nazwanymi właściwościami (kluczami)
+Obiekty w języku JavaScript mogą być używana jako [*tablice asocjacyjne*][1], 
+ponieważ obiekty składają się głównie z mapowań pomiędzy nazwanymi właściwościami (kluczami)
 a wartościami dla tych atrybutów.
 
-Używając literału obiektu - notacji `{}` - istnieje możliwość stworzenie obiektu prostego.
-Ten nowy obiekt bedzie [dziedziczył](#object.prototype) z `Object.prototype` oraz 
-nie bedzie posiadał żadnych [własnych właściwości](#object.hasownproperty) zdefiniowanych w sobie.
+Używając literału obiektu - notacji `{}` - istnieje możliwość stworzenia obiektu prostego.
+Ten nowy obiekt będzie [dziedziczył](#object.prototype) z `Object.prototype` oraz 
+nie będzie posiadał żadnych [własnych właściwości](#object.hasownproperty).
 
-    var foo = {}; // nowy pusty obiekt
+    var foo = {}; // nowy, pusty obiekt
 
     // nowy obiekt z właściwością test o wartości 12
     var bar = {test: 12}; 
 
 ### Dostęp do właściwości
 
-Właściwości obiektu można uzyskać na dwa sposoby, poprzez notację z kropką
-lub notacje z nawiasami kwadratowymi.
+Właściwości obiektu można uzyskać na dwa sposoby - poprzez notację z kropką
+lub z nawiasami kwadratowymi.
     
-    var foo = {name: 'Kitten'}
+    var foo = {name: 'kitten'}
     foo.name; // kitten
     foo['name']; // kitten
     
@@ -54,13 +54,13 @@ lub notacje z nawiasami kwadratowymi.
     foo.1234; // wyrzuca błąd SyntaxError
     foo['1234']; // działa, zwraca undefined
 
-Obie notacje są identyczne w swoim działaniu, z tą tylko różnicą że notacja z nawiasami 
-kwadratowymi pozwala na dynamiczne dodawanie właściwości i nie prowadzi do wyrzycenia
+Obie notacje są identyczne w swoim działaniu, z tą tylko różnicą, że notacja z nawiasami 
+kwadratowymi pozwala na dynamiczne dodawanie właściwości i nie prowadzi do wyrzucenia
 błędu podczas odczytu nieistniejącej właściwości.
 
 ### Usuwanie właściwości
 
-Jedynym sposobem na faktycze usunięcie własności z obiektu jest użycie operatora 
+Jedynym sposobem na faktyczne usunięcie własności z obiektu jest użycie operatora 
 `delete`. Ustawienie własności na `undefined` lub `null` usunie tylko *wartość* 
 związaną z własnością, ale nie usunie to *klucza* (nazwy własności) z obiektu.
 
@@ -79,20 +79,20 @@ związaną z własnością, ale nie usunie to *klucza* (nazwy własności) z obi
         }
     }
 
-Powyższy kod wypisuje dwie linie `bar undefined` i `foo null` - tylko własność `baz`
+Powyższy kod wypisuje dwie linie - `bar undefined` i `foo null`. Tylko własność `baz`
 została usunięta i dlatego nie została wypisana.
 
 ### Notacja właściwości
 
     var test = {
-        'case': 'I am a keyword so I must be notated as a string',
-        delete: 'I am a keyword too so me' // wyrzuca błąd SyntaxError
+        'case': 'jestem słowem kluczowym, więc muszę być w cudzysłowie',
+        delete: 'tak samo jak ja' // wyrzuca błąd SyntaxError
     };
 
-Nazwy właściwości obiektu mogą być zarówno zapisane jako tekst(bez cudzysłowów 
-lub apostrofów) lub jako string (w cudzisłowach lub apostrofach). 
-Ze względu na kolejne niedociągnięcie w parserze JavaScript
-powyższy kod wyrzuci błąd `SyntaxError` dla implementacji JavaScript ponizej ECMAScript 5.
+Nazwy właściwości obiektu mogą być zarówno zapisane jako tekst (bez cudzysłowów 
+lub apostrofów) lub jako string (w cudzysłowach lub apostrofach). 
+Ze względu na kolejne niedociągnięcie w parserze JavaScript,
+powyższy kod wyrzuci błąd `SyntaxError` dla implementacji JavaScript poniżej ECMAScript 5.
 
 Ten błąd wynika z faktu, że `delete` jest *słowem kluczowym*, dlatego musi zostać 
 zapisany jako *string* (z cudzysłowami lub apostrofami), aby zapewnić, że zostanie 
diff --git a/doc/pl/object/hasownproperty.md b/doc/pl/object/hasownproperty.md
index 5c3429e6..59ae744a 100644
--- a/doc/pl/object/hasownproperty.md
+++ b/doc/pl/object/hasownproperty.md
@@ -1,13 +1,13 @@
 ## `hasOwnProperty`
 
-W celu sprawdzenia czy dana właściwość została zdefiniowana *w tym* obiekcie a **nie** 
-w [łańcuchu prototypów](#object.prototype) niezbędne jest skorzystanie z metody 
-`hasOwnProperty`, która wszystkie obiekty dziedziczą z `Object.prototype`.
+W celu sprawdzenia, czy dana właściwość została zdefiniowana *w tym* obiekcie, a **nie** 
+w [łańcuchu prototypów](#object.prototype), niezbędne jest skorzystanie z metody 
+`hasOwnProperty`, której wszystkie obiekty dziedziczą z `Object.prototype`.
 
-> **Uwaga:** **Nie** jest wystarczające, by sprawdzić, czy właściwość jest `undefined`.
-> Ponieważ właściwość może istnieć, ale jej wartość być ustawiona na `undefined`. 
+> **Uwaga:** **Nie** wystarczy sprawdzić, czy właściwość jest `undefined`,
+> ponieważ właściwość może istnieć, ale jej wartość być ustawiona na `undefined`. 
 
-`hasOwnProperty` jest jedyna metodą w języku JavaScript która operuje na właściwościach 
+`hasOwnProperty` jest jedyną metodą w języku JavaScript, która operuje na właściwościach 
 i **nie** przegląda całego łańcucha prototypów. 
 
     // Zatrucie Object.prototype
@@ -28,7 +28,7 @@ ale gdzieś indziej w łańcuchu prototypów.
 ### `hasOwnProperty` jako właściwość
 
 JavaScript **nie** chroni właściwości o nazwie `hasOwnProperty`, zatem istnieje 
-możliwość, że obiekt może posiadać tak nazwaną właściwość. Konieczne jest użycie
+możliwość, że obiekt będzie posiadać tak nazwaną właściwość. Konieczne jest użycie
 *zewnętrznego* `hasOwnProperty`, aby otrzymać poprawne rezultaty.
 
     var foo = {
@@ -40,14 +40,14 @@ możliwość, że obiekt może posiadać tak nazwaną właściwość. Konieczne
 
     foo.hasOwnProperty('bar'); // zawsze zwraca false
 
-    // Została użyta metoda innego obiektu i wywołana z konkekstem 
+    // Została użyta metoda innego obiektu i wywołana z kontekstem 
     // `this` ustawionym na foo
     ({}).hasOwnProperty.call(foo, 'bar'); // true
 
 ### Wnioski
 
-**Jedyną** metodą służącą do sprawdzenia zdefiniowania jakiejś właściwości w konkretnym 
-obiekcie jest metoda `hasOwnProperty`. Zaleca się korzystać z `hasOwnProperty` jako część
-**każdej** [pętli `for in`](#object.forinloop), pozwoli to uniknąć błędów pochodzących z 
-rozszerzonych natywnych [prototypów](#object.prototype).
+**Jedyną** metodą służącą do sprawdzenia istnienia jakiejś właściwości w konkretnym 
+obiekcie jest metoda `hasOwnProperty`. Zaleca się korzystać z `hasOwnProperty` w 
+**każdej** [pętli `for in`](#object.forinloop). Pozwoli to uniknąć błędów pochodzących 
+z rozszerzonych natywnych [prototypów](#object.prototype).
 
diff --git a/doc/pl/object/prototype.md b/doc/pl/object/prototype.md
index e79a45cb..3cabc20e 100644
--- a/doc/pl/object/prototype.md
+++ b/doc/pl/object/prototype.md
@@ -1,23 +1,23 @@
 ## Prototyp
 
-JavaScript nie posiada klasycznego modelu dziedziczenia, lecz zamiast tego 
+JavaScript nie posiada klasycznego modelu dziedziczenia. Zamiast tego 
 dziedziczenie jest realizowane poprzez *prototypy*.
 
 Choć jest to często uważane za jedną ze słabości języka JavaScript,
 prototypowy model dziedziczenia, jest w rzeczywistości potężniejszy od klasycznego
-modelu. Na przykład stworzenia klasycznego modelu na podstawie modelu prototypowym 
-jest dość proste, podczas gdy zrobienie odwrotnie to już o wiele trudniejsze zadanie.
+modelu. Na przykład stworzenia klasycznego modelu na podstawie modelu prototypowego 
+jest dość proste, podczas gdy zrobienie odwrotnego przekształcenie to o wiele trudniejsze zadanie.
 
 Ze względu na fakt, że w JavaScript jest w zasadzie jedynym powszechnie stosowanym 
-językiem, któy posiada prototypowy model dziedziczenia, to wymaga troche czasu aby
-dostosować się do różnic pomiędzy tymi dwoma modelami. 
+językiem, który posiada prototypowy model dziedziczenia, dostosowanie się do różnic pomiędzy
+tymi dwoma modelami wymaga trochę czasu. 
 
 Pierwszą znaczącą różnicą jest to, że dziedziczenie w JavaScript odbywa się za pomocą
 tak zwanych *łańcuchów prototypów*.
 
-> **Uwaga:** Używanie po prosstu `Bar.prototype = Foo.prototype` spowoduje, że oba obiekty 
-> będą korzystały z **tego samego** prototypu. W związku z tym zmiany na prototypie jednego
-> obiektu będą również zmieniały prototyp drugiego obiektu, co jest w wiekszości przypadków 
+> **Uwaga:** Używanie po prostu `Bar.prototype = Foo.prototype` spowoduje, że oba obiekty 
+> będą korzystały z **tego samego** prototypu. W związku z tym zmiany w prototypie jednego
+> obiektu będą również zmieniały prototyp drugiego obiektu, co jest ,w większości przypadków, 
 > niepożądanym efektem.
 
     function Foo() {
@@ -41,31 +41,31 @@ tak zwanych *łańcuchów prototypów*.
     // The resulting prototype chain
     test [instance of Bar]
         Bar.prototype [instance of Foo] 
-            { foo: 'Hello World' }
+            { foo: 'Hello World', value: 42 }
             Foo.prototype
                 { method: ... }
                 Object.prototype
                     { toString: ... /* etc. */ }
 
-W powyższym przykładzie obiekt `test` będzie dziedziczył z obydwu tj. 
-`Bar.prototyp` i `Foo.prototyp`, stąd będzie miał dostęp do funkcji `method`,
+W powyższym przykładzie obiekt `test` będzie dziedziczył z obydwu, tj. 
+`Bar.prototype` i `Foo.prototype`, stąd będzie miał dostęp do funkcji `method`,
 która była zdefiniowana w `Foo`. Ponadto obiekt będzie miał dostęp do 
-właściwości `value`, która jest jednyną instancją `Foo` i stała się jego prototypem.
-Ważne jest, aby pamiętać `new Bar` **nie** tworzy nowej instancji `Foo`, 
-ale wykorzystuje instancje, którą jest przypisana do własności `prototype`. 
+właściwości `value`, która jest jedyną instancją `Foo` i stała się jego prototypem.
+Należy pamiętać, że `new Bar` **nie** tworzy nowej instancji `Foo`, 
+tylko wykorzystuje instancję, która jest przypisana do własności `prototype`. 
 Zatem Wszystkie instancje `Bar` będą dzieliły tą samą własność `value`.
 
 > **Uwaga:** **Nie** należy używać konstrukcji `Bar.prototype = Foo`, 
-> ponieważ nie spowoduje ona przypisania prototypu `Foo` a raczej obiektu 
-> funckji `Foo`. Zatem łańcuch prototypów nie bedzie zawierał `Foo.prototype`,
-> ale `Function.prototype`, więc metoda `method` nie będzie w łańcuchu prototypów. 
+> ponieważ nie spowoduje ona przypisania prototypu `Foo` tylko obiektu 
+> funckji `Foo`. Zatem łańcuch prototypów nie będzie zawierał `Foo.prototype`,
+> tylko `Function.prototype`, więc metoda `method` nie będzie w łańcuchu prototypów. 
 
 ### Wyszukiwanie własności
 
-Podczas dostępu do właściwości obiektu, JavaScript przejdzie w górę łańcucha 
-prototypów dopóki nie znajdzie właściwości z żądaną nazwą.
+Podczas dostępu do właściwości obiektu JavaScript przejdzie w górę łańcucha 
+prototypów, dopóki nie znajdzie właściwości bez nazwy.
 
-Gdy przeszukiwanie dotrze do końca (szczytu) łańcucha mianowicie `Object.prototype` 
+Gdy przeszukiwanie dotrze do końca (szczytu) łańcucha, mianowicie `Object.prototype` 
 i nadal nie znajdzie określonej właściwości, to zwróci wartość 
 [undefined](#core.undefined).    
 
@@ -85,31 +85,31 @@ na dynamiczne tworzenie łańcuchów prototypów.
 
 Czas wyszukiwania właściwości, które są na końcu łańcucha prototypów może mieć 
 negatywny wpływ na wydajność krytycznych części kodu. Dodatkowo, próba dostępu 
-do nieistniejącej właściwości powoduje zawsze przeszukanie całego łańcucha prototypów.
+do nieistniejącej właściwości zawsze spowoduje przeszukanie całego łańcucha prototypów.
 
-Również, podczas [iteracji](#object.forinloop) po właściwościach obiektu
-**każda** właściwość, która znajduje się w łańcuchu prototypów niezależnie 
-na jakim znajduje się poziomie zostanie wyliczona.
+Również podczas [iteracji](#object.forinloop) po właściwościach obiektu
+**każda** właściwość, która znajduje się w łańcuchu prototypów (niezależnie 
+na jakim znajduje się poziomie) zostanie wyliczona.
 
 ### Rozszerzanie natywnych prototypów
 
 Rozszerzanie `Object.prototype` lub innego prototypu wbudowanych typów jest jednym z 
-najczęściej używanych niedoskonałej częsci języka JavaScript.
+najczęściej nadużywanej częsci języka JavaScript.
 
 Technika ta nazywana jest [monkey patching][1] i łamie zasady *enkapsulacji*.
-Jednak jest szeroko rozpowszechniona w frameworkach takich jak [Prototype][2].
-Nie ma jednak dobrego powodu, aby zaśmiecać wbudowane typy poprzez dodawanie do nich
-*niestandardowych* funkcjonalności.
+Mimo to jest szeroko rozpowszechniona w frameworkach takich jak [Prototype][2].
+Nie ma jednak dobrego powodu, aby zaśmiecać wbudowane typy poprzez wzbogacanie ich o 
+*niestandardowe* funkcjonalności.
 
 **Jedynym** dobrym powodem do rozszerzania wbudowanych prototypów jest portowanie  
-funkcjonalności znajdujących sie w nowszych silnikach JavaScript np. [`Array.forEach`][3]
+funkcjonalności znajdujących się w nowszych silnikach JavaScript, np. [`Array.forEach`][3]
 
 ### Wnioski
 
-Zanim przystąpi się do pisania skomplikowanego kodu korzystającego z dziedziczanie 
-należy **całkowicie** rozumieć prototypowy model dziedziczenia. Ponadto należy uważać 
-na długość łańcucha prototypów i w razie potrzeby zmniejszać ilość dziedziczeń 
-aby uniknąć problemów z wydajnością. Natywne prototypy nie powinny **nigdy** być 
+Zanim przystąpi się do pisania skomplikowanego kodu korzystającego z dziedziczenia,  
+należy **całkowicie** zrozumieć prototypowy model dziedziczenia. Ponadto trzeba uważać 
+na długość łańcucha prototypów i w razie potrzeby zmniejszać ilość dziedziczeń, 
+aby uniknąć problemów z wydajnością. Natywne prototypy **nigdy** nie powinny być 
 rozszerzane, chyba że ze względu na wprowadzanie kompatybilności z nowszymi silnikami 
 JavaScript.
 
diff --git a/doc/pl/other/timeouts.md b/doc/pl/other/timeouts.md
index bf2ad512..97a47745 100644
--- a/doc/pl/other/timeouts.md
+++ b/doc/pl/other/timeouts.md
@@ -1,15 +1,13 @@
 ### `setTimeout` i `setInterval`
 
 Ponieważ JavaScript jest asynchroniczny, istnieje możliwość zaplanowania wykonania 
-funkcji korzystając z funkcji `setTimeout` i `setInterval`.
-Since JavaScript is asynchronous, it is possible to schedule the execution of a 
-function by using the `setTimeout` and `setInterval` functions.
+funkcji przy użyciu funkcji `setTimeout` i `setInterval`.
 
 > **Note:** Funkcje czasowe nie są częścią standardu ECMAScript. Jest to część 
 > standardu [DOM][1].
 
     function foo() {}
-    var id = setTimeout(foo, 1000); // zwraca licznę typu Number > 0
+    var id = setTimeout(foo, 1000); // zwraca liczbę typu Number > 0
 
 Powyższe wywołanie `setTimeout` zwraca ID budzika i planuje wywołanie `foo` za 
 **około** tysiąc milisekund. `foo` zostanie wykonana dokładnie **jeden raz**.
@@ -18,11 +16,11 @@ Powyższe wywołanie `setTimeout` zwraca ID budzika i planuje wywołanie `foo` z
 upłynięciu zadanego czasu podanego jako parametr do `setTimeout`, ponieważ zależy 
 to od dokładności zegara w silniku JavaScript, który wykonuje kod oraz od tego, 
 że inny kawałek kodu może zablokować wątek, ponieważ JavaScript jest tylko 
-jedno wątkowy.
+jednowątkowy.
 
 Funkcja, która została przekazana jako pierwszy parametr zostanie wykonana w 
 globalnym zasięgu, co oznacza, że [`this`](#function.this) wewnątrz tej funkcji 
-będzie wkazywać na obiekt *global*.
+będzie wskazywać na obiekt *global*.
 
     function Foo() {
         this.value = 42;
@@ -35,22 +33,22 @@ będzie wkazywać na obiekt *global*.
     new Foo();
 
 > **Uwaga:** Ponieważ `setTimeout` przyjmuje **obiekt funkcji** jako pierwszy 
-> argument często popełnianym błędem jest wykorzystanie składni `setTimeout(foo(), 1000)`, 
+> argument, często popełnianym błędem jest wykorzystanie składni `setTimeout(foo(), 1000)`, 
 > która użyje wartości zwróconej przez funkcję `foo` jako parametru zamiast 
 > funkcji `foo` samej w sobie. W większości przypadków będzie to cichy błąd, 
-> ponieważ jeżeli funkcja zwróci `undefined` `setTimeout` **nie** wyrzuci żadnego 
+> ponieważ jeżeli funkcja zwróci `undefined`, `setTimeout` **nie** wyrzuci żadnego 
 > błędu.
 
 ### Kolejkowanie wywołań z `setInterval`
 
-Podczas, gdy `setTimeout` wywołuje podaną funkcję tylko raz, `setInterval` - 
+Podczas gdy `setTimeout` wywołuje podaną funkcję tylko raz, `setInterval` - 
 jak wskazuje nazwa - będzie wykonywać funkcję **w odstępach czasowych** co `X` 
 milisekund. Jednakże korzystanie z tej funkcji jest odradzane.
 
 Kiedy wykonywany kod zablokuje możliwość uruchomienia zaplanowanej funkcji, 
-`setInterval` będzie próbować uruchamiać daną funkcję co będzie powodować 
-kolejkowanie wykonania tej samej funkcji kilkakrotnie. W szczególności może się 
-to wydarzyć przy krótkim interwale.
+`setInterval` będzie próbować uruchamiać daną funkcję, co będzie powodować 
+kolejkowanie wykonania tej samej funkcji kilkukrotnie. Może się to zdarzyć
+szczególnie przy krótkim interwale.
 
     function foo(){
         // coś co blokuje wykonanie na 1 sekundę 
@@ -60,13 +58,13 @@ to wydarzyć przy krótkim interwale.
 W powyższym kodzie kod `foo` zostanie wywołany tylko raz i zablokuje wywołanie na 
 jedną sekundę.
 
-Podczas, gdy funkcja `foo` blokuje wykonanie `setInterval` będzie planować kolejne 
-wywołania `foo`. W momencie, gdy pierwsze wywołanie `foo` się zakończy, już 
-w kolejce do wywołania będą czekały kolejne **dziesięć** wywołań tej funkcji.
+Podczas, gdy funkcja `foo` blokuje wykonanie, `setInterval` będzie planować kolejne 
+wywołania `foo`. W momencie, gdy pierwsze wywołanie `foo` się zakończy, 
+w kolejce do wywołania będzie już czekało kolejne **dziesięć** wywołań tej funkcji.
 
 ### Radzenie sobie z możliwymi blokadami
 
-Najprostrzym jak również najbardziej kontrolowaną sytuacją jest użycie `setTimeout` 
+Najprostszą, jak również najbardziej kontrolowaną sytuacją, jest użycie `setTimeout` 
 wewnątrz wywoływanej funkcji.
 
     function foo(){
@@ -75,9 +73,9 @@ wewnątrz wywoływanej funkcji.
     }
     foo();
 
-Powyższy kod nie tylko hermetyzuje wywołanie `setTimeout` ale również zapobiega 
-kolejkowaniu wywołań fukcji i daje dodatkową kontrolę. W tym przypadku funkcja 
-`foo` może zdecydować czy powinna się wywołać ponownie czy też nie.
+Powyższy kod nie tylko hermetyzuje wywołanie `setTimeout`, ale też zapobiega 
+kolejkowaniu wywołań funkcji i daje dodatkową kontrolę. W tym przypadku funkcja 
+`foo` może zdecydować czy powinna się wywołać ponownie, czy też nie.
 
 ### Ręczne usuwanie budzików
 
@@ -90,17 +88,17 @@ zwrócone ID.
 
 ### Usuwanie wszystkich budzików
 
-Ponieważ nie istnieje wbudowana metoda na usunięcie wszystkich budzików i/lub 
-interwałów, konieczne jest użycie metody brute force aby osiągnąć ten efekt.
+Ponieważ nie istnieje wbudowana metoda usuwania wszystkich budzików i/lub 
+interwałów, do osiągnięcia tego efektu konieczne jest użycie metody 'brute force'.
 
     // usunięcie "wszystkich" budzików 
     for(var i = 1; i < 1000; i++) {
         clearTimeout(i);
     }
 
-Nadal może istnieć jakieś budziki, na które powyższy kawałek kodu nie zadziała, 
-ponieważ ID było z innego przedziału, dlatego zamiast korzystania z metody brute 
-force, zaleca się śledzić wszystkie numery ID budzików, aby można je było usunąć.
+Nadal mogą istnieć jakieś budziki, na które powyższy kawałek kodu nie zadziała. 
+Ponieważ ID było z innego przedziału, zamiast korzystania z metody brute force, 
+zaleca się śledzić wszystkie numery ID budzików, aby można je było usunąć.
 
 ### Ukryte wykorzystanie `eval`
 
@@ -125,11 +123,11 @@ możliwości, ponieważ wewnętrznie `setTimeout` i `setInterval` wykorzystują
     }
     bar();
 
-Ponieważ `eval` nie zostało wywołane [wprost](#core.eval) w tym przypadku, to 
-string przekazany do `setTimeout` zostanie uruchomiony w *zasięgu globalnym*, 
-co za tym idzie lokalna zmienna `foo` z zasięgu `bar` nie zostanie użyta.
+Ponieważ `eval` nie zostało wywołane w tym przypadku [wprost](#core.eval), to 
+string przekazany do `setTimeout` zostanie uruchomiony w *zasięgu globalnym*. 
+Co za tym idzie, lokalna zmienna `foo` z zasięgu `bar` nie zostanie użyta.
 
-Kolejnym zaleceniem jest aby **nie** stosować stringów do przekazywania argumentów 
+Kolejnym zaleceniem jest **niestosowanie** stringów do przekazywania argumentów 
 do funkcji, która ma zostać wywołana przez budzik.
 
     function foo(a, b, c) {}
@@ -137,23 +135,23 @@ do funkcji, która ma zostać wywołana przez budzik.
     // NIGDY nie należy tak robić 
     setTimeout('foo(1,2, 3)', 1000)
 
-    // Zamiast tego należy skorzystać z anonimowej funkcji
+    // zamiast tego należy skorzystać z anonimowej funkcji
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
->**Uwaga:** Mimo, że możliwe jest wykorzystanie składni
-> `setTimeout(foo, 1000, a, b, c)`, to nie zaleca się korzystania z niej, ponieważ 
+>**Uwaga:** Mimo że możliwe jest wykorzystanie składni
+> `setTimeout(foo, 1000, 1, 2, 3)`, nie zaleca się korzystania z niej, ponieważ
 > może to prowadzić do subtelnych błędów podczas wykorzystania [metod](#function.this).
 
 ### Wnioski
 
-Nie należy **nigdy** przekazywać stringu jako parametru do `setTimeout` lub 
-`setInterval`. Jest to wyraźną oznaką **bardzo** złego kodu, jeżeli potrzebne jest 
-przekazanie argumentów do funkcji należy skorzystać z *anonimowej funkcji* i 
+**Nigdy** nie należy przekazywać stringu jako parametru do `setTimeout` lub 
+`setInterval`. Jest to wyraźną oznaką **bardzo** złego kodu. Jeżeli potrzebne jest 
+przekazanie argumentów do funkcji, należy skorzystać z *anonimowej funkcji* i 
 wewnątrz niej dokonać przekazania argumentów.
 
-Ponadto, należy unikać korzystanie z `setInterval`, ponieważ planista może 
+Ponadto, należy unikać korzystania z `setInterval`, ponieważ planista może 
 zablokować wykonanie JavaScriptu.
 
 [1]: http://pl.wikipedia.org/wiki/Obiektowy_model_dokumentu "Document Object Model"
diff --git a/doc/pl/types/casting.md b/doc/pl/types/casting.md
index 5e358c63..099ac0c9 100644
--- a/doc/pl/types/casting.md
+++ b/doc/pl/types/casting.md
@@ -1,43 +1,43 @@
 ## Rzutowanie typów
 
-JavaScript jest językiem słabo typowanym, co za tym idzie będzie stosować koercję 
+JavaScript jest językiem słabo typowanym. Co za tym idzie, będzie stosować koercję 
 typów **gdziekolwiek** jest to możliwe.
 
-    // These are true
+    // te zwracają true
     new Number(10) == 10; // Number.toString() zostanie przekształcone
                           // z powrotem do liczby
 
-    10 == '10';           // Stringi zostaną przekształcone do typu Number
-    10 == '+10 ';         // Kolejne wariacje
+    10 == '10';           // stringi zostaną przekształcone do typu Number
+    10 == '+10 ';         // kolejne wariacje
     10 == '010';          // i następne
     isNaN(null) == false; // null zostanie przekształcony do 0
                           // który oczywiście nie jest NaN
     
-    // Poniższe zwracają false
+    // poniższe zwracają false
     10 == 010;
     10 == '-10';
 
-> **Uwaga ES5: Literały licznowe zaczynające sie od `0` są interpretowane jako
+> **Uwaga ES5: Literały liczbowe zaczynające się od `0` są interpretowane jako
 > liczby w systemie ósemkowym. W trybie strict mode w ECMAScript 5 wsparcie dla 
 > liczb ósemkowych zostało porzucone.
 
-Aby uniknąć powyższych problemów, należy **koniecznie** skorzystać ze 
+Aby uniknąć powyższych problemów, należy **koniecznie** korzystać ze 
 [ściełego operatora równości](#types.equality). Mimo, że pozwala to uniknąć wiele 
 typowych problemów to nadal istnieje wiele innych, które powstają na bazie słabego 
 typowania języka JavaScript.
 
 ### Konstruktory typów wbudowanych
 
-Konstruktory typów wbudowanych takich, jak `Number` lub `String` zachowują się 
-inaczej jeżeli są poprzedzone słowem kluczowym `new` a inaczej jeżeli nie są.
+Konstruktory typów wbudowanych, takich jak `Number` lub `String`, zachowują się 
+inaczej kiedy są poprzedzone słowem kluczowym `new` a inaczej kiedy nie są.
 
     new Number(10) === 10;     // False, Object i Number
     Number(10) === 10;         // True, Number i Number
     new Number(10) + 0 === 10; // True, ponieważ dokonano jawnej konwersji
 
-Korzystanie z wbudowanych typów jak `Number` jako konstruktor utworzy nowy obiekt 
-typu `Number`, natomiast opuszczenie słowa kluczowego `new` spowoduje, że funkcja 
-`Number` zachowa się jak konwerter.
+Korzystanie z wbudowanych typów jak `Number` jako konstruktora tworzy nowy obiekt 
+typu `Number`, natomiast opuszczenie słowa kluczowego `new` powoduje, że funkcja 
+`Number` zachowuje się jak konwerter.
 
 Ponadto, użycie literałów lub wartości nieobiektowych zaowocuje jeszcze większą 
 ilością rzutowań (koercją) typów.
@@ -58,7 +58,7 @@ Zastosowanie **unarnego** operatora + spowoduje rzutowanie do typu Number.
 
 ### Rzutowanie do typu Boolean
 
-Używając dwukrotnie operatora **negacji** dowolna wartość może zostać zrzutowana 
+Używając dwukrotnie operatora **negacji**, dowolna wartość może zostać zrzutowana 
 do typu Boolean
 
     !!'foo';   // true
diff --git a/doc/pl/types/equality.md b/doc/pl/types/equality.md
index e79b952f..c655a795 100644
--- a/doc/pl/types/equality.md
+++ b/doc/pl/types/equality.md
@@ -21,16 +21,16 @@ JavaScript jest słabo typowanym językiem. Oznacza to, że operator równości
 
 Powyższa tabela przedstawia wyniki koercji typów. Nieprzewidywalne wyniki 
 porównania są głównym powodem, że stosowanie `==` jest powszechnie uważane za złą 
-praktykę. Skomplikowane reguły konwersji są powodem trudnych do wyśledzenia błędy.
+praktykę. Skomplikowane reguły konwersji są powodem trudnych do wyśledzenia błędów.
 
-Ponadto koercja ma również wpływ na wydajność na przykład gdy typ String musi zostać 
+Ponadto koercja ma również wpływ na wydajność, Na przykład gdy typ String musi zostać 
 przekształcony na typ Number przed porównaniem z drugą liczbą.
 
 ### Operator ścisłej równości
 
 Operator ścisłej równości składa się z **trzech** znaków "równa się": `===`
 
-Działa on dokładnie tak jak normalny operator równości, z jednym wyjątkiem nie 
+Działa on dokładnie tak jak normalny operator równości, z jednym wyjątkiem - nie 
 dokonuje koercji typów przed porównaniem.
 
     ""           ===   "0"           // false
@@ -49,8 +49,8 @@ obiektów o różnych typach.
 
 ### Porównywanie obiektów
 
-Mimo, że oba operatory `==` i `===` nazywane są operatorami **równościowymi**, 
-to zachowują się różnie gdy jednym z operandów jest obiekt typu `Object`.
+Mimo że oba operatory `==` i `===` nazywane są operatorami **równościowymi**, 
+to zachowują się różnie, gdy jednym z operandów jest obiekt typu `Object`.
 
     {} === {};                   // false
     new String('foo') === 'foo'; // false
@@ -58,14 +58,14 @@ to zachowują się różnie gdy jednym z operandów jest obiekt typu `Object`.
     var foo = {};
     foo === foo;                 // true
 
-Oba operatory porównują **toższmość** a **nie** równość, czyli będą porównywać czy 
-jeden i drugi operand jest tą samą **instancją** obiektu, podobnie jak operator 
-`is` w Pythonie i porównanie wskaźników w C.  
+Oba operatory porównują **tożsamość** a **nie** równość, czyli będą porównywać czy 
+jeden i drugi operand jest tą samą **instancją** obiektu (podobnie jak operator 
+`is` w Pythonie i porównanie wskaźników w C).  
 
 ### Wnioski
 
-Zaleca się aby używać tylko operatora **ścisłej równości**. W sytuacjach gdy 
+Zaleca się, aby używać tylko operatora **ścisłej równości**. W sytuacjach gdy 
 potrzebna jest koercja (porównanie obiektów różnych typów), konwersja powinna 
-być dokonana [jawnie](#types.casting) a nie pozostawiona trudnym regułom koercji 
+być dokonana [jawnie](#types.casting), a nie pozostawiona trudnym regułom koercji 
 obowiązującym w języku.
 
diff --git a/doc/pl/types/instanceof.md b/doc/pl/types/instanceof.md
index 73ae4ebd..aee5fe86 100644
--- a/doc/pl/types/instanceof.md
+++ b/doc/pl/types/instanceof.md
@@ -1,8 +1,8 @@
 ## Operator `instanceof`
 
 Operator `instanceof` porównuje konstruktory obiektów przekazanych jako operendy. 
-Jest on jedynie użyteczny do porównywania obiektów utworzonych klas. Stosowanie 
-go na wbudowanych typach jest praktycznie tak samo bezużyteczne jak operatora
+Jest on użyteczny jedynie do porównywania obiektów utworzonych klas. Stosowanie 
+go na wbudowanych typach jest praktycznie tak samo bezużyteczne, jak operatora
 [typeof](#types.typeof).
 
 ### Porównywanie obiektów utworzonych klas
@@ -14,7 +14,7 @@ go na wbudowanych typach jest praktycznie tak samo bezużyteczne jak operatora
     new Bar() instanceof Bar; // true
     new Bar() instanceof Foo; // true
 
-    // Poniżej kod który przypisuje do Bar.prototype obiekt funkcji Foo
+    // poniżej kod który przypisuje do Bar.prototype obiekt funkcji Foo
     // a nie faktyczną instancję Foo
     Bar.prototype = Foo;
     new Bar() instanceof Foo; // false
@@ -34,7 +34,7 @@ samymi obiektami.
 
 ### Wnioski
 
-Operator `instanceof` powinien być **tylko** używany podczas korzystania z obiektów 
+Operator `instanceof` powinien być używany **wyłącznie** podczas korzystania z obiektów 
 klas utworzonych, które były zdefiniowane w tym samym kontekscie JavaScriptowym. 
 Podobnie jak operator [`typeof`](#types.typeof), należy **unikać** korzystania 
 z tego operatora w innych sytuacjach.
diff --git a/doc/pl/types/typeof.md b/doc/pl/types/typeof.md
index 186e241f..666d9b52 100644
--- a/doc/pl/types/typeof.md
+++ b/doc/pl/types/typeof.md
@@ -1,10 +1,10 @@
 ## Operator `typeof` 
 
 Operator `typeof` (razem z operatorem [`instanceof`](#types.instanceof)) jest 
-prawdopodobnie najwiekszą wadą konstrukcji języka JavaScript, jest on praktycznie 
-**całkowicie wadliwy**.
+prawdopodobnie najwiekszą wadą konstrukcji języka JavaScript. Posiada on praktycznie  
+**same wady**.
 
-Mimo, że `instanceof` ma swoje wady to nadal ma ograniczone zastosowanie w praktyce, 
+Mimo że `instanceof` ma swoje wady to nadal ma ograniczone zastosowanie w praktyce, 
 natomiast `typeof` ma tylko jeden praktyczny przypadek użycia, który na dodatek 
 **nie** jest związany z sprawdzaniem typu obiektu.
 
@@ -36,7 +36,7 @@ natomiast `typeof` ma tylko jeden praktyczny przypadek użycia, który na dodate
 W powyższej tabeli *Typ* odnosi się do wartości zwracanej przez operator `typeof`. 
 Wyraźnie widać, że zwracane wartości w ogóle nie są spójne.
 
-*Klasa* odnosi sie do wartości wewnętrznej właściwości `[[Class]]` obiektu.
+*Klasa* odnosi się do wartości wewnętrznej właściwości `[[Class]]` obiektu.
 
 > **Fragment Specyfikacji:** Wartość `[[Class]]` może być jednym z poniższych 
 > stringów. `Arguments`, `Array`, `Boolean`, `Date`, `Error`, 
@@ -83,5 +83,5 @@ są zdefiniowane w specyfikacji, co za tym idzie mogą się różnić w różnyc
 implementacjach.
 
 O ile nie operator `typeof` nie jest użyty do sprawdzania czy zmienna została 
-zdefiniowana, powinien być unikany **o ile to tylko możliwe**.
+zdefiniowana, powinien być unikany **jeśli to tylko możliwe**.
 
diff --git a/doc/ptbr/array/constructor.md b/doc/ptbr/array/constructor.md
new file mode 100644
index 00000000..eaaf1c20
--- /dev/null
+++ b/doc/ptbr/array/constructor.md
@@ -0,0 +1,29 @@
+## O construtor `Array`
+
+Uma vez que o construtor `Array` é ambíguo na forma como ele lida com seus parâmetros,
+o uso da notação `[]` é fortemente recomendado ao criar novo arrays.
+
+    [1, 2, 3]; // Resultado: [1, 2, 3]
+    new Array(1, 2, 3); // Resultado: [1, 2, 3]
+
+    [3]; // Resultado: [3]
+    new Array(3); // Resultado: []
+    new Array('3') // Resultado: ['3']
+
+Nos casos onde somente um argumento é passado para o construtor `Array` e quando o argumento é
+um `Number`, o construtor retornará um novo array *sem elementos* com a propriedade `length` configurada de acordo com o valor do argumento.
+É importante perceber que **somente** a propriedade `length` do novo array será configurada desta maneira; os índices do array não serão inicializados.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, o índice não foi definida
+
+Ser capaz de definir o comprimento de um array antecipadamente é útil em poucos casos,
+como ao replicar uma string, em que se evita o uso de um loop.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### Conclusão
+
+O uso de literais é preferencial na inicialição de Arrays. São curtos, possuem uma sintaxe limpa, e contribuem para a legibilidade do código.
+
diff --git a/doc/ptbr/array/general.md b/doc/ptbr/array/general.md
new file mode 100644
index 00000000..10543a84
--- /dev/null
+++ b/doc/ptbr/array/general.md
@@ -0,0 +1,59 @@
+## Iteração com Arrays e propriedades
+
+Embora arrays em JavaScript sejam objetos, não existem boas razões para utilizar
+o [`for in`](#object.forinloop) loop. De fato, existem muitas boas razões para 
+**evitar** o uso de `for in` com arrays.
+
+> **Nota:** JavaScript arrays **não** são *arrays associativos*. JavaScript utiliza 
+> [objects](#object.general) apenas para mapear chaves com valores. Enquanto arrays associativos 
+> **preservam** a ordem, objetos **não preservam**.
+
+Uma vez que o `for in` loop enumera todas as propriedades que estão na cadeia
+prototype e visto que o único modo de excluir tais propriedades é por meio do uso
+do [`hasOwnProperty`](#object.hasownproperty), ele chega a ser **vinte vezes**
+mais custoso que o uso normal do `for` loop.
+
+### Iteração
+
+A fim de atingir a melhor performance ao interagir sobre arrays, 
+a melhor opção é utilizar o clássico `for` loop.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Existe um detalhe importante no exemplo acima , que é o caching
+do comprimento do array via `l = list.length`.
+
+Embora a propriedade `length` esteja definida no próprio array, ainda existe
+um trabalho extra ao executar a busca em cada iteração do array.
+Enquanto que recentes engines JavaScript **talvez** implementem um otimização
+para este caso, não existe uma maneira de saber quando o código será executado em uma
+dessas novas engines. 
+
+De fato, deixando de lado o armazenamento em caching pode resultar em um loop **duas vezes mais rápido** 
+do que com o armazenamento em caching.
+
+### A propriedade `length`
+
+Enquanto que o *getter* da propriedade `length` retorna o total de elementos
+que estão contidos no array, o *setter* pode ser usado para **truncar** o array. 
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo.push(4);
+    foo; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Atribuir um valor de menor para length trunca o array. Por outro lado, incrementando
+o valor de length cria um array esparso.
+
+### Conclusão
+
+Para melhor performance, é recomendado o uso do `for` loop e o cache da propriedade
+`length`. O uso do `for in` loop na iteração com array é um sinal de código mal escrito 
+e tendencioso a apresentar defeitos, além de ter performance ruim.
+
diff --git a/doc/ptbr/core/delete.md b/doc/ptbr/core/delete.md
new file mode 100644
index 00000000..949c24d8
--- /dev/null
+++ b/doc/ptbr/core/delete.md
@@ -0,0 +1,85 @@
+## O operador `delete`
+
+Em resumo, é *impossível* remover variáveis globais, funções e outras coisas em JavaScript
+que tenham o atributo `DontDelete` definido.
+
+### Código global e código de função
+
+Quando uma variável ou função é definida no escopo global ou em 
+um [escopo de função](#function.scopes) ela passa a ser uma propriedade de ambos
+objeto Activation e do objeto Global. Tais propriedades possuem um conjunto de atributos, um dos quais é o `DontDelete`.
+Declarações de funções e variáveis em código global e em código de função
+sempre criam propriedades com `DontDelete`, e portanto não podem ser removidas.
+
+    // variável global:
+    var a = 1; // DontDelete está definido
+    delete a; // false
+    a; // 1
+
+    // função comum:
+    function f() {} // DontDelete está definido
+    delete f; // false
+    typeof f; // "function"
+
+    // mudar o valor do atributo não ajuda:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Propriedades explícitas
+
+Propriedades definidas explicitamente podem ser apagadas normalmente.
+
+    // definição explícita de propriedade:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+No exemplo acima, `obj.x` e `obj.y` podem ser removidos por que eles não possuem o
+atributo `DontDelete`. Este é o motivo pelo qual o exemplo abaixo também funciona.
+
+    // Desconsiderando o IE, isto funciona bem:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - apenas uma variável global
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Aqui nós utilizamos um truque para remover `a`. Aqui o [`this`](#function.this)
+faz referência ao objeto Global e declara explicitamente a variável `a` como
+sua propriedade a qual nos permite removê-la.
+
+O IE (pelo menos 6-8) possui defeitos, então o código acima não funciona.
+
+### Argumentos de função e propriedades nativas
+
+Argumentos de função, [objetos `arguments`](#function.arguments) e 
+propriedades nativas tambêm possuem o `DontDelete` definido.
+
+    // argumentos de funções e propriedades:
+    (function (x) {
+    
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Objetos hosts
+    
+O comportamento do operador `delete` pode ser imprevisível para objetos hosts.
+Devido a especificação, objetos hosts têm permissão para implementar qualquer tipo de comportamento.
+
+### Conclusão
+
+O operador `delete` freqüentemente apresenta um comportamento inesperado e só
+pode ser usado com segurança para remover propriedades definidas explicitamente em objetos normais.
diff --git a/doc/ptbr/core/eval.md b/doc/ptbr/core/eval.md
new file mode 100644
index 00000000..e7608cd9
--- /dev/null
+++ b/doc/ptbr/core/eval.md
@@ -0,0 +1,45 @@
+## Por que não utilizar `eval`
+
+A função `eval` executará uma string de código JavaScript no escopo local.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+
+Entretanto, `eval` somente é executado no escopo local quando é chamado diretamente
+*e* quando o nome da função chamada é `eval`. 
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+O uso de `eval` deve ser evitado. 99.9% de seu "uso" pode ser alcançado **sem** ele.
+    
+### `eval` dissimulado
+
+As [funções timeout](#other.timeouts) `setTimeout` e `setInterval` podem ambas receberem uma string
+como primeiro argumento. Tais strings **sempre** serão executadas no escopo global uma vez que 
+`eval` não é chamado diretamente, naquele caso.
+
+### Problemas de segurança
+
+`eval` também é considerado um problema de segurança, por que executa **qualquer** código dado.
+Ele **nunca** deve ser utilizado com strings de origens duvidosas ou desconhecidas.
+
+### Conclusão
+
+`eval` nunca deve ser utilizado. Qualquer código que faça uso de `eval` seve ser questionado
+em sua utilidade, performance e segurança. Se algo necessita de `eval` para funcionar, então **não** deve ser utilizado.
+Um *design melhor* deve ser utilizado, um que não faça uso de `eval`.
+
diff --git a/doc/ptbr/core/semicolon.md b/doc/ptbr/core/semicolon.md
new file mode 100644
index 00000000..843d7db4
--- /dev/null
+++ b/doc/ptbr/core/semicolon.md
@@ -0,0 +1,100 @@
+## Inserção automática do ponto e vírgula 
+
+Apesar do JavaScript possuir uma sintaxe no estilo C, o uso do ponto e vírgula **não** é obrigatório. 
+
+JavaScript não é uma linguagem 'semicolon-less'. De fato, o ponto e vírgula é necessário para o interpretação do código. Entretanto, o parser do JavaScript insere o **ponto e vírgula** automaticamente sempre que ocorrer um error de parser, decorrente da falta do ponto e vírgula. 
+
+    var foo = function() {
+    } // parse error, semicolon expected
+    test()
+
+A inserção acontece e o parser realiza uma nova tentativa. 
+
+    var foo = function() {
+    }; // no error, parser continues
+    test()
+
+A inseção automática de ponto e vírgula é considerada um dos **maiores** equívocos no design da linguagem pois pode influenciar no comportamento do código.
+
+### Como funciona
+
+O código abaixo não possui ponto e vírgula, então fica à cargo do parser inserir o ponto e vírgula onde julgar necessário.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Abaixo está o resultado do processamento do parser.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Not inserted, lines got merged
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- inserted
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- inserted
+
+            return; // <- inserted, breaks the return statement
+            { // treated as a block
+
+                // a label and a single expression statement
+                foo: function() {} 
+            }; // <- inserted
+        }
+        window.test = test; // <- inserted
+
+    // The lines got merged again
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- inserted
+
+    })(window); //<- inserted
+
+> **Nota:** O parser do JavaScript não manipula corretamente 'return statements' que são seguidos de uma nova linha. Apesar de não ser necessariamente uma > > > falha da inserção automática do ponto e vírgula, ainda pode gerar efeitos colaterais não-esperados. 
+
+O parser mudou o comportamento do código acima drásticamente. Em determinados casos, o parser **não procede** como o esperado. 
+
+### Parênteses 
+
+No caso de parênteses, o parser **não** insere o ponto  e vírgula. 
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Este código é interpretado em uma só linha. 
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+As chances de `log` não retornar uma função são **muito** altas; portanto, o código acima irá produzir um `TypeError` informando que `undefined is not a function`.
+
+### Conclusão
+
+É **fortemente** recomendado que nunca se omita o ponto e vírgula. Também é recomendado que chaves sejam mantidas na mesma linha que seus statements e que nunca sejam omitadas em declações de uma só linha como `if` / `else` statements. Tais medidas não somente melhorarão a consistência do código, como também irão previnir alteração no comportamento do código por má interpretação do parser do JavaScript.
+
diff --git a/doc/ptbr/core/undefined.md b/doc/ptbr/core/undefined.md
new file mode 100644
index 00000000..cbaedcc6
--- /dev/null
+++ b/doc/ptbr/core/undefined.md
@@ -0,0 +1,68 @@
+## `undefined` e `null`
+
+JavaScript tem duas formas distintas para representar o nada, `null` e `undefined`, com
+o último sendo o mais útil.
+
+### O valor `undefined`
+
+`undefined` é um tipo com um valor exato : `undefined`.
+
+A linguagem também define uma variável global que tem como valor `undefined`;
+esta variável também é chamada `undefined`. Entretanto tal variável *não é nem* uma constante
+*muito menos* uma palavra-chave da linguagem. Isto significa que seu *valor* pode ser facilmente
+sobrescrito.
+
+> **Nota ES5:** `undefined` em ECMAScript 5 **não dispõe** mais de permissão para escrita no modo estrito, porém
+> sua denominação ainda pode ser confundida com, por exemplo, uma função com o nome `undefined`.
+
+Aqui estão alguns exemplos de quando o valor `undefined` é retornado:
+
+ - Acessando uma variável global (não-modificada) `undefined`.
+ - Acessando uma variável declarada *mas não* ainda inicializada.
+ - Retornos implícitos de funções devido ao esquecimento do `return` statement.
+ - `return` statements  que explicimente retornam o nada.
+ - Busca por propriedades não-existentes.
+ - Parâmetros de funções que não têm um valor explícito definido.
+ - Qualquer coisa que tenha sido definida como `undefined`.
+ - Qualquer expressão no formato `void(expressão)`
+
+### Manipulando mudanças no valor de `undefined`
+
+Uma vez que a variável global `undefined` apenas mantém uma cópia do valor *atual* de `undefined`, atribuir-lhe
+um novo valor **não** muda o valor do tipo `undefined`.
+
+Ainda, a fim de comparar alguma coisa com o valor de `undefined`, é necessário que
+primeiro se retorne o `undefined`.
+
+A fim de proteger o código contra uma possível sobrescrtia da variável `undefined`, uma
+técnica comum utilizada é a de adicionar um parâmetro adicional em um [wrapper anônimo](#function.scopes)
+ que não recebe argumentos.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // undefined no escopo local agora 
+        // refer-se ao valor `undefined`
+
+    })('Hello World', 42);
+
+Outra maneira de atingir o mesmo efeito seria utilizar uma declaração dentro do wrapper.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+A única diferença aqui é a que a última versão resulta na redução de 4 bytes, e não existe
+outro `var` statement dentro do wrapper anônimo.
+
+### Usos do `null`
+
+Enquanto que `undefined` no contexto da linguagem JavaScript é normalmente utilizado
+como um *null*, o atual `null` (ambos o tipo e o literal)  é mais ou menos um outro tipo de dado.
+
+Ele é utilizado internamente pelo JavaScript (como na declaração no fim da cadeia prototype
+ao definir `Foo.prototype = null`), porém na maioria dos casos, pode ser substituido por `undefined`.
+
+
diff --git a/doc/ptbr/function/arguments.md b/doc/ptbr/function/arguments.md
new file mode 100644
index 00000000..33c3214f
--- /dev/null
+++ b/doc/ptbr/function/arguments.md
@@ -0,0 +1,110 @@
+## O objeto `arguments`
+
+Todo escopo de uma função em JavaScript tem acesso à variável especial `arguments`.
+Esta variável armazena uma lista de todos os argumentos que foram passados para a função.
+
+> **Nota:** No caso em que `arguments` tenha sido definido dentro do escopo da função por meio 
+> de `var` statement ou que este seja o nome de um parâmetro formal, o objeto `arguments` não será criado.
+
+O objeto `arguments` **não** é um `Array`. Enquanto que ele possui uma semântica
+parecida com a de um array - a saber a propriedade `length` - ele não herda de `Array.prototype`
+e é de fato um `Object`.
+
+Devido a isto, **não** é possível usar os métodos padrões de array como `push`,
+`pop` ou `slice` no `arguments`. Enquanto que a iteração com um simples `for` loop funciona bem,
+é necessário convertê-lo para um `Array` a fim de usar os métodos padrões de `Array`.
+
+### Convertendo em um Array
+
+O código abaixo irá retornar um novo `Array` contendo todos os elementos do
+objeto  `arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Por este tipo de conversão ser **lenta**, seu uso em porções de código que apresentam performance crítica **não é recomendado**.
+
+### Passando argumentos
+
+O código abaixo é a maneira recomendada de se passar argumentos de uma função para outra.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // do stuff here
+    }
+
+Outro truque é o de usar ambos `call` e `apply` juntos para criar wrappers.
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Create an unbound version of "method" 
+    // It takes the parameters: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // Result: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### Parâmetros formais Formal Parameters and Arguments Indices
+
+O objeto `arguments` cria funções *getter* e *setter* para suas propriedades,
+bem como os parâmetros formais da função.
+
+Como resultado, alterando o valor de um parâmetro formal também mudará o valor
+da propriedade correspondente no objeto `arguments`, e vice versa.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Mitos e verdades sobre performance
+
+A única vez em que o objeto `arguments` não é criado é quando é declarado como um nome dentro de uma função 
+ou declarado como um de seus parâmetros formais. Não importa se ele é usado ou não.
+
+Ambos *getters* e *setters* são *sempre* criados; desta maneira, usá-los não causa impacto
+de performance, especialmente não em código do mundo real, onde existe mais de um simples
+acesso às  propriedades do objeto `arguments`.
+
+> **Nota ES5:** Estes *getters* e *setters* não são criados no strict mode.
+
+Entretando, existe um caso em que a performance é drasticamente reduzida
+em engines modernas de JavaScript. Este caso é o uso de `arguments.callee`
+
+    function foo() {
+        arguments.callee; // Faça alguma coisa com os objeto deta função
+        arguments.callee.caller; // e o calling do objeto da função
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Would normally be inlined...
+        }
+    }
+ 
+Isto não somente acaba com possíveis ganhos de performance que resultariam de inlining,
+mas também quebram o encapsulamento pois a função agora depende de uma chamada específica de contexto.
+
+O uso de `arguments.callee` é **fortemente desencorajado**.
+
+> **Nota ES5:** No strict mode, `arguments.callee` lança `TypeError` uma vez que 
+> se tornou obsoleto.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
+
diff --git a/doc/ptbr/function/closures.md b/doc/ptbr/function/closures.md
new file mode 100644
index 00000000..cdf8fd30
--- /dev/null
+++ b/doc/ptbr/function/closures.md
@@ -0,0 +1,83 @@
+## Closures e Referências
+
+Uma das caracterísricas mais poderosas do JavaScript é a possibilidade de usar *closures*. Quando usamos closures, definimos que um escopo **sempre** poderá acessar o escopo externo no qual foi definido. Uma vez que a única concepção de escopo em JavaScripe é [function scope](#function.scopes), todas as funções, por default, agem como closures.
+
+### Emulando variáveis privadas
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+Aqui, `Counter` retorna **duas** closures: a função 'increment' bem como a função 'get'. Ambas as funções mantêm uma **referência** ao escopo de 'Counter' e, portanto, sempre mantêm o acesso à variável 'count' definida naquele escopo.
+
+### Por que variáveis privadas funcionam
+
+Uma vez que não é possível referenciar ou atribuir escopos em JavaScript, **não** existe uma maneira de acessar a variável 'count' por fora. A única maneira de interagir com a variável é através das duas closures.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+O código acima **não** irá mudar a variável 'count' no escopo de 'Counter', uma vez que 'foo.hack' não foi definido **naquele** escopo. Neste caso, uma variável 'global' 'count' será criada ou substituida.
+
+### Closures dentro de laços
+
+Um erro comum é utilizar closures dentro de laços, como se elas copiassem o valor da variável de indexação do laço.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+O exemplo acima **não** retornará os números '0' até '9', mas os número '10' dez vezes.
+
+A função *anônima* mantêm uma **referência** para 'i'. No momento em que 'console.log' é chamado, 'o laço for' já encerrou a execução, e o valor '10' está atrbuído em 'i'.
+
+Com a finalidade de se obter o comportamento esperado, é necessário criar uma **cópia** do valor de 'i'.
+
+### Evitando problemas de referência
+
+Com a finalidade de copiar o valor da variável de indexação do laço, a melhor opção é utilizar um [wrapper anônimo](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+A função anônima será chamada imediatamente com 'i' como seu primeiro argumento e receberá uma cópia do **valor** de 'i' como parâmetro de 'e'. 
+
+A função anônima que é passada para o 'setTimeout' agora possui uma referência a 'e', cujo os valores **não** são modificados pelo laço.
+
+Não existe outra maneira de se obter este resultado, que não seja retornando uma função do wrapper anônimo que terá, então, o mesmo comportamento que o código acima. 
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+Há ainda uma outra maneira, usando .bind, que pode ligar argumentos e um  contexto'this' a uma função. Isto se comporta como o código acima
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
diff --git a/doc/ptbr/function/constructors.md b/doc/ptbr/function/constructors.md
new file mode 100644
index 00000000..26abfedf
--- /dev/null
+++ b/doc/ptbr/function/constructors.md
@@ -0,0 +1,115 @@
+## Construtores 
+
+Construtores em JavaScript ainda são diferentes de muitas outras linguagens.
+Qualquer chamada a uma função que seja precedida pela palavra-chave `new` age como um cosntrutor.
+
+Dentro do construtor - a função chamada - o valor de `this` se refere ao objeto recém criado.
+O [prototype](#object.prototype) deste **novo** objeto é definido como o `prototype` do objeto da função que foi
+invocada como construtor.
+
+Se a função chamada não possui um `return` statement explícito, então implicitamente
+retornará o valor de `this` - o novo objeto. 
+
+    function Foo() {
+        this.bla = 1;
+    }
+
+    Foo.prototype.test = function() {
+        console.log(this.bla);
+    };
+
+    var test = new Foo();
+
+O código acima chama `Foo` como construtor e define o `prototype` do objeto recém criado
+como `Foo.prototype`.
+
+No caso de um `return` statement explícito, a função retorna o valor
+especificado pelo statement, mas **somente** se o valor de retorno for um `Object`.
+
+    function Bar() {
+        return 2;
+    }
+    new Bar(); // um novo objeto
+
+    function Test() {
+        this.value = 2;
+
+        return {
+            foo: 1
+        };
+    }
+    new Test(); // o objeto retornado
+
+Quando a palavra-chave `new` é omitida, a função **não** retornará o novo objeto.
+
+    function Foo() {
+        this.bla = 1; // esta definida no escopo global do objeto
+    }
+    Foo(); // undefined
+
+Enquanto que o exemplo acima pareça funcionar em alguns casos,  devido 
+a maneira como [`this`](#function.this) funciona em JavaScript, o *objeto global*
+será usado como valor do `this`.
+
+### Fábricas
+
+A fim de omitir a palavra-chave `new`, o construtor da função deve retornar um valor explicitamente.
+
+    function Bar() {
+        var value = 1;
+        return {
+            method: function() {
+                return value;
+            }
+        }
+    }
+    Bar.prototype = {
+        foo: function() {}
+    };
+
+    new Bar();
+    Bar();
+
+Ambas as chamadas a `Bar` retornam a mesma coisa, um objeto recém criado
+que tem a propriedade chamada `method`, que é uma [Closure](#function.closures).
+
+Deve-se perceber que a chamada `new Bar()` **não** afeta o prototype do objeto retornado.
+Enquanto o prototype é definido no objeto recém criado, `Bar` nunca retornará um novo objeto.
+
+No exemplo acima, não existe diferença funcional entre o uso ou não de `new`.
+
+### Criando novos objetos por fábricas
+
+É recomendado **não** usar `new` pois eventual o esquecimento de seu uso
+pode levar à defeitos.
+
+A fim de criar um novo objeto, deve-se utilizar uma fábrica e construir o novo objeto dentro desta fábrica.
+
+    function Foo() {
+        var obj = {};
+        obj.value = 'blub';
+
+        var private = 2;
+        obj.someMethod = function(value) {
+            this.value = value;
+        }
+
+        obj.getPrivate = function() {
+            return private;
+        }
+        return obj;
+    }
+
+Enquanto que o código acima previne defeitos decorrentes do esquecimnto da palavra-chave `new`
+e certamente utiliza-se de [private variables](#function.closures) de forma mais fácil, este apresenta algumas desvantagens:
+
+ 1. Utiliza mais memória desde que os objetos criados **não** compartilham métodos em um prototype.
+ 2. A fim de implementar herença, a fábrica precisa copiar todos os métodos de um outro objeto ou colocar o outro objeto no prototype do novo objeto.
+ 3. Quebrar a cadeia prototype somente por causa de esquecer eventualmente o `new` vai contra o que é proposto pela linguagem.
+
+### Conclusão
+
+Enquanto que a omissão do `new` origine defeitos, **não** é certamente uma razão para
+quebrar a estrura prototype como um todo. No final, a melhor solução é sempre a que se adequa às necessidades de cada projeto.
+O importante é utilizar de forma **consistente** o modelo de criação de objetos escolhido.
+
diff --git a/doc/ptbr/function/general.md b/doc/ptbr/function/general.md
new file mode 100644
index 00000000..dc002e8f
--- /dev/null
+++ b/doc/ptbr/function/general.md
@@ -0,0 +1,46 @@
+## Declaração de funções e expressões
+
+Funções em JavaScript são objetos de primeira classe. Isto significa que elas
+podem ser tratadas como qualquer outro tipo. Um uso muito comum desta característica é
+o de passar uma *função anônima* como uma callback para outra, talvez uma função assíncrona.
+
+### A declaração `function`
+
+    function foo() {}
+
+A função acima sofrerá [hoisting](#function.scopes) antes que a execução do programa se inicie; assim,
+ela estará disponível em *todo* o escopo em que foi *definida*, até mesmo se for chamada antes de ter
+sido definida no código. 
+
+    foo(); // Funciona pois foo foi elevada para o topo do escopo
+    function foo() {}
+
+### A expressão `function`
+
+    var foo = function() {};
+
+Este exemplo atribui uma função sem nome e *anônima* à variável `foo`. 
+
+    foo; // 'undefined'
+    foo(); // dispara TypeError
+    var foo = function() {};
+
+Devido ao fato de que `var` é uma declaração que eleva a definição da variável `foo` ao topo do escopo, esta sofrerá hoist e `foo` estará declarado logo que o script for executado.
+
+Como atribuições só ocorrem em tempo de execução, o valor default de `foo` 
+será [undefined](#core.undefined) antes que o código seja executado.
+
+### Expressão de uma função nomeada
+
+Outro caso especial é a atribuição de funções nomeadas.
+
+    var foo = function bar() {
+        bar(); // Funciona
+    }
+    bar(); // ReferenceError
+
+Aqui, `bar` não está disponível fora do escopo, uma vez que a função se encontra atribuída 
+em `foo`; no entanto, dentro de `bar`, ela esta disponível. Isto ocorre devido ao fato de 
+como o [name resolution](#function.scopes) funciona em JavaScript, o nome da função está *sempre*
+disponível no escopo local da própria função.
+
diff --git a/doc/ptbr/function/scopes.md b/doc/ptbr/function/scopes.md
new file mode 100644
index 00000000..0bcd99d6
--- /dev/null
+++ b/doc/ptbr/function/scopes.md
@@ -0,0 +1,225 @@
+## Escopos e Namespaces
+
+Embora o JavaScript lide bem com a sintaxe de duas chaves para definir blocos, ele **não** oferece suporte a escopos em blocos; por isso,
+todo o restante da linguagem é definido em *escopo de função*.
+
+    function test() { // define escopo
+        for(var i = 0; i < 10; i++) { // não define escopo
+            // count
+        }
+        console.log(i); // 10
+    }
+
+> **Nota:** Quando não usado em um assignment, em um statement return ou como um argumento de função,
+>  a notação `{...}` será interpretada como um block statement e **não** como um objeto literal. 
+> Isto, em conjunto com a [inserção automática de ponto-e-vírgula](#core.semicolon), pode levar à erros sutis.
+
+Também não existem namespaces distintos em JavaScript, o que significa que tudo é
+automaticamente definido em um namespace *globalmente compartilhado*.
+
+Cada vez que uma variável é referenciada, o JavaScript vai percorrer toda a hierarquia 
+de escopos até encontrá-la. Caso ele alcance o escopo global e ainda não tenha encontrado
+a variável, ele lançará um `ReferenceError`.
+
+### A queda das variáveis globais
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+O dois scripts acima **não** têm o mesmo efeito. O Script A define uma
+variável chamada `foo` no escopo *global*, e o Script B define `foo` no
+escopo *atual*.
+
+Novamente, isto **não** é *mesma coisa*:  emitir o uso de `var` tem várias implicações.
+
+    // escopo global
+    var foo = 42;
+    function test() {
+        // escopo local
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+Deixando o statement `var` de fora da função `test` faz com que o valor de `test` seja sobrescrito.
+Enquanto que à primeira vista isto não pareça um problema, um script com milhares de linhas de código
+que não utiliza `var` apresenta erros horríveis e bugs difíceis de serem detectados.
+    
+    // escopo global
+    var items = [/* uma lista qualquer */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // escopo de subLoop
+        for(i = 0; i < 10; i++) { // esquecendo do var statement
+            // faça algo incrível!
+        }
+    }
+    
+O loop externo terminará depois da primeira chamada para `subLoop`, uma vez que `subLoop`
+sobrescreve o valor global  `i`. Utilizar `var` no segundo `for` loop evitaria facilmente este problema.
+O `var` statement **nunca** pode ser esquecido a não ser que o *efeito desejado* seja afetar o escopo externo.
+
+### Variáveis locais
+
+A única fonte de variáveis locais em JavaScript são parâmetros de [função](#function.general)
+e variáveis declaradas via `var` statement.
+
+    // escopo global
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // escopo local da função test
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+Enquanto que  `foo` e `i` são variáveis locais dentro do escopo da função `test`,
+a atribuição de `bar` irá substituir a variável global com o mesmo nome.
+
+### Hoisting
+
+Javascript **eleva** declarações. Isto quer dizer que ambas declarações `var`
+e `function`  serão movidas para o topo do escopo ao qual pertencem.
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+O código acima é modificado antes mesmo que seja executado. O JavaScript move
+ todos as declarações `var` assim como as de `function`, para o topo
+do escopo mais próximo.
+
+    // declarações var são movidas aqui
+    var bar, someValue; // default para 'undefined'
+
+    // as declarações de função também são movidas
+    function test(data) {
+        var goo, i, e; // escopo de bloco ausente move essas variáveis p/ cá
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // falha com um TypeError uma vez que bar continua 'undefined'
+    someValue = 42; // atribuições não são afetadas pelo hoisting
+    bar = function() {};
+
+    test();
+
+A falta de delimitação de um escopo não somente moverá `var` statements para fora de loops
+ e seus blocos, isto também fará com que os testes de determinados `if` se tornem não-intuitivos.
+
+ No código original, embora o `if` statement pareça modificar a *variável global*
+ `goo`, ele modifica a *variável local* - depois que hoisting foi aplicado.
+
+Por desconhecer o *hoisting*, pode-se suspeitar que o código abaixo lançaria um 
+`ReferenceError`.
+
+    // verifique se SomeImportantThing já foi inicializado
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+Mas é claro, isto funciona devido ao fato de que `var` statement é movido para o topo
+do *escopo global*.
+
+    var SomeImportantThing;
+
+    // outro código pode inicializar SomeImportantThing aqui, ou não
+
+    // tenha certeza de que isto foi inicializado
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### Ordem da Resolução de Nomes
+
+Todos os escopos em JavaScript, incluindo o *escopo global*, possuem o [`this`](#function.this)
+ o qual faz referência ao *objeto atual*. 
+
+Escopos de funções também possuem o [`arguments`](#function.arguments), o qual contêm
+os argumentos que foram passados para a função.
+
+Por exemplo, ao tentar acessar a variável denominada `foo` dentro do escopo de uma função, JavaScript irá
+procurar pela variável na seguinte ordem:
+
+ 1. No caso de haver `var foo` statement no escopo atual, use-a.
+ 2. Se um dos parâmetros é denominado `foo`, use-o.
+ 3. Se a própria função é denominada `foo`, use-a.
+ 4. Vá para o escopo externo mais próximo e inicie do **#1**.
+
+> **Nota:** Dispor de um parâmetro denominado `arguments` irá **previnir** a criação 
+> do objeto default `arguments`.
+
+### Namespaces
+
+Um problema comum relacionado ao fato de dispor de apenas um namespace global é 
+a probabilidade de esbarrar com problemas onde nomes de variáveis coincidem. Em JavaScript,
+este problema pode ser facilmente evitado com a ajuda de *wrappers anônimos*.
+
+    (function() {
+        // um "namespace" autocontido
+        
+        window.foo = function() {
+            // closure exposta
+        };
+
+    })(); // execute a função imediatamente
+
+
+Funções sem nome são consideradas [expressões](#function.general); a fim de ser referênciável,
+elas devem ser avaliadas.
+
+    ( // avalie a função dentro dos parênteses
+    function() {}
+    ) // e retorne o objeto de função
+    () // chama o resultado da avaliação
+
+Existem outras maneiras para avaliar e chamar diretamente a expressão da função a qual,
+enquanto que diferentes em sintaxe, comportam-se da mesma maneira.
+
+	// Alguns outros estilos para invocar diretamente ...
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // e assim por diante...
+
+### Conclusão
+
+É recomendado sempre utilizar um *wrapper anônimo* para encapsular código em seu
+próprio namespace. Isto não é somente uma maneira de se proteger contra conflitos de nomes,
+como também contribui para melhor modularização de programas.
+
+Adicionalmente, o uso de variáveis globais é considerado **uma prática ruim**. **Qualquer**
+uso delas indica código mal escrito que tende à apresentar erros e apresenta manutenção complexa.
+
diff --git a/doc/ptbr/function/this.md b/doc/ptbr/function/this.md
new file mode 100644
index 00000000..daacb9a9
--- /dev/null
+++ b/doc/ptbr/function/this.md
@@ -0,0 +1,108 @@
+## Como funciona o `this`
+
+JavaScript tem uma concepção diferente sobre a que a palavra reservada `this` se refere da maioria das outras linguagens de programação. Existem exatamente **cinco** diferentes maneiras as quais os valores de `this` podem ser referenciados na linguagem.
+
+### O escopo Global
+
+    this;
+
+Quando usando `this` no escopo global, ele simplesmente estará apontando para o objeto *global*.
+
+
+### Chamando uma função
+
+    foo();
+
+Aqui, `this` irá referenciar novamente o objeto *global*.
+
+> **Nota ES5:** No strict mode, global **não existe**.
+> neste caso, `this` receberá como valor `undefined`.
+
+### Chamando um método
+
+    test.foo(); 
+
+Neste exemplo, `this` irá referenciar `test`.
+
+### Chamando um construtor
+
+    new foo(); 
+
+Uma chamada de função que é precedida pela palavra chave `new` age como
+um [construtor](#function.constructors). Dentro da função, `this` irá se referir
+a um objeto *recém criado*.
+
+### Referência explícita do `this`
+
+    function foo(a, b, c) {}
+                          
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // array will expand to the below
+    foo.call(bar, 1, 2, 3); // results in a = 1, b = 2, c = 3
+
+Quando utiliza-se os métodos `call` ou `apply` de `Function.prototype`, o valor de
+`this` dentro da função chamada irá referenciar **explicitamente** o primeiro argumento
+correspondente na chamada da função.
+
+Como resultado, no exemplo anterior o *escopo original do método* **não** é aplicado, e `this`
+dentro de `foo` irá referenciar `bar`.
+
+> **Nota:** `this` **não** pode ser utilizado para referenciar o objeto dentro de um `Object` lietral.
+> Logo `var obj = {me: this}` **não** irá resultar em `me` apontando para 
+> `obj`, uma vez que `this` só pode ser referenciado em dos cinco casos aqui apresentados.
+
+### Erros comuns
+
+Embora a maioria destes casos façam sentido,  o primeiro pode ser considerado
+como um engano de concepção da linguagem, já que **nunca** se mostrou útil.
+
+    Foo.method = function() {
+        function test() {
+            // this referencia o objeto global
+        }
+        test();
+    };
+
+Um erro comum é achar que `this` dentro de `test` referencia `Foo`; enquanto que, na realidade
+ **não é isto que acontece**.
+
+Com a finalidade de acessar `Foo` de dentro de `test`, é necessário instanciar
+uma variável global dentro do método para se referir à `Foo`.
+
+    Foo.method = function() {
+        var that = this;
+        function test() {
+            // Utilize that no lugar de this aqui
+        }
+        test();
+    };
+
+`that` trata-se de uma variável normal, porém é normalmente utilizada para referências externas de `this`.
+Quando combinadas com [closures](#function.closures), também podem ser utilizadas para repassar `this` como valor.
+
+### Atribuindo métodos
+
+Outra coisa que **não** funciona em JavaScript é function aliasing, ou seja, 
+**atribuir** um método a uma variável.
+
+    var test = someObject.methodTest;
+    test();
+
+Devido ao primeiro caso, `test` se comportará como uma chamada de função; como consequencia,
+o `this` dentro do método não apontará para `someObject`.
+
+Enquanto que realizar binding do `this` pareça uma idéia ruim, no fundo, é o que faz a
+[herança prototypal](#object.prototype) funcionar.
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+Quando os métodos da instância de `Bar` são chamados, o `this` faz referência
+àquela mesma instância. 
+
+
diff --git a/doc/ptbr/index.json b/doc/ptbr/index.json
new file mode 100644
index 00000000..e7b22d3f
--- /dev/null
+++ b/doc/ptbr/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden em Português",
+    "description": "Um guia pelas vantagens e desvantagens do JavaScript.",
+    "sections": [
+        {
+            "title": "Introdução",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "Objetos",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Funções",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Arrays",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Tipos",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Core",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "Outros assuntos",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/ptbr/intro/index.md b/doc/ptbr/intro/index.md
new file mode 100644
index 00000000..ecba225b
--- /dev/null
+++ b/doc/ptbr/intro/index.md
@@ -0,0 +1,38 @@
+## Introdução
+
+**JavaScript Garden** é uma coletânea crescente que documenta as peculiaridades da linguagem de programação JavaScript. Nela você encontra recomendações para escapar dos erros comuns aos mais sutís, bem como de problemas de desempenho e práticas ruins, que programadores novatos podem acabar encontrando enquanto se aprofundam na linguagem.
+
+JavaScript Garden **não** tem como propósito te ensinar à programar em JavaScript. Conhecimento prévio da linguagem é fortemente recomendado para que você entenda o conteúdo dos tópicos abordados neste guia. A fim de aprender as noções básicas da linguagem, por favor, consulte o excelente [guia][1] disponível na Mozilla Developer Network.
+
+## Os autores
+
+Este guia é fruto do trabalho de dois excelentes usuários do [Stack Overflow][2], [Ivo Wetzel][3]
+(Conteúdo) e [Zhang Yi Jiang][4] (Design).
+
+É mantido atualmente por [Tim Ruffles](http://truffles.me.uk).
+
+## Contribuidores
+
+- São muitos para serem listados, [veja a lista completa clicando aqui](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors).
+
+
+## Hospedagem
+
+JavaScript Garden está hospedado no GitHub, porém [Cramer Development][7] nos apoia com um espelho em [JavaScriptGarden.info][8].
+
+## Licença
+
+JavaScript Garden está publicado sob a [licença MIT][9] e hospedado no [GitHub][10]. Caso você encontre defeitos ou erros de digitação, por favor [registre o problema][11] ou realize um pull request no repositório. Você também pode nos encontrar na [sala de JavaScript][12] no chat do Stack Overflow.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/ptbr/object/forinloop.md b/doc/ptbr/object/forinloop.md
new file mode 100644
index 00000000..e3e09efa
--- /dev/null
+++ b/doc/ptbr/object/forinloop.md
@@ -0,0 +1,41 @@
+## O laço `for in`
+
+Assim como o operador `in`, o laço `for in` percorre a cadeia prototype quando interage sobre as propriedades de um objeto.
+
+> **Nota:** O laço `for in` **não** interage sobre propriedades que 
+> que tenham o atributo `enumerable` configurado como `false`; por exemplo, a propriedade `length` de um array. 
+    
+    // Poluindo o Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // retorna ambos bar e moo
+    }
+
+Uma vez que não é possível alterar o comportamento do laço `for in` por si só, faz-se necessário filtrar as propriedades do objeto durante o ciclo de repetição do laço; isso é feito usando o método [`hasOwnProperty`](#object.hasownproperty) do `Object.prototype`.
+
+> **Nota:** Uma vez que o `for in` percorre toda a cadeia prototype, 
+> cada camada a mais na herança do objeto deixa a execução do laço mais lenta.
+
+### Utilizando `hasOwnProperty` como filtro
+
+    // o mesmo foo utilizado anteriormente
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+Esta é única forma correta de usar. Devido ao uso de `hasOwnProperty`, o exemplo **só** irá retornar `moo`. Quando `hasOwnProperty` é deixado de lado, o código fica propenso a erros nos casos em que o prototype - por exemplo `Object.prototype`- tenha sido estendido.
+
+Um framework largamente utilizado que estende o `Object.prototype` é [Prototype][1].
+Quando este framework é utilizado, laços `for in` que não utilizam 
+`hasOwnProperty` ficam desprotegidos contra erros.
+
+### Conclusão
+
+Recomenda-se utilizar `hasOwnProperty` **sempre**. Nunca faça pressuposições sobre o ambiente em que o código está sendo executado, ou se os prototypes nativos foram estendidos ou não.
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/ptbr/object/general.md b/doc/ptbr/object/general.md
new file mode 100644
index 00000000..12452e7f
--- /dev/null
+++ b/doc/ptbr/object/general.md
@@ -0,0 +1,83 @@
+## Propriedades e manipulação de objetos
+
+Tudo em JavaScript se comporta como um objeto, com apenas duas exceções que são 
+[`null`](#core.undefined) e [`undefined`](#core.undefined).
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Um equívoco muito comum é a idéia de que números não podem ser manipulados como objetos. O parser do JavaScript analisa a *notação de ponto* como ponto flutuante de um número.
+
+    2.toString(); // raises SyntaxError
+
+Existem três soluções para contornar este problema e permtir que números se comportem como objetos.
+
+    2..toString(); // o segundo ponto é reconhecido corretamente
+    2 .toString(); // perceba o espaço deixado à esquerda do ponto
+    (2).toString(); // 2 é interpretado primeiro
+
+### Objetos como tipo de dados
+
+Em JavaScript, Objetos podem também ser utilizados como [*Hashmaps*][1]; eles consistem principalmente de propriedades nomeadas, que apontam para valores.
+
+Usando um objeto literal  - notação do tipo `{}`- é possível criar um objeto simples. Este novo objeto [herda](#object.prototype) de `Object.prototype` e não possui [propriedades próprias](#object.hasownproperty) definidas.
+
+    var foo = {}; // um novo objeto vazio
+
+    // um novo objeto com uma propriedade 'test' populada com o valor 12
+    var bar = {test: 12}; 
+
+### Acessando propriedades
+
+As propriedades de um objeto podem ser acessadas de duas maneiras, através da notação de ponto ou da notação de colchete.
+    
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+    
+    var get = 'name';
+    foo[get]; // kitten
+    
+    foo.1234; // Erro de sintaxe
+    foo['1234']; // funciona
+
+Ambas as notações trabalham de forma quase idêntica, com a única diferença de que o colchete permite configuração dinâmica de propriedades e uso de propriedades nomeadas que de outra maneira levaria à erros de sintaxe.
+
+### Removendo propriedades
+
+A única maneira de remover uma propriedade de um objeto é através do operador `delete`; definir uma propriedade como `undefined` ou `null` somente apaga o valor associado com tal propriedade, mas não remove a *key*.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+O código acima retorna tanto `bar undefined` quanto`foo null` - somente `baz` foi removido e, portanto, não saiu no output.
+
+### Notações de Keys
+
+    var test = {
+        'case': 'I am a keyword, so I must be notated as a string',
+        delete: 'I am a keyword, so me too' // dispara SyntaxError
+    };
+
+Propriedades de objetos podem ser tanto representadas como caracteres simples bem como strings. Devido a outro engano do parser do JavaScript, o exemplo acima irá retornar `SyntaxError` remetendo ao ECMAScript 5.
+
+Este erro decorre do fato de que 'apagar' é uma *palavra reservada*; por consequencia, deve ser representada como uma *string literal* a fim de garantir a interpretação correta pelas antigas engines de JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/ptbr/object/hasownproperty.md b/doc/ptbr/object/hasownproperty.md
new file mode 100644
index 00000000..858e052c
--- /dev/null
+++ b/doc/ptbr/object/hasownproperty.md
@@ -0,0 +1,56 @@
+## `hasOwnProperty`
+
+Para verificar se uma propriedade está definida no **próprio** objeto e não em outro lugar 
+da sua [cadeia prototype](#object.prototype), é necessário utilizar o método
+`hasOwnProperty` o qual todos os objetos herdam de `Object.prototype`.
+
+> **Nota:** **Não** é sufuciente verificar se uma propriedade é `undefined`.
+> A propriedade pode muito bem existir, porém acontece de seu valor só ser
+> `undefined`.
+
+`hasOwnProperty` é a única coisa em JavaScript a qual lida com propriedades e **não** percorre a cadeia prototype.
+
+    // Poluindo Object.prototype
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+Somente `hasOwnProperty` irá retornar o resultado correto e esperado; isto é
+essencial quando se interage sobre propriedades de qualquer objeto. **Não** existe
+outra maneira de verificar propriedades que não estejam definidas no próprio objeto, mas
+em outro lugar na cadeia prototype.
+
+### `hasOwnProperty` como propriedade
+
+JavaScript não protege o nome da propriedade `hasOwnProperty`; assim, se
+existe a possibilidade de algum objeto possuir uma propriedade com este mesmo nome,
+torna-se necessário utilizar um `hasOwnProperty` **externo** a fim de obter resultados corretos.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // sempre retorna false
+
+    // Utiliza hasOwnProperty de outro objeto e o instancia com 'this' apontado para foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+    // Também é possível utilizar hasOwnProperty do Object
+    // prototype para este fim
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+
+
+### Conclusão
+
+O método `hasOwnProperty` é a **única** maneira confiável para verificar a existência da propriedade em um objeto.
+É recomendado que `hasOwnProperty` seja utilizado em **cada** interação de um [laço `for in`](#object.forinloop)
+a fim de evitar erros de extensão do [prototype](#object.prototype).
+
diff --git a/doc/ptbr/object/prototype.md b/doc/ptbr/object/prototype.md
new file mode 100644
index 00000000..c9411640
--- /dev/null
+++ b/doc/ptbr/object/prototype.md
@@ -0,0 +1,109 @@
+## Prototype
+
+JavaScript  não dispõe de nenhum modelo clássico de herança; em vez disso, ele
+faz uso do modelo *prototypal*.
+
+Enquanto isto é considerado muitas vezes como sendo um dos pontos fracos do JavaScript, o modelo de herança prototypal é de fato muito mais poderoso do que o modelo clássico.
+Por exemplo, isto torna relativamente trivial construir um modelo clássico
+com base no modelo prototypal, enquanto que o contrário se verifica como uma tarefa mais difícil.
+
+JavaScript é a única linguagem amplamente utilizada que apresenta um modelo de herança do tipo prototypal,
+por isso pode levar algum tempo até que você se ajuste às diferenças entre os dois modelos.
+
+A primeira grande diferença é que herança em JavaScript utiliza o conceito de *cadeias prototype*.
+
+> **Nota:** Usando simplesmente `Bar.prototype = Foo.prototype` resultará em ambos os objetos
+> compartilhando **o mesmo** prototype. Portanto, as alterações no prototype de um dos objetos
+> também irá afetar o prototype do outro, o que na maioria dos casos não é o esperado.
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // Apontar Bar's prototype para uma nava instância de Foo
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // Tenha certeza de que Bar é o construtor atual
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar(); // criar uma nova instância de bar
+
+    // A cadeia prototype resultante
+    test [instance of Bar]
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* etc. */ }
+
+No código acima, o objeto `test` irá herdar de ambos `Bar.prototype` e
+`Foo.prototype`; portanto, ele terá acesso à função `method` que foi definida em Foo.
+Ele também terá acesso à propriedade `value` da **única** instância de Foo que é seu próprio prototype.
+É importante perceber que `new Bar()` não cria uma nova instância de `Foo`, mas
+reutiliza aquela associada ao prototype; assim, todas as intâncias `Bar` dividirão a
+**mesma** propriedade `value`.
+
+> **Nota:** **Não** utilize `Bar.prototype = Foo`, uma vez que isto não aponta para o prototype de `Foo`, mas sim para o objeto função `Foo`.
+> Assim a cadeia prototype irá percorrer `Function.prototype` e não `Foo.prototype`;
+> desse modo, `method` não estará na cadeia prototype.
+
+### Buscando propriedades
+
+Ao acessar as propriedades de um objeto, JavaScript irá percorre a cadeia prototype
+**até o topo** para encontrar a propriedade solicitada.
+
+Caso atinja o topo da cadeia - denominada `Object.prototype` - e não encontre
+a propriedade especificada, o valor [undefined](#core.undefined) será retornado.
+
+### A propriedade Prototype
+
+Enquanto a propriedade prototype é utilizada pela linguagem na contrução de cadeia de prototype,
+ainda é possível associar **qualquer** valor dado a ele. No entanto, tipos primitivos serão
+ignorados quando associados como prototype.
+
+    function Foo() {}
+    Foo.prototype = 1; // sem efeito
+
+Atribuindo objetos, como demonstrado no exemplo anterior, irá funcionar, e permite
+a criação dinâmica de cadeias prototype.
+
+### Performance
+
+O tempo de pesquisa por propriedades que estão no topo da cadeia prototype
+pode ter um impacto negativo na performance, principalmente em código
+onde a performance é um fator crítico. Além disso, a busca por propriedades que não existem
+também atravessa a cadeia prototype.
+
+Além disso, ao [interagir](#object.forinloop) com propriedades de um objeto
+**cada** propriedade na cadeia prototype será enumerada.
+
+### Estendendo Prototypes nativos
+
+Uma prática ruim que é normalmente utilizada é a de estender `Object.prototype` ou qualquer outro prototype construído.
+
+Esta técnica é denominada [monkey patching][1] e quebra o *encapsulamento*.
+Mesmo utilizada por frameworks populars como [Prototype][2], não existe mais razão
+para poluir tipos built-in com funcionalidades adicionais *fora de padrão*.
+
+A **única** boa razão existente para continuar estendendo um  built-in prototype
+é a de assegurar as novas funcionalidade de engines JavaScript modernas; por exemplo, [`Array.forEach`][3].
+
+### Conclusão
+
+É **essencial** entender o modelo de herança prototypal antes de escrever código complexo
+que faço uso do mesmo. Além disso, tome cuidado com o tamanho da cadeia prototype em seu código
+e a refatore caso necessário a fim de evitar futuros problemas de performance. A respeito do prototypes nativos,
+estes **nunca** devem ser estendidos ao menos que seja para manter a compatibilidade com novas
+características do JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+
diff --git a/doc/ptbr/other/timeouts.md b/doc/ptbr/other/timeouts.md
new file mode 100644
index 00000000..74ec2081
--- /dev/null
+++ b/doc/ptbr/other/timeouts.md
@@ -0,0 +1,161 @@
+### `setTimeout` e `setInterval`
+
+Uma vez que JavaScript é assíncrono, é possível agendar a execução de uma função
+usando as funções `setTimeout` e `setInterval`.
+
+> **Nota:** Timeouts **não** fazem parte do Padrão ECMAScript. Eles são
+> implementados como parte do [DOM][1].
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // retorna um Number > 0
+
+Quando `setTimeout` é chamado, ele retorna o ID do timeout e agenda a execução de `foo`
+para **aproximadamente** mil milissegundos no futuro.
+`foo` será executado uma **única** vez.
+
+Dependendo de como a engine JavaScript que está rodando o código resolve o timer, bem como
+o fato de que o JavaScript é single threaded e outro código que é executado pode bloquear a 
+thread, **não há como** garantir a precisão dos intervalos especificados nas chamadas `setTimeout`.
+
+A função que foi passada como primeiro parâmetro será chamada pelo *objeto global*, o que 
+significa que o [`this`](#function.this) dentro da função chamada se refere ao objeto global.
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // this faz referência ao objeto global
+            console.log(this.value); // log undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+
+> **Nota:** Como o `setTimeout` espera um **objeto de função** para primeiro parâmetro, um
+> erro comum é usar `setTimeout(foo(), 1000)`, que irá usar o 
+> **o valor retornado** por `foo` e **não** `foo`. Isto é, na maioria das vezes,  
+> um erro silencioso, visto que neste caso a função retorna `undefined`, logo `setTimeout` **não**
+> lançará erro algum.
+
+### Acumulando chamadas com o `setInterval`
+
+Enquanto que `setTimeout` somente executa a função uma vez, `setInterval` -  como
+o nome sugere -  irá executar a função a **cada** `X` milisegundos, porém seu uso é
+desencorajado.
+
+Quando um código em execução bloqueia a chamada do timeout, `setInterval` continuará
+emitindo chamadas para a função em questão. Isto pode, especialmente com intervalos curtos,
+resultar em uma pilha de chamadas de função.
+
+    function foo(){
+        // algo que bloqueie por 1 segundo
+    }
+    setInterval(foo, 1000);
+
+No código acima, `foo` será chamada uma vez e irá então bloquear a execução por um segundo.
+
+Enquanto `foo` bloqueia a execução, `setInterval` irá programar mais chamadas para ela.
+Em seguida, quando `foo` completar sua execução, existirão **dez** chamadas programadas
+para ela aguardando por execução.
+
+### Lidando com possíveis bloqueios de código
+
+A solução mais fácil, bem como a mais controlável, é usar `setTimeout` dentro da 
+própria função.
+
+    function foo(){
+        // Algo que bloqueia por um segundo
+        setTimeout(foo, 1000);
+    }
+    foo();
+
+Isto não somente encapsula a chamada para `setTimeout`, mas também previne
+o acumulo de chamadas e dá controle adicional. `foo` por si só pode decidir
+quando rodar novamente ou não.
+
+### Limpando Timeouts manualmente
+
+A limpeza de intervalos e timeouts funciona passando o respectivo ID 
+para `clearTimeout` ou `clearInterval`, dependendo onde a função `set` foi usada primeiro.
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### Limpando todos os Timeouts
+
+Como não existe métodos próprios para limpar todos os timeouts e/ou intervalos,
+é necessário usar a força bruta para chegar a esta funcionalidade.
+
+    // limpe "todos" os timeouts
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+Mas ainda podem haver timeouts que não serão afetados por este número arbitrário.
+Uma outra maneira de fazer isto é considerar que o ID dado a um timeout é
+incrementado um a um cada vez que você chama `setTimeout`.
+
+    // limpe "todos" os timeouts
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+Apesar desta maneira funcionar nos principais navegadores hoje em dia, não está especificado
+que os IDs respeitem uma ordem como este, logo esta ordem pode ser variada. Por este motivo, em vez disso
+é recomendade manter o controle de todos os IDs de timeouts, de forma que possam ser apagados precisamente.
+
+### O uso oculto do `eval`
+
+`setTimeout` e `setInterval` aceitam uma string como primeiro argumento.
+Esta funcionalidade **nunca** deve ser utilizada pois internamente faz uso de `eval`.
+
+> **Nota:** Uma vez que funções timeout **não** são especificadas pelo padrão ECMAScript, a maneira como 
+> eles interpretam uma string passada pode variar de acordo com a implementação do JavaScript. Por exemplo, JScript
+> da Microsoft faz uso do construtor `Function` no lugar do `eval`.
+
+    function foo() {
+        // será chamada
+    }
+
+    function bar() {
+        function foo() {
+            // nunca será chamada
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+Uma vez que `eval` não é chamado [diretamente](#core.eval) neste caso, a string
+passada como argumento para `setTimeout` será executada no *escopo global*; assim, ela
+não usará a variável local `foo` do escopo de `bar`.
+
+Também é recomendado **não** usar uma string para passar argumentos
+para a função que será chamada por qualquer uma das funções de timeout.
+
+    function foo(a, b, c) {}
+    
+    // NUNCA use isto
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // Utilize uma função anônima do lugar
+    setTimeout(function() {
+        foo(a, b, c);
+    }, 1000)
+
+> **Nota:** Enquanto que é possivel utilizar a sintaxe 
+> `setTimeout(foo, 1000, a, b, c)`, não é recomendada, pois sua utilização pode levar
+> a erros sútis quando utilizadas com [métodos](#function.this). 
+
+### Conclusão
+
+Uma string **nunca** deve ser usada como parâmetro `setTimeout` ou 
+`setInterval`. Esta prática é um sinal **claro** de código ruim, quando argumentos precisam ser fornecido para a função que é chamada.
+Uma *função anônima* é que deve ser passada para que, em seguida, cuide da chamada.
+
+Além disso, o uso de `setInterval` deve ser evitado pois seu scheduler não é
+bloqueado pela execução do JavaScript.
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
+
diff --git a/doc/ptbr/types/casting.md b/doc/ptbr/types/casting.md
new file mode 100644
index 00000000..d7dc9b3f
--- /dev/null
+++ b/doc/ptbr/types/casting.md
@@ -0,0 +1,67 @@
+## Conversão de tipos
+
+JavaScript é *fracamente tipado*, logo ele aplica a *coerção de tipos*
+**sempre** que possível.
+
+    // Estes retornam true
+    new Number(10) == 10; // Number.toString() é convertido
+                          // de volta a um número
+
+    10 == '10';           // Strings são convertidas em Number
+    10 == '+10 ';         // Mais loucuras com strings
+    10 == '010';          // E mais 
+    isNaN(null) == false; // null é convertido em 0
+                          // que claro não é NaN
+    
+    // Estes retornam false
+    10 == 010;
+    10 == '-10';
+
+> **Nota ES5:** Literais Number que começam com um `0` são interpretados como octais
+> (Base 8). Suporte à octais para estes literais foi **removido** no modo estrito do ECMAScript.
+
+A fim de evitar os problemas acima, o uso do [operador de igualdade estrito](#types.equality) 
+é **fortemente** recomendado. Embora ele evite uma série de problemas comuns,
+existem ainda muitas outras questões que surgem do fraco sistema de tipagem do JavaScript.
+
+### Construtores de tipos nativos
+
+Os construtores de tipos nativos como `Number` e `String` comportam-se
+diferentemente quando utilizados com ou sem a palavra-chave `new`.
+
+    new Number(10) === 10;     // False, Object e Number
+    Number(10) === 10;         // True, Number e Number
+    new Number(10) + 0 === 10; // True, devido à conversão implícita
+
+Utilizar um tipo nativo como `Number` como construtor iré criar um novo objeto `Number`,
+porém omitir a palavra-chave `new` fará com que a função `Number` se comporte como
+um conversor.
+
+Além, passando valores literais ou não-objetos irá resultar em mais coerções
+de tipos.
+
+A melhor opção é converter para um dos três possíveis tipos **de forma explícita**.
+
+### Convertendo para String
+
+    '' + 10 === '10'; // true
+
+Prefixando uma string vazia, qualquer valor pode ser facilmente convertido em uma string.
+
+### Convertendo para Number
+
+    +'10' === 10; // true
+
+Ao utilizar o operador de soma **unário**, é possível converter um valor para Number.
+
+### Convertendo para Boolean
+
+Ao utilizar duas vezes o operador **not**, é possível converter um valor para Boolean.
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
\ No newline at end of file
diff --git a/doc/ptbr/types/equality.md b/doc/ptbr/types/equality.md
new file mode 100644
index 00000000..709b1186
--- /dev/null
+++ b/doc/ptbr/types/equality.md
@@ -0,0 +1,70 @@
+## Igualdades e comparações
+
+JavaScript tem duas maneiras diferentes de comparar a igualdades entre valores de objetos.
+
+### O operador de igualdade
+
+O operador de igualdade consiste de dois sinais de igual : `==`
+
+JavaScript é *fracamente tipado*. Isto que dizer que o operador de igualdade
+**induz** tipos ao invés de compará-los.
+    
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+A tabela acima mostra o resultado da coerção de tipos, e isto é principal razão
+para que o uso `==` seja amplamente considerado uma má prática. Seu uso introduz defeitos
+difíceis de serem rastreados devido às suas complicadas regras de conversão.
+
+Adicionalmente, também existe um impacto em performance quando a coerção acontece;
+por exemplo, é necessário que uma string seja convertida em um número antes que seja comparada
+com outro número.
+
+### O operador de igualdade estrito
+
+O operador de igualdade estrito consiste de **três** sinais de igual : `===`.
+
+Ele funciona como o operador de igualdade normal, salvo que o operador de igualdade estrito
+**não** realiza coerção de tipos entre seus operandos.
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+Os resultados acima são bastante claros e permitem uma análise objetiva do código. Pode parecer complicar o código até um certo ponto
+ mas também traz ganhos de performance em casos em que os operandos são de tipos diferentes.
+
+### Comparando Objetos
+
+Enquanto que ambos `==` e `===` são denominados operadores de **igualdade**, eles se comportam de 
+formas diferentes quando pelo menos um de seus operandos é um `Object`.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+Aqui, ambos os operadores comparam em função da **identidade** e **não** da igualdade; isto é,
+eles vão comparar em função da mesma **instância** do objeto, muito parecido com o `is` do Python
+e a comparação de ponteiros em C.
+
+### Conclusão
+
+E fortemente recomendado que só se use o operador de ** igualdade estrito**.
+Em casos onde a coerção de tipos seja necessária, isto deve ser feito [explicitamente](#types.casting) 
+e não deve ser deixado para as complicadas regras de coerção da linguagem.
+
diff --git a/doc/ptbr/types/instanceof.md b/doc/ptbr/types/instanceof.md
new file mode 100644
index 00000000..9cbd7561
--- /dev/null
+++ b/doc/ptbr/types/instanceof.md
@@ -0,0 +1,38 @@
+## O operador `instanceof`
+
+O operador `instanceof` compara os construtores de seus dois operandos.
+Ele é útil somente quando estamos comparando objetos personalizados. Quando utilizado em tipos nativos,
+ele é tão inútil quanto [o operador typeof](#types.typeof).
+
+### Comparando objetos personalizados
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // Isto somente define Bar.prototype ao objeto de função Foo,
+    // mas não à instância atual de Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### Utilizando `instanceof` com tipos nativos
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+Uma coisa importante para perceber aqui é que `instanceof` não funciona em objetos
+originados de diferentes contextos de JavaScript (isto é, de diferentes documentos em um
+navegador web), uma vez que seus construtores não irão representar exatamente o mesmo objeto.
+
+### Conclusão
+
+O operador `instanceof` deve **somente** ser utilizado quando estive lidando
+com objetos customizados originados de um mesmo contexto JavaScript. Bem como o operador
+[`typeof`](#types.typeof), qualquer outro uso de `instanceof` deve ser **evitado**.
+
diff --git a/doc/ptbr/types/typeof.md b/doc/ptbr/types/typeof.md
new file mode 100644
index 00000000..3f499ee5
--- /dev/null
+++ b/doc/ptbr/types/typeof.md
@@ -0,0 +1,83 @@
+## O operador `typeof`
+
+O operador `typeof`(em conjunto com
+[`instanceof`](#types.instanceof) é provavelmente a maior falha de design do JavaScript,
+por estar **complemente mal implementado**.
+
+Embora `instanceof` ainda tenha seu uso limitado, `typeof` realmente só possui uma utilidade,
+a qual **não** acaba por ser a de verificar o tipo de um objeto.
+
+> **Nota:** Enquanto que `typeof` possa também ser invocado com uma sintaxe parecida com a de chamada de função, i.e.
+> `typeof(obj)`, não se trata de uma chamada de função. Os parênteses se comportam normalmente
+> e o valor retornado será usado como o operando do operador `typeof`.
+> **Não** existe a função `typeof`.
+
+### A tabela de tipos em JavaScript
+
+    Value               Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+Na tabela acima, *Type* se refere ao valor de retorno do operador `typeof`.
+Como pode ser facilmente observado, este valor não é nada consistente.
+
+O *Class* se refere ao valor interno da propriedade `[[Class]]` de um objeto.
+
+> **Da especificação:** O valor de `[[Class]]` pode ser
+> das seguintes strings. `Arguments`, `Array`, `Boolean`, `Date`, `Error`, 
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+A fim de se obeter o valor de `[[Class]]`, deve-se utilizar o método 
+`toString` de `Object.prototype`.
+
+### A classe de um objeto
+
+A especificação fornece exatamente uma maneira de acessar o valor de `[[Class]]`,
+com o uso de `Object.prototype.toString`. 
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+No exemplo acima, `Object.prototype.toString` é chamado enquanto que o valor de [this](#function.this)
+é definido como o objeto o qual  o valor `[[Class]]` deva ser retornado.
+
+> **Nota ES5:** Por conveniência o retorno do valor de `Object.prototype.toString` 
+> para ambos `null` e `undefined` foi **modificado** de `Object` para `Null` e 
+> `Undefined` no ECMAScript 5.
+
+### Teste para variáveis não-definidas
+
+    typeof foo !== 'undefined'
+
+O exemplo acima irá verificar se `foo` foi declarado ou não; apenas
+o fato de referênciá-lo poderia resultar em `ReferenceError`. Esta é a única utilidade
+real de `typeof`.
+
+### Conclusão
+
+A fim de verificar o tipo de um objeto, é fortemente recomendade o uso de 
+`Object.prototype.toString` pelo motivo de que esta é a única maneira confiável de ser feita.
+Como demonstrado na tabela anterior, alguns valores retornados de `typeof` não estão definidos na
+especificação; assim, eles podem variar entre implementações.
+O uso de `typeof` deve ser evitado, a menos que não se esteja testando se uma variável está ou não definida.
+
+
diff --git a/doc/ru/appendix/fromtranslators.md b/doc/ru/appendix/fromtranslators.md
index 37372aa8..c9c399d2 100644
--- a/doc/ru/appendix/fromtranslators.md
+++ b/doc/ru/appendix/fromtranslators.md
@@ -1,6 +1,6 @@
 ## От переводчиков
 
-Авторы этой документации требуют от читателя не совершать каких-либо ошибок и постоянно следить за качеством пишущегося кода. Мы, как переводчики и опытные программисты на JavaScript рекомендуем *прислушиваться* к этим советам, но при этом не делать из этого *крайность*. Опыт — сын ошибок трудных, и иногда в борьбе с ошибками зарождается намного более детальное понимание предмета. Да, нужно избегать ошибок, но допускать их неосознанно — вполне нормально.
+Авторы этой документации требуют от читателя не совершать каких-либо ошибок и постоянно следить за качеством пишущегося кода. Мы, как переводчики и опытные программисты на JavaScript, рекомендуем *прислушиваться* к этим советам, но при этом не делать из этого *крайность*. Опыт — сын ошибок трудных, и иногда в борьбе с ошибками зарождается намного более детальное понимание предмета. Да, нужно избегать ошибок, но допускать их неосознанно — вполне нормально.
 
 К примеру, в статье про [сравнение объектов](#types.equality) авторы настоятельно рекомендуют использовать *только* оператор строгого неравенства `===`. Но мы считаем, что если вы уверены и осознали, что оба сравниваемых операнда имеют один тип, вы имеете право опустить последний символ `=`. Вы вольны применять строгое неравенство только в случаях, когда вы не уверены в типах операндов (`!== undefined` — это полезный приём). Так в вашем коде будут опасные и безопасные области, но при этом по коду будет явно видно, где вы рассчитываете на переменные одинаковых типов, а где позволяете пользователю вольности.
 
@@ -8,7 +8,7 @@
 
 С другой стороны, [использование `var`](#function.scopes) и грамотная [расстановка точек с запятой](#core.semicolon) — обязательные вещи, халатное отношение к которым никак не может быть оправдано — в осознанном пропуске `var` (если только вы не переопределяете глобальный объект браузера... хотя *зачем*?) или точки с запятой нет никакого смысла.
 
-Относитесь с **мудростью** к тому, что вы пишете — *важно* знать как работает именно ваш код и как это соответствует приведённым в статье тезисам — и уже из этого вы сможете делать вывод, подходит ли вам тот или иной подход или нет. *Важно* знать как работает [прототипное наследование](#object.prototype), но это не так необходимо, если вы используете функциональный подход или пользуетесь какой-либо сторонней библиотекой. Важно помнить о том, что у вас недостаёт какого-либо конкретного знания и что пробел следует заполнить, но если вы не используете в работе эту часть, вы всё равно можете писать хороший код — ну, если у вас есть талант.
+Относитесь с **мудростью** к тому, что вы пишете — *важно* знать, как работает именно ваш код и как это соответствует приведённым в статье тезисам — и уже из этого вы сможете делать вывод, подходит ли вам тот или иной подход или нет. *Важно* знать, как работает [прототипное наследование](#object.prototype), но это не так необходимо, если вы используете функциональный подход или пользуетесь какой-либо сторонней библиотекой. Важно помнить о том, что у вас недостаёт какого-либо конкретного знания и что пробел следует заполнить, но если вы не используете в работе эту часть, вы всё равно можете писать хороший код — ну, если у вас есть талант.
 
-Гонка за оптимизацией — это драматично и правильно, но лучше написать работающий и понятный вам код, а потом уже его оптимизировать и искать узкие места, при необходимости. Оптимизацию необходимо делать, если вы видите явные неудобства для пользователя в тех или иных браузерах или у вас есть супер-крупный проект, которым никогда не мешает оптимизация, или вы работаете с какой-либо сверхтребовательной технологией типа WebGL. Данная документация очень поможет вам в определении этих узких мест.
+Гонка за оптимизацией — это драматично и правильно, но лучше написать работающий и понятный вам код, а потом уже его оптимизировать и искать узкие места при необходимости. Оптимизацию необходимо делать, если вы видите явные неудобства для пользователя в тех или иных браузерах, или у вас один из тех супер-крупных проектов, которым никогда не помешает оптимизация, или вы работаете с какой-либо сверхтребовательной технологией типа WebGL. Данная документация очень поможет вам в определении этих узких мест.
 
diff --git a/doc/ru/array/constructor.md b/doc/ru/array/constructor.md
index 34f15976..13f58846 100644
--- a/doc/ru/array/constructor.md
+++ b/doc/ru/array/constructor.md
@@ -1,6 +1,6 @@
 ## Конструктор `Array`
 
-Так как в конструкторе `Array` есть некоторая двусмысленность касающаяся его параметров, настоятельно рекомендуется при создании массивов всегда использовать синтаксис литеральной нотации — `[]`.
+Так как в конструкторе `Array` есть некоторая двусмысленность, касающаяся его параметров, настоятельно рекомендуется при создании массивов всегда использовать синтаксис литеральной нотации — `[]`.
 
     [1, 2, 3]; // Результат: [1, 2, 3]
     new Array(1, 2, 3); // Результат: [1, 2, 3]
@@ -15,7 +15,7 @@
     arr[1]; // не определён, undefined
     1 in arr; // false, индекс не был установлен
 
-Поведение, которое позволяет изначально установить только размер массива может пригодиться лишь в нескольких случаях, таких как повторение строк, за счёт чего избегается использование цикла `for loop`.
+Поведение, которое позволяет изначально установить только размер массива, может пригодиться лишь в нескольких случаях, таких как повторение строк, за счёт чего избегается использование цикла `for`.
 
     new Array(count + 1).join(stringToRepeat);
 
diff --git a/doc/ru/array/general.md b/doc/ru/array/general.md
index 8350eefa..a9012e9b 100644
--- a/doc/ru/array/general.md
+++ b/doc/ru/array/general.md
@@ -23,7 +23,7 @@
 
 ### Свойство `length`
 
-Хотя *геттер* свойства `length` просто возвращает количество элементов содежащихся в массиве, *сеттер* можно использовать для **обрезания** массива.
+Хотя *геттер* свойства `length` просто возвращает количество элементов содержащихся в массиве, *сеттер* можно использовать для **обрезания** массива.
 
     var foo = [1, 2, 3, 4, 5, 6];
     foo.length = 3;
diff --git a/doc/ru/core/delete.md b/doc/ru/core/delete.md
new file mode 100644
index 00000000..7db3010b
--- /dev/null
+++ b/doc/ru/core/delete.md
@@ -0,0 +1,88 @@
+## Оператор `delete`
+
+Если говорить коротко, то JavaScript *невозможно* удалить глобальную переменную, функцию или любой другой объект, которому задан атрибут `DontDelete` .
+
+### Глобальный код и код функции
+
+Если переменная или функция определена в глобальной области видимости (scope) или в
+[области видимости функции](#function.scopes), это значит что она является
+свойством (property) глобального или же Activation объекта.
+Подобные свойства имеют набор атрибутов, одним из которых и является
+упомянутый ранее `DontDelete`. Объявление переменных и функций в коде
+функции или глобально всегда создает свойство с атрибутом `DontDelete`, и поэтому
+не может быть удалено.
+
+    // глобальная переменная:
+    var a = 1; // задается DontDelete
+    delete a; // false
+    a; // 1
+
+    // обычная функция:
+    function f() {} // задается DontDelete
+    delete f; // false
+    typeof f; // "function"
+
+    // переназначение не поможет:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Явные свойства
+
+Явно заданные свойство могут быть удалены обычным способом.
+
+    // явно заданные свойства:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+В примере выше, `obj.x` и `obj.y` могут быть удалены потому что у них не задан
+атрибут `DontDelete`. Именно поэтому следующий пример тоже сработает.
+
+    // работает хорошо везде, кроме IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - просто глобальная переменная
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Здесь мы используем небольшой трюк, чтобы удалить `a`. [`this`](#function.this) здесь
+относится к глобальному объекту и мы явно указали удаление переменной `a` как свойства
+глобального объекта, что и позволи нам ее удалить.
+
+Из-за нескольких багов в IE (как минимум 6-8) предыдущий код работать в нем не будет.
+
+### Аргументы функций и встроенные модули (built-ins)
+
+Обычным аргументам функций [`arguments` objects](#function.arguments) и
+встроенным свойствам также задан атрибут `DontDelete`.
+
+    // аргументы функции и свойства:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### Host объекты
+
+Host объект - это объект, предоставляемый окружением. К таким объектам относятся `window`,
+`document`, `location` и так далее.
+Для host объектов поведение оператора `delete` может быть непредсказуемым.
+Согласно спецификации, таким объектам позволено реализовывать любой вид поведения.
+
+### Заключение
+
+Оператор `delete` часто обладает непредсказуемым поведением и безопасно использовать
+его можно лишь для удаления явно заданных свойств обычных объектов.
\ No newline at end of file
diff --git a/doc/ru/core/eval.md b/doc/ru/core/eval.md
index 3750281f..8051a5a2 100644
--- a/doc/ru/core/eval.md
+++ b/doc/ru/core/eval.md
@@ -31,9 +31,9 @@
 
 ### Проблемы с безопасностью
 
-Кроме всего прочего, функция `eval` — это проблема в безопасности, поскольку исполняется **любой** переданный в неё код; **никогда** не следует использовать её со строками из неизвестных или недоверительных источников.
+Кроме всего прочего, функция `eval` — это проблема в безопасности, поскольку исполняется **любой** переданный в неё код; **никогда** не следует использовать её со строками из неизвестных или недоверенных источников.
 
 ### Заключение
 
-Никогда не стоит использовать `eval`: любое применение такого кода поднимает вопросы о качестве его работы, производительности и безопасности. Если вдруг для работы вам необходим `eval`, эта часть должна тут же ставиться под сомнение и **не** должна использоваться в первую очередь — необходимо найти *лучший способ* , которому не требуются вызовы `eval`.
+Никогда не стоит использовать `eval`: любое применение такого кода поднимает вопросы о качестве его работы, производительности и безопасности. Если вдруг для работы вам необходима `eval`, эта часть должна тут же ставиться под сомнение и **не** должна использоваться в первую очередь — необходимо найти *лучший способ*, которому не требуются вызовы `eval`.
 
diff --git a/doc/ru/core/semicolon.md b/doc/ru/core/semicolon.md
index 18c5749b..e36be8de 100644
--- a/doc/ru/core/semicolon.md
+++ b/doc/ru/core/semicolon.md
@@ -89,11 +89,11 @@
     log('тестируем!')
     (options.list || []).forEach(function(i) {})
 
-Такой код трасформируется в строку
+Такой код трансформируется в строку
 
     log('тестируем!')(options.list || []).forEach(function(i) {})
 
-**Чрезвычайно** высоки шансы, что `log` возращает **не** функцию; таким образом, эта строка вызовет `TypeError` с сообщением о том, что `undefined не является функцией`.
+**Чрезвычайно** высоки шансы, что `log` возвращает **не** функцию; таким образом, эта строка вызовет `TypeError` с сообщением о том, что `undefined не является функцией`.
 
 ### Заключение
 
diff --git a/doc/ru/core/undefined.md b/doc/ru/core/undefined.md
index 326f397b..092aec61 100644
--- a/doc/ru/core/undefined.md
+++ b/doc/ru/core/undefined.md
@@ -23,7 +23,7 @@
 
 Поскольку глобальная переменная `undefined` содержит копию настоящего *значения* `undefined`, присвоение этой переменной нового значения **не** изменяет значения *типа* `undefined`.
 
-Но при этом, чтобы сравнить что-либо со *значением* `undefined` прежде нужно получить значение самой *переменной* `undefined`.
+Но при этом, чтобы сравнить что-либо со *значением* `undefined`, прежде нужно получить значение самой *переменной* `undefined`.
 
 Чтобы защитить код от переопределения переменной `undefined`, часто используется техника [анонимной обёртки](#function.scopes), которая использует отсутствующий аргумент.
 
@@ -49,5 +49,5 @@
 
 Хотя `undefined` в контексте языка JavaScript чаще используется в качестве традиционного *null*, настоящий `null` (и тип и литерал) является в большей или меньшей степени просто другим типом данных.
 
-Он используется во внутренних механизмах JavaScript (например для определения конца цепочки прототипов засчёт присваивания `Foo.prototype = null`). Но в большинстве случаев тип `null` может быть заменён на `undefined`.
+Он используется во внутренних механизмах JavaScript (например для определения конца цепочки прототипов за счёт присваивания `Foo.prototype = null`). Но в большинстве случаев тип `null` может быть заменён на `undefined`.
 
diff --git a/doc/ru/function/arguments.md b/doc/ru/function/arguments.md
index 64085e8d..c96c76fc 100644
--- a/doc/ru/function/arguments.md
+++ b/doc/ru/function/arguments.md
@@ -4,9 +4,9 @@
 
 > **Замечание:** В случае, если переменная `arguments` уже была объявлена в области видимости функции либо путём присвоения через выражение `var`, либо являясь формальным параметром, объект `arguments` не будет создан.
 
-Объект `arguments` **не** является наследником `Array`. Он, конечно же, очень похож на массив, и даже содержит свойство `length` — но он не наследует `Array.prototype`, а представляет собой `Object`.
+Объект `arguments` **не** является наследником `Array`. Он, конечно же, очень похож на массив и даже содержит свойство `length` — но он не наследует `Array.prototype`, а представляет собой `Object`.
 
-По этой причине, у объекта `arguments` **отсутствуют** стандартные методы массивов, такие как `push`, `pop` или `slice`. Хотя итерация с использованием обычного цикла `for` по агрументам работает вполне корректно, вам придётся конвертировать этот объект в настоящий массив типа `Array`, чтобы применять к нему стандартные методы массивов.
+По этой причине, у объекта `arguments` **отсутствуют** стандартные методы массивов, такие как `push`, `pop` или `slice`. Хотя итерация с использованием обычного цикла `for` по аргументам работает вполне корректно, вам придётся конвертировать этот объект в настоящий массив типа `Array`, чтобы применять к нему стандартные методы массивов.
 
 ### Конвертация в массив
 
@@ -68,7 +68,7 @@
 
 Объект `arguments` создаётся во всех случаях, лишь за двумя исключениями — когда он переопределён внутри функции (по имени) или когда одним из её параметров является переменная с таким именем. Неважно, используется при этом сам объект или нет.
 
-*Геттеры* и *сеттеры* создаются **всегда**; так что, их использование практически никак не влияет на производительность.
+*Геттеры* и *сеттеры* создаются **всегда**; так что их использование практически никак не влияет на производительность.
 
 > **ES5 Замечание:** Эти *геттеры* и *сеттеры* не создаются в strict-режиме.
 
diff --git a/doc/ru/function/closures.md b/doc/ru/function/closures.md
index a6e62997..b96ccf61 100644
--- a/doc/ru/function/closures.md
+++ b/doc/ru/function/closures.md
@@ -46,7 +46,7 @@
 
 Данный код **не** будет выводить числа с `0` до `9`, вместо этого число `10` будет выведено десять раз.
 
-*Анонимная* функция сохраняет **ссылку** на `i` и когда будет вызвана функция `console.log`, цикл `for` уже закончит свою работу, а в `i` будет содержаться `10`.
+*Анонимная* функция сохраняет **ссылку** на `i` и, когда будет вызвана функция `console.log`, цикл `for` уже закончит свою работу, а в `i` будет содержаться `10`.
 
 Для получения желаемого результата необходимо создать **копию** переменной `i`.
 
diff --git a/doc/ru/function/constructors.md b/doc/ru/function/constructors.md
index 20b09d4f..7a322aff 100644
--- a/doc/ru/function/constructors.md
+++ b/doc/ru/function/constructors.md
@@ -2,7 +2,7 @@
 
 Создание конструкторов в JavaScript также отличается от большинства других языков. Любая функция, вызванная с использованием ключевого слова `new`, будет конструктором.
 
-Внутри конструктора (вызываемой функции) `this` будет указывать на новосозданный `Object`. [Прототипом](#object.prototype) этого **нового** объекта будет `prototype` функции, которая была вызвана в качестве коструктора.
+Внутри конструктора (вызываемой функции) `this` будет указывать на новосозданный `Object`. [Прототипом](#object.prototype) этого **нового** объекта будет `prototype` функции, которая была вызвана в качестве конструктора.
 
 Если вызываемая функция не имеет явного возврата посредством `return`, то вернётся `this` — этот новый объект.
 
@@ -70,7 +70,7 @@
 
 ### Создание объектов с использованием фабрик
 
-Часто рекомендуют **не** использовать `new`, поскольку если вы его забудете, это может привести к ошибкам.
+Часто **не** рекомендуют использовать `new`, поскольку если вы его забудете, это может привести к ошибкам.
 
 Чтобы создать новый объект, лучше использовать фабрику и создать новый объект *внутри* этой фабрики.
 
@@ -89,13 +89,13 @@
         return obj;
     }
 
-Хотя данный пример и сработает, если вы забыли ключевое слово `new` и благодаря ему легче работать с [приватными переменными](#function.closures), у него есть несколько недостатков
+Хотя данный пример и сработает, если вы забыли ключевое слово `new`, и благодаря ему легче работать с [приватными переменными](#function.closures), у него есть несколько недостатков
 
  1. Он использует больше памяти, поскольку созданные объекты **не** хранят методы в прототипе и соответственно для каждого нового объекта создаётся копия каждого метода.
  2. Чтобы эмулировать наследование, фабрике нужно скопировать все методы из другого объекта или установить прототипом нового объекта старый.
- 3. Разрыв цепочки прототипов просто по причине забытого ключевого слова `new` идёт в разрез с духом языка.
+ 3. Разрыв цепочки прототипов просто по причине забытого ключевого слова `new` идёт вразрез с духом языка.
 
 ### Заключение
 
-Хотя забытое ключевое слово `new` и может привести к багам, это точно **не** причина отказываться от использования прототипов. В конце концов, полезнее решить какой из способов лучше совпадает с требованиями приложения: очень важно выбрать один из стилей создания объектов и после этого **не изменять** ему.
+Хотя забытое ключевое слово `new` и может привести к багам, это точно **не** причина отказываться от использования прототипов. В конце концов, полезнее решить, какой из способов лучше совпадает с требованиями приложения: очень важно выбрать один из стилей создания объектов и после этого **не изменять** ему.
 
diff --git a/doc/ru/function/general.md b/doc/ru/function/general.md
index c4a47e64..eaf48c67 100644
--- a/doc/ru/function/general.md
+++ b/doc/ru/function/general.md
@@ -7,7 +7,7 @@
     // всё просто и привычно
     function foo() {}
 
-В следующем примере описанная функция [резервируется](#function.scopes) перед запуском всего скрипта; за счёт этого она доступна *в любом месте* кода, вне зависимости от того где она *определена* — даже если функция вызывается до её фактического объявления в коде.
+В следующем примере описанная функция [резервируется](#function.scopes) перед запуском всего скрипта; за счёт этого она доступна *в любом месте* кода, вне зависимости от того, где она *определена* — даже если функция вызывается до её фактического объявления в коде.
 
 
     foo(); // сработает, т.к. функция будет создана до выполнения кода
@@ -34,7 +34,7 @@
 
 ### Выражения с именованными фунциями
 
-Существует еще ньюанс, касающийся именованных функций создающихся через присваивание:
+Существует еще нюанс, касающийся именованных функций создающихся через присваивание:
 
     var foo = function bar() {
         bar(); // работает
diff --git a/doc/ru/function/scopes.md b/doc/ru/function/scopes.md
index 48c6e846..0cf88caa 100644
--- a/doc/ru/function/scopes.md
+++ b/doc/ru/function/scopes.md
@@ -73,9 +73,9 @@
 
 В то время как `foo` и `i` — локальные переменные в области видимости функции `test`, присвоение `bar` переопределит значение одноимённой глобальной переменной.
 
-### Высасывание
+### Всплытие
 
-JavaScript **высасывает** определения. Это значит, что оба определения с использованием `var` и определение `function` будут перенесены наверх заключающей их области видимости.
+В JavaScript действует механизм **всплытия** определения. Это значит, что оба определения с использованием `var` и определение `function` будут перенесены наверх заключающей их области видимости.
 
     bar();
     var bar = function() {};
@@ -116,16 +116,16 @@ JavaScript **высасывает** определения. Это значит,
 
     bar(); // вылетает с ошибкой TypeError,
            // поскольку bar всё ещё 'undefined'
-    someValue = 42; // присвоения не подвержены высасыванию
+    someValue = 42; // присвоения не подвержены всплытию
     bar = function() {};
 
     test();
 
 Потерянная область видимости блока не только переместит операторы `var` вовне циклов и их тел, но и сделает результаты некоторых конструкций с `if` неинтуитивными.
 
-В исходном коде оператор `if` изменял *глобальную переменную* `goo`, когда, как оказалось, он изменяет *локальную переменную* — в результате работы высасывания.
+В исходном коде оператор `if` изменял *глобальную переменную* `goo`, когда, как оказалось, он изменяет *локальную переменную* — в результате работы всплытия.
 
-Если вы не знакомы с *высасываниями*, то можете посчитать, что нижеприведённый код должен породить
+Если вы не знакомы со *всплытием*, то можете посчитать, что нижеприведённый код должен породить
 `ReferenceError`.
 
     // проверить, проинициализована ли SomeImportantThing
@@ -133,7 +133,7 @@ JavaScript **высасывает** определения. Это значит,
         var SomeImportantThing = {};
     }
 
-Но конечно же этот код работает: из-за того, что оператор `var` был перемещён наверх *глобальной области видимости*
+Но, конечно же, этот код работает: из-за того, что оператор `var` был перемещён наверх *глобальной области видимости*
 
     var SomeImportantThing;
 
@@ -155,14 +155,14 @@ JavaScript **высасывает** определения. Это значит,
 
  1. Если в текущей области видимости есть выражение `var foo`, использовать его.
  2. Если один из параметров функции называется `foo`, использовать его.
- 3. Если функциия сама называется `foo`, использовать её.
+ 3. Если функция сама называется `foo`, использовать её.
  4. Перейти на одну область видимости выше и начать с **п. 1**
 
 > **Замечание:** Наличие параметра функции с именем `arguments` **не позволит** движку создать объект `arguments`, создающийся по умолчанию.
 
 ### Пространства имён
 
-Нередкое последствие наличия только одного глобального пространства имён — проблемы с перекрытием имён переменных. В JavaScript эту проблему легко избежать, используя *анонимные обёртки*.
+Нередкое последствие наличия только одного глобального пространства имён — проблема с перекрытием имён переменных. В JavaScript эту проблему легко избежать, используя *анонимные обёртки*.
 
     (function() {
         // самостоятельно созданное "пространство имён"
@@ -188,7 +188,7 @@ JavaScript **высасывает** определения. Это значит,
 
 ### Заключение
 
-Рекомендуется всегда использовать *анонимную обёртку* для заключения кода в его собственное пространство имён. Это не только защищает код от совпадений имён, но и позваоляет создавать более модульные программы.
+Рекомендуется всегда использовать *анонимную обёртку* для заключения кода в его собственное пространство имён. Это не только защищает код от совпадений имён, но и позволяет создавать более модульные программы.
 
 Важно добавить, что использование глобальных переменных считается **плохой практикой**. **Любое** их использование демонстрирует плохое качество кода и может привести к трудноуловимым ошибкам.
 
diff --git a/doc/ru/function/this.md b/doc/ru/function/this.md
index 9fd6390c..6883a546 100644
--- a/doc/ru/function/this.md
+++ b/doc/ru/function/this.md
@@ -26,7 +26,7 @@
 
     new foo();
 
-Если перед вызовом функции присутствует ключевое слово `new` то данная функция будет действовать как [конструктор](#function.constructors). Внутри такой функции `this` будет указывать на *новосозданный* `Object`.
+Если перед вызовом функции присутствует ключевое слово `new`, то данная функция будет действовать как [конструктор](#function.constructors). Внутри такой функции `this` будет указывать на *новосозданный* `Object`.
 
 ### 5. Переопределение `this`
 
@@ -36,9 +36,9 @@
     foo.apply(bar, [1, 2, 3]); // массив развернётся в a = 1, b = 2, c = 3
     foo.call(bar, 1, 2, 3); // аналогично
 
-Когда мы используем методы `call` или `apply` из `Function.prototype`, то внутри вызваемой функции `this` **явным образом** будет присвоено значение первого передаваемого параметра.
+Когда мы используем методы `call` или `apply` из `Function.prototype`, то внутри вызываемой функции `this` **явным образом** будет присвоено значение первого передаваемого параметра.
 
-Исходя из этого, в предыдущем примере (строка с `apply`) правило #3 *вызов метода* **не** будет применёно, и `this` внутри `foo` будет присвоено `bar`.
+Исходя из этого, в предыдущем примере (строка с `apply`) правило #3 *вызов метода* **не** будет применено, и `this` внутри `foo` будет присвоено `bar`.
 
 > **Замечание:** `this` **нельзя** использовать внутри литералов `{}` (`Object`) для ссылки на сам объект. Т.е. если мы напишем `var obj = {me: this}`, то `me` не будет ссылаться на `obj`, поскольку `this` присваивается только по одному из пяти описанных правил.
 
@@ -51,11 +51,11 @@
             // this ссылается на глобальный объект
         }
         test();
-    }
+    };
 
 Распространенным заблуждением будет то, что `this` внутри `test` ссылается на `Foo`, но это **не так**.
 
-Для того, чтобы получить доступ к `Foo` внутри функции `test`, необходимо создать локальную перменную внутри `method`, которая и будет ссылаться на `Foo`.
+Для того, чтобы получить доступ к `Foo` внутри функции `test`, необходимо создать локальную переменную внутри `method`, которая и будет ссылаться на `Foo`.
 
     Foo.method = function() {
         var that = this;
@@ -63,9 +63,9 @@
             // Здесь используем that вместо this
         }
         test();
-    }
+    };
 
-Подходящее имя для переменной - `that`, его часто используют для ссылки на внешний `this`. В комбинации с [замыканиями](#function.closures) `this` можно пробрасывать в глобальную область, или в любой другой объект.
+Подходящее имя для переменной - `that`, его часто используют для ссылки на внешний `this`. В комбинации с [замыканиями](#function.closures) `this` можно пробрасывать в глобальную область или в любой другой объект.
 
 > **Замечание** от перев. Кроме `that` также часто встречаются `this_`, `self_` и другие варианты, но лучше принять для себя `that` как стандарт и тогда, возможно, все вокруг тоже будут им пользоваться.
 
@@ -88,5 +88,5 @@
 
     new Bar().method();
 
-В момент, когда будет вызван `method` нового экземляра `Bar`, `this` будет ссылаться на этот самый экземпляр.
+В момент, когда будет вызван `method` нового экземпляра `Bar`, `this` будет ссылаться на этот самый экземпляр.
 
diff --git a/doc/ru/intro/contributors.md b/doc/ru/intro/contributors.md
index da825f6a..159fb877 100644
--- a/doc/ru/intro/contributors.md
+++ b/doc/ru/intro/contributors.md
@@ -1,8 +1,4 @@
 ## Участники
 
- - [Кайо Ромао /Caio Romão/][1] (проверка орфографии)
- - [Андреас Бликст /Andreas Blixt/][2] (проверка грамматики)
-
-[1]: https://github.com/caio
-[2]: https://github.com/blixt
+- [Участники](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
 
diff --git a/doc/ru/intro/index.md b/doc/ru/intro/index.md
index fa7c6636..9debe341 100644
--- a/doc/ru/intro/index.md
+++ b/doc/ru/intro/index.md
@@ -1,6 +1,6 @@
 ## Вступление
 
-**JavaScript Гарден** это постоянно обновляющаяся и растущая документация по самым заковыристым темам языка JavaScript. В ней вы найдёте советы о том, как избежать распространённых ошибок и предсказать появление тех или иных багов. В документации подробно освещены проблемы оптимизации и нерекомендуемые практики с которыми, продираясь к глубинам языка, могут столкнуться даже просвещённые JavaScript-программисты.
+**JavaScript Гарден** — это постоянно обновляющаяся и растущая документация по самым заковыристым темам языка JavaScript. В ней вы найдёте советы о том, как избежать распространённых ошибок и предсказать появление тех или иных багов. В документации подробно освещены проблемы оптимизации и нерекомендуемые практики с которыми, продираясь к глубинам языка, могут столкнуться даже просвещённые JavaScript-программисты.
 
 JavaScript Гарден **не** имеет цели научить вас языку JavaScript. Вам понадобится реальный опыт работы с языком чтобы понимать темы, рассматриваемые в этом руководстве. Если вам требуется изучить основы языка, пожалуйста внимательно ознакомьтесь с замечательным [руководством][1] на сайте Mozilla Developer Network.
 
diff --git a/doc/ru/object/forinloop.md b/doc/ru/object/forinloop.md
index 22470a2f..3bc5c8d4 100644
--- a/doc/ru/object/forinloop.md
+++ b/doc/ru/object/forinloop.md
@@ -1,6 +1,6 @@
 ## Цикл `for in`
 
-Как и оператор `in`, цикл `for in` проходит по всей цепочке прототипов обходя свойства объекта.
+Как и оператор `in`, цикл `for in` проходит по всей цепочке прототипов, обходя свойства объекта.
 
 > **Примечание:** Цикл `for in` **не** обходит те свойства объекта, у которых атрибут `enumerable` установлен в `false`; как пример - свойство `length` у массивов
 
@@ -25,7 +25,7 @@
         }
     }
 
-Это единственная версия правильного использования цикла. Благодаря использованию `hasOwnPropery` будет выведено **только** свойство `moo`. Если же убрать `hasOwnProperty`, код становится нестабилен и могут возникнуть ошибки, особенно если кто-то изменил встроенные прототипы, такие как `Object.prototype`.
+Это единственная версия правильного использования цикла. Благодаря использованию `hasOwnProperty` будет выведено **только** свойство `moo`. Если же убрать `hasOwnProperty`, код становится нестабилен и могут возникнуть ошибки, особенно если кто-то изменил встроенные прототипы, такие как `Object.prototype`.
 
 Один из самых популярных фреймворков [Prototype][1] как раз этим и славится, и если вы его подключаете, то не забудьте использовать `hasOwnProperty` внутри цикла `for in`, иначе у вас гарантированно возникнут проблемы.
 
diff --git a/doc/ru/object/general.md b/doc/ru/object/general.md
index d5b65e7a..aa5ad534 100644
--- a/doc/ru/object/general.md
+++ b/doc/ru/object/general.md
@@ -1,8 +1,8 @@
 ## Объекты и их свойства
 
-В JavaScript всё является объектом, лишь за двумя исключениями — [`null`](#core.undefined) и [`undefined`](#core.undefined).
+В JavaScript всё ведет себя, как объект, лишь за двумя исключениями — [`null`](#core.undefined) и [`undefined`](#core.undefined).
 
-    false.toString() // 'false'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
 
     function Foo(){}
@@ -34,7 +34,7 @@
 
 Получить доступ к свойствам объекта можно двумя способами: используя либо точечную нотацию, либо запись квадратными скобками.
 
-    var foo = {name: 'Kitten'}
+    var foo = {name: 'kitten'}
     foo.name; // kitten
     foo['name']; // kitten
 
@@ -73,7 +73,7 @@
 
     var test = {
         'case': 'Я — ключевое слово, поэтому меня надо записывать строкой',
-        delete: 'Я тоже ключевое слово, так что я' // бросаю SyntaxError
+        delete: 'Я тоже ключевое слово, так что я' // не является ошибкой, бросает SyntaxError только в версиях ECMAScript ниже 5ой версии
     };
 
 Свойства объектов могут записываться как явно символами, так и в виде закавыченных строк. В связи с другим упущением в парсере JavaScript, этот код выбросит `SyntaxError` во всех версиях ранее ECMAScript 5.
@@ -84,14 +84,14 @@
 
     // валидный JavaScript и валидный JSON
     {
-        'foo': 'oof',
-        'bar': 'rab'
+        "foo": "oof",
+        "bar": "rab"
     }
 
-    // валидный JavaScript и НЕ валидный JSON
+    // валидный JavaScript и НЕвалидный JSON
     {
-        foo: 'oof',
-        bar: 'rab'
+        foo: "oof",
+        bar: "rab"
     }
 
 [1]: http://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0
diff --git a/doc/ru/object/hasownproperty.md b/doc/ru/object/hasownproperty.md
index 1c8a617c..89b950ca 100644
--- a/doc/ru/object/hasownproperty.md
+++ b/doc/ru/object/hasownproperty.md
@@ -16,7 +16,7 @@
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-Только используя ｀hasOwnProperty｀ можно гарантировать правильный результат при переборе свойств объекта. И **нет** иного способа для определения свойств, которые определены в *самом* объекте, а не где-то в цепочке его прототипов.
+Только используя `hasOwnProperty` можно гарантировать правильный результат при переборе свойств объекта. И **нет** иного способа для определения свойств, которые определены в *самом* объекте, а не где-то в цепочке его прототипов.
 
 ### `hasOwnProperty` как свойство
 
@@ -37,5 +37,4 @@ JavaScript **не** резервирует свойство с именем `has
 
 ### Заключение
 
-**Единственным** способом проверить существование свойства у объекта является использование метода `hasOwnProperty`. При этом, рекомендуется использовать этот метод в **каждом** [цикле `for in`](#object.forinloop) вашего проекта, чтобы избежать возможных ошибок с ошибочным заимствованием свойств из [прототипов](#object.prototype) родительских объектов. Также вы можете использовать конструкцию `{}.hasOwnProperty.call(...)` на случай, если кто-то вздумает расширить [прототипы](#object.prototype) встроенных объектов.
-
+**Единственным** способом проверить существование свойства у объекта является использование метода `hasOwnProperty`. При этом рекомендуется использовать этот метод в **каждом** [цикле `for in`](#object.forinloop) вашего проекта, чтобы избежать возможных ошибок с ошибочным заимствованием свойств из [прототипов](#object.prototype) родительских объектов. Также вы можете использовать конструкцию `{}.hasOwnProperty.call(...)` на случай, если кто-то вздумает расширить [прототипы](#object.prototype) встроенных объектов.
diff --git a/doc/ru/object/prototype.md b/doc/ru/object/prototype.md
index 15f90ba6..a8e75129 100644
--- a/doc/ru/object/prototype.md
+++ b/doc/ru/object/prototype.md
@@ -10,17 +10,19 @@
 
 > **Замечание:** В результате выполнения конструкции `Bar.prototype = Foo.prototype` оба объекта будут делить друг с другом **один и тот же** прототип. Так что изменение прототипа одного из объектов повлечёт за собой изменение прототипа другого и наоборот — вряд ли это окажется тем, чего вы ожидали.
 
+> **Замечание:** Для объявления наследования вместо `Bar.prototype = Object.create(Foo.prototype)` можно воспользоваться конструкций `Bar.prototype = new Foo()`, но у нее есть пару недостатков: 1) как правило требуется унаследовать только методы и свойства прототипа, а не создавать для этого новый объект; 2) создание объекта может требовать обязательные аргументы.
+
+> **Примечание:** Метод `Object.create` отсутствует в IE8 и ниже, но его легко реализовать созданием своей такой функции или же можно подключить библиотеку для поддержки старых IE [*es5-shim*][5]
+
     function Foo() {
         this.value = 42;
     }
-    Foo.prototype = {
-        method: function() {}
-    };
+    Foo.prototype.method = function() {}
 
     function Bar() {}
 
-    // Установим значением прототипа Bar новый экземпляр Foo
-    Bar.prototype = new Foo();
+    // Зададим наследование от Foo
+    Bar.prototype = Object.create(Foo.prototype);
     Bar.prototype.foo = 'Hello World';
 
     // Убедимся, что Bar является действующим конструктором
@@ -31,13 +33,13 @@
     // Цепочка прототипов, которая получится в результате
     test [instance of Bar]
         Bar.prototype [instance of Foo]
-            { foo: 'Hello World' }
+            { foo: 'Hello World', value: 42 }
             Foo.prototype
                 { method: ... }
                 Object.prototype
                     { toString: ... /* и т.д. */ }
 
-В приведённом коде объект `test` наследует оба прототипа: `Bar.prototype` и `Foo.prototype`; следовательно, он имеет доступ к функции `method` которую мы определили в прототипе `Foo`. Также у него есть доступ к свойству `value` **одного уникального** экземпляра `Foo`, который является его протипом. Важно заметить, что код `new Bar()` **не** создаёт новый экземпляр `Foo`, а повторно вызывает функцию, которая была назначен его прототипом: таким образом все новые экземпляры `Bar` будут иметь **одинаковое** свойство `value`.
+В приведённом коде объект `test` наследует оба прототипа: `Bar.prototype` и `Foo.prototype`; следовательно, он имеет доступ к функции `method` которую мы определили в прототипе `Foo`. Также у него есть доступ к свойству `value` **одного уникального** экземпляра `Foo`, который является его прототипом. Важно заметить, что код `new Bar()` **не** создаёт новый экземпляр `Foo`, а повторно вызывает функцию, которая была назначена его прототипом: таким образом все новые экземпляры `Bar` будут иметь **одинаковое** свойство `value`.
 
 > **Замечание:** Никогда **не** используйте конструкцию `Bar.prototype = Foo`, поскольку ссылка будет указывать не на прототип `Foo`, а на объект функции `Foo`. Из-за этого цепочка прототипов будет проходить через `Function.prototype`, а не через `Foo.prototype` и в результате функция `method` не будет содержаться в цепочке прототипов.
 
@@ -69,7 +71,7 @@
 
 Часто встречается неверное применение прототипов — расширение прототипа `Object.prototype` или прототипов одного из встроенных объектов JavaScript.
 
-Подобная практика нарушает принцип *инкапсуляции*, и имеет соответствующее название — [monkey patching][2]. К сожалению, в основу многих широко распространенных фреймворков, например Prototype, положен принцип изменения базовых прототипов. Вам же стоит запомнить — от хорошей жизни прототипы встроенных объектов не меняют.
+Подобная практика нарушает принцип *инкапсуляции* и имеет соответствующее название — [monkey patching][2]. К сожалению, в основу многих широко распространенных фреймворков, например Prototype, положен принцип изменения базовых прототипов. Вам же стоит запомнить — от хорошей жизни прототипы встроенных объектов не меняют.
 
 **Единственным** оправданием для расширения встроенных прототипов может быть только воссоздание возможностей более новых движков JavaScript, например функции [`Array.forEach`][4], которая появилась в версии 1.6.
 
@@ -81,4 +83,5 @@
 [2]: http://en.wikipedia.org/wiki/Monkey_patch
 [3]: http://prototypejs.org/
 [4]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+[5]: https://github.com/es-shims/es5-shim
 
diff --git a/doc/ru/other/timeouts.md b/doc/ru/other/timeouts.md
index 7e2a6647..d5eb03b1 100644
--- a/doc/ru/other/timeouts.md
+++ b/doc/ru/other/timeouts.md
@@ -2,12 +2,12 @@
 
 Поскольку JavaScript поддерживает асинхронность, есть возможность запланировать выполнение функции, используя функции `setTimeout` и `setInterval`.
 
-> **Замечание:** Таймауты **не** являются частью стандарта ECMAScript, они были разработаны как раздел спецификации[DOM][1].
+> **Замечание:** Таймауты **не** являются частью стандарта ECMAScript, они были разработаны как раздел спецификации [DOM][1].
 
     function foo() {}
     var id = setTimeout(foo, 1000); // возвращает число > 0
 
-Функция `setTimeout` возвращает идентификатор таймаута и планирует вызвать `foo` через, **примерно**, тысячу миллисекунд. Фунция `foo` при этом будет вызвана ровно **один** раз.
+Функция `setTimeout` возвращает идентификатор таймаута и планирует вызвать `foo` через, **примерно**, тысячу миллисекунд. Функция `foo` при этом будет вызвана ровно **один** раз.
 
 В зависимости от разрешения таймера в используемом для запуска кода движке JavaScript, а также с учётом того, что JavaScript является однопоточным языком и посторонний код может заблокировать выполнение потока, нет **никакой** гарантии, что переданный код будет выполнен ровно через указанное в вызове `setTimeout` время.
 
@@ -55,7 +55,7 @@
 
 ### Очистка таймаутов вручную
 
-Удаление таймаутов и интервалов работает через передачу соответствуюего идентификатора либо в функцию `clearTimeout`, либо в функцию `clearInterval` — в зависимости от того, какая функция `set...` использовалась для его получения.
+Удаление таймаутов и интервалов работает через передачу соответствующего идентификатора либо в функцию `clearTimeout`, либо в функцию `clearInterval` — в зависимости от того, какая функция `set...` использовалась для его получения.
 
     var id = setTimeout(foo, 1000);
     clearTimeout(id);
@@ -69,7 +69,7 @@
         clearTimeout(i);
     }
 
-Вполне могут остаться таймауты, которые не будут захвачены этим произвольным числом; так что всё же рекомендуется следить за идентификаторами всех создающихся таймаутов, засчёт чего их можно будет удалять индивидуально.
+Вполне могут остаться таймауты, которые не будут захвачены этим произвольным числом; так что всё же рекомендуется следить за идентификаторами всех создающихся таймаутов, за счёт чего их можно будет удалять индивидуально.
 
 ### Скрытое использование `eval`
 
@@ -100,10 +100,10 @@
 
     // Вместо этого используйте анонимную функцию
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
-> **Замечание:** При том, что синтаксис `setTimeout(foo, 1000, a, b, c)` разрешено использовать, это крайне не рекомендуется, поскольку может привести к сложно-разпознаваемым ошибкам при работе с [методами](#function.this).
+> **Замечание:** При том, что синтаксис `setTimeout(foo, 1000, 1, 2, 3)` разрешено использовать, это крайне не рекомендуется, поскольку может привести к сложно распознаваемым ошибкам при работе с [методами](#function.this).
 
 ### Заключение
 
diff --git a/doc/ru/types/casting.md b/doc/ru/types/casting.md
index bc350cfc..8e77c79d 100644
--- a/doc/ru/types/casting.md
+++ b/doc/ru/types/casting.md
@@ -1,36 +1,37 @@
 ## Приведение типов
 
-JavaScript *слабо типизированный* язык, поэтому *преобразование типов* будет применяться **везде**, где возможно.
+JavaScript — *слабо типизированный* язык, поэтому *преобразование типов* будет применяться **везде**, где возможно.
 
     // Эти равенства — истинны
-    new Number(10) == 10; // Number.toString() преобразуется
-                          // обратно в число
+    new Number(10) == 10; // объект типа Number преобразуется
+                          // в числовой примитив в результате неявного вызова
+                          // метода Number.prototype.valueOf
 
     10 == '10';           // Strings преобразуется в Number
     10 == '+10 ';         // Ещё чуток строко-безумия
     10 == '010';          // и ещё
     isNaN(null) == false; // null преобразуется в 0,
-                          // который конечно же NaN
+                          // который конечно же не NaN
 
     // Эти равенства — ложь
     10 == 010;
     10 == '-10';
 
-> **ES5 Замечание:** Числовые литералы, которые начинаются с 0 интерпретируются как восьмеричные (Base 8). В ECMAScript 5 strict mode **удалена** поддержка восьмеричной системы.
+> **ES5 Замечание:** Числовые литералы, которые начинаются с 0, интерпретируются как восьмеричные (Base 8). В ECMAScript 5 strict mode **удалена** поддержка восьмеричной системы.
 
 Для того, чтобы избежать этого, **настоятельно** рекомендуется использовать [оператор строгого равенства](#types.equality). Впрочем, хотя это и позволяет избежать многих распространенных ошибок, существует ещё много дополнительных вопросов, которые возникают из-за слабости типизации JavaScript.
 
 ### Конструкторы встроенных типов
 
-Конструкторы встроенных типов, например, `Number` и `String` ведут себя различным образом, в зависимости от того вызываются они с ключевым словом `new` или без.
+Конструкторы встроенных типов, например, `Number` и `String` ведут себя различным образом, в зависимости от того, вызываются они с ключевым словом `new` или без.
 
     new Number(10) === 10;     // False, Object и Number
     Number(10) === 10;         // True, Number и Number
     new Number(10) + 0 === 10; // True, из-за неявного преобразования
 
-Использование встроенных типов, например `Number`, с конструктором создаёт новый экземпляр объекта Number, но использование без ключевого слова `new` создаст функцию `Number`, которая будет вести себя как конвертер.
+Использование встроенного типа, такого как `Number`, в качестве конструктора создаёт новый экземпляр объекта Number, но при использовании без ключевого слова `new` функция `Number` будет вести себя как конвертер.
 
-Кроме того, присутствие литералов или переменных, которые не являются объектами приведет к еще большему насилию над типами.
+Кроме того, присутствие литералов или переменных, которые не являются объектами, приведет к еще большему насилию над типами.
 
 Лучший вариант — это **явное** приведение к одному из трех возможных типов.
 
@@ -44,7 +45,7 @@ JavaScript *слабо типизированный* язык, поэтому *
 
     +'10' === 10; // true
 
-Используя **унарный** оператор плюс можно преобразовать значение в число.
+Используя **унарный** оператор плюс, можно преобразовать значение в число.
 
 ### Приведение к булеву типу
 
diff --git a/doc/ru/types/equality.md b/doc/ru/types/equality.md
index 03c916ce..a7255ca7 100644
--- a/doc/ru/types/equality.md
+++ b/doc/ru/types/equality.md
@@ -18,7 +18,7 @@ JavaScript имеет 2 различных способа сравнения з
     null         ==   undefined     // true
     " \t\r\n"    ==   0             // true
 
-В таблице выше показаны результаты приведения типов и это главная причина почему использование `==` повсеместно считается плохой практикой: оно приводит к трудностям в отслеживании ошибок из-за сложных правил преобразования типов.
+В таблице выше показаны результаты приведения типов и это главная причина, почему использование `==` повсеместно считается плохой практикой: оно приводит к трудностям в отслеживании ошибок из-за сложных правил преобразования типов.
 
 Кроме того, приведение типов во время сравнения также влияет на производительность; например, строка должна быть преобразована в число перед сравнением с другим числом.
 
@@ -50,7 +50,7 @@ JavaScript имеет 2 различных способа сравнения з
     var foo = {};
     foo === foo;                 // true
 
-Здесь оба операнда сравниваются на **идентичность**, а **не** на равенство; то есть, будет проверяться, являются ли операнды одним **экземпляром** объекта, так же как делает `is` в Python и сравниваются указатели в С.
+Здесь оба операнда сравниваются на **идентичность**, а **не** на равенство; то есть будет проверяться, являются ли операнды одним **экземпляром** объекта, так же как делает `is` в Python и сравниваются указатели в С.
 
 ### Заключение
 
diff --git a/doc/ru/types/instanceof.md b/doc/ru/types/instanceof.md
index 76d770c9..a19f2ce9 100644
--- a/doc/ru/types/instanceof.md
+++ b/doc/ru/types/instanceof.md
@@ -28,5 +28,5 @@
 
 ### Заключение
 
-Оператор `instanceof` должен использоваться **только** при обращении к пользовательским объектам, происходящим из одного контекста JavaScript. Так же, как и в случае оператора `typeof`, любое другое использование необходимо **избегать**.
+Оператор `instanceof` должен использоваться **только** при обращении к пользовательским объектам, происходящим из одного контекста JavaScript. Так же, как и в случае оператора `typeof`, любого другого использования необходимо **избегать**.
 
diff --git a/doc/ru/types/typeof.md b/doc/ru/types/typeof.md
index 96cd7ed1..f19b62a6 100644
--- a/doc/ru/types/typeof.md
+++ b/doc/ru/types/typeof.md
@@ -1,10 +1,10 @@
 ## Оператор `typeof`
 
-Оператор `typeof` (вместе с [`instanceof`](#types.instanceof)) — это, вероятно, самая большая недоделка в JavaScript, поскольку, похоже, он **поломан более чем полностью**.
+Оператор `typeof` (вместе с [`instanceof`](#types.instanceof)) — это, вероятно, самая большая недоделка в JavaScript, поскольку, похоже, он **поломан более, чем полностью**.
 
 Хотя `instanceof` еще имеет ограниченное применение, `typeof` на самом деле имеет *только один* практический случай применения, который при всём при этом **не** является проверкой типа объекта.
 
-> **Замечаение:** Хотя для вызова `typeof` также можно использовать синтаксис функции, т.е. `typeof(obj)`, на самом деле это не функция. Двойные круглые скобки будут работать нормально и возвращаемое значение будет использоваться как операнд оператора `typeof`. Но функции `typeof` — **не существует**.
+> **Замечание:** Хотя для вызова `typeof` также можно использовать синтаксис функции, т.е. `typeof(obj)`, на самом деле это не функция. Двойные круглые скобки будут работать нормально и возвращаемое значение будет использоваться как операнд оператора `typeof`. Но функции `typeof` — **не существует**.
 
 ### Таблица типов JavaScript
 
@@ -32,7 +32,7 @@
 
 > **Из спецификации:** Значением `[[Class]]` может быть одна из следующих строк: `Arguments`, `Array`, `Boolean`, `Date`, `Error`, `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
 
-Для того, чтобы получить значение `[[Class]]` необходимо вызвать метод `toString` у  `Object.prototype`.
+Для того, чтобы получить значение `[[Class]]`, необходимо вызвать метод `toString` у `Object.prototype`.
 
 ### Класс объекта
 
diff --git a/doc/tr/core/delete.md b/doc/tr/core/delete.md
new file mode 100644
index 00000000..de19f1a4
--- /dev/null
+++ b/doc/tr/core/delete.md
@@ -0,0 +1,84 @@
+## `delete` Operatörü
+
+Kısacası, genel kapsamda tanımlanmış değişkenleri, fonksiyonları ve `DontDelete`
+niteliğine sahip bazı başka şeyleri silmek *imkansızdır*.
+
+### Genel kapsam ve fonksiyon kapsamı
+
+Bir değişken veya fonksiyon genel kapsamda veya
+[fonksiyon kapsamında](#function.scopes) tanımlandığında aktivasyon nesnesinin
+veya global nesnenin bir özelliği olacaktır. Bu tür özelliklerin bir takım
+nitelikleri vardır ve bunlardan biri `DontDelete` niteliğidir. Genel kapsamda ve
+fonksiyon kapsamında tanımlanan değişkenler ve fonksiyonlar yaratıldıklarında
+her zaman `DontDelete` niteliğine sahip olacaktır, ve bu nedenle silinemezler.
+ 
+    // genel kapsam değişkeni:
+    var a = 1; // DontDelete niteliğine sahip
+    delete a; // false
+    a; // 1
+
+    // normal bir fonksiyon:
+    function f() {} // DontDelete niteliğine sahip
+    delete f; // false
+    typeof f; // "function"
+
+    // başka bir değişkene atamak işe yaramaz:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Açıkça tanımlanan özellikler
+
+Açıkça tanımlanan özellikleri silmek mümkündür.
+
+    // tanımlanan özellik:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+Yukarıdaki örnekte `obj.x` ve `obj.y` silinebilir çünkü `DontDelete` niteliğine
+sahip değillerdir. Aynı nedenle aşağıdakini yapmak da mümkündür:
+
+    // IE hariç çalışır:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - genel değişken
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Burada `a`'yı silmek için bir hile kullanıyoruz. [`this`](#function.this)
+burada genel nesneye işaret ediyor ve `a` değişkenini onun özelliği olarak
+atıyoruz, ve böylece onu silebiliyoruz.
+
+IE (en azından 6-8) bazı hatalar içerdiğinden yukarıdaki örnek çalışmayacaktır.
+
+### Fonksiyon argümanları ve önceden tanımlı özellikler
+
+Fonksiyonlara verilen argümanlar, [`arguments` nesnesi](#function.arguments)
+ve önceden tanımlı özellikler de `DontDelete` niteliğine sahiptir.
+
+    // fonksiyon argümanları ve özellikler:
+    (function (x) {
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+    })(1);
+
+### *Host* nesneler
+
+`Host` nesneler üzerinde kullanıldığında `delete` operatörünün davranışı belirsiz
+olabilir. Standarda göre `host` nesneler istedikleri davranışı uygulayabilirler.
+
+### Sonuç
+
+`delete` operatörünün davranışı genellikle belirsizdir ve güvenle kullanılabileceği
+tek yer sıradanan nesneler üzerinde açıkça tanımlanan özelliklerdir.
diff --git a/doc/tr/function/general.md b/doc/tr/function/general.md
index e45949c1..84d54801 100644
--- a/doc/tr/function/general.md
+++ b/doc/tr/function/general.md
@@ -29,8 +29,8 @@ Bu örnekte *isimsiz fonksiyon* `foo` değişkenine atanır.
 Yukarıdaki `var` anahtar kelimesi bir bildirim olduğu için `foo` değişkeni
 program çalışmadan önce yukarı alınır, program çalıştığında `foo` tanımlanmştır.
 
-Fakat değer ataması program çalışırken gerçekleşeceği için, ilgili satır
-çalıştığında, `foo` değişkeninin değeri varsayılan olarak
+Fakat değer atamaları sadece program çalışırken gerçekleşeceği için, ilgili
+satır çalıştığında, `foo` değişkeninin değeri varsayılan olarak
 [undefined](#core.undefined) olacaktır.
 
 ### İsimli fonksiyon ifadesi
diff --git a/doc/tr/function/scopes.md b/doc/tr/function/scopes.md
index 7b9d4a24..211c45f7 100644
--- a/doc/tr/function/scopes.md
+++ b/doc/tr/function/scopes.md
@@ -14,7 +14,7 @@ kapsamı **bulunmaz**; bu nedenle, dilde sadece *fonksiyon kapsamı* mevcuttur.
 > kullanıldığında `{...}` notasyonu bir nesne değişmezi olarak **değil**
 > blok ifade olarak değerlendirilir. Bu özellik 
 > [otomatik noktalı virgül ilavesi](#core.semicolon) ile birleştiğinde fark
-> edilmesizor hatalara neden olabilir.
+> edilmesi zor hatalara neden olabilir.
 
 JavaScript'te isim uzayları kavramı da bulunmaz, tanımlanan herşey
 *genel olarak paylaşılmış* tek bir isim uzayının içindedir.
@@ -178,7 +178,7 @@ adında bir özel değişken tanımlanmıştır, bu değişken *geçerli nesneyi
 Fonksiyon kapsamlarında aynı zamanda [`arguments`](#function.arguments) adında
 bir değişken tanımlanmıştır ve fonksiyonun argümanlarını içerir.
 
-Örnek olarak bir fonksiyon kapsamında `foo` değişkenine eriğildiğinde JavaScript
+Örnek olarak bir fonksiyon kapsamında `foo` değişkenine erişildiğinde JavaScript
 isim çözümlemeyi aşağıdaki sıra ile yapacaktır:
 
  1. Geçerli kapsamda bir `var foo` ifadesi mevcutsa bu kullanılır.
diff --git a/doc/tr/function/this.md b/doc/tr/function/this.md
index de24190a..b589dc42 100644
--- a/doc/tr/function/this.md
+++ b/doc/tr/function/this.md
@@ -65,7 +65,7 @@ kullanılımı yoktur.
             // this genel nesneye işaret eder
         }
         test();
-    }
+    };
 
 Bir başka yanılgı `test` fonksiyonunun içinde `this` 'in `Foo` 'ya işaret
 edeceğinin sanılmasıdır, ama bu **doğru değildir**.
@@ -79,7 +79,7 @@ değişken oluşturmaktır.
             // Burada this yerine that kullanın
         }
         test();
-    }
+    };
 
 `that` kelimesinin dilde özel bir anlamı yoktur, ama sıklıkla dış kapsamdaki
 `this` 'e işaret etmek için kullanılır. Bu yöntem [`closure`](#function.closures)
diff --git a/doc/tr/index.json b/doc/tr/index.json
index 36a94b8d..9d04c424 100644
--- a/doc/tr/index.json
+++ b/doc/tr/index.json
@@ -6,11 +6,7 @@
         {
             "title": "Giriş",
             "dir": "intro",
-            "articles": [
-                "authors",
-                "contributors",
-                "license"
-            ]
+            "articles": ["index"]
         },
         {
             "title": "Nesneler",
@@ -58,7 +54,8 @@
             "articles": [
                 "eval",
                 "undefined",
-                "semicolon"
+                "semicolon",
+                "delete"
             ]
         },
         {
diff --git a/doc/tr/intro/authors.md b/doc/tr/intro/authors.md
deleted file mode 100644
index 6e53d523..00000000
--- a/doc/tr/intro/authors.md
+++ /dev/null
@@ -1,8 +0,0 @@
-## Yazarlar
-
-Bu rehber, sevimli birer Stack Overflow kullanıcısı olan [Ivo Wetzel][1] (Yazım)
-ve [Zhang Yi Jiang][2] (Tasarım) tarafından hazırlanmıştır.
-
-[1]: http://stackoverflow.com/users/170224/ivo-wetzel
-[2]: http://stackoverflow.com/users/313758/yi-jiang
-
diff --git a/doc/tr/intro/contributors.md b/doc/tr/intro/contributors.md
deleted file mode 100644
index ba517abc..00000000
--- a/doc/tr/intro/contributors.md
+++ /dev/null
@@ -1,8 +0,0 @@
-## Katkıda Bulunanlar
-
- - [Caio Romão][1] (Yazım düzeltmeleri)
- - [Andreas Blixt][2] (Dil düzeltmeleri)
-
-[1]: https://github.com/caio
-[2]: https://github.com/blixt
-
diff --git a/doc/tr/intro/index.md b/doc/tr/intro/index.md
index 303ef891..4bf6a852 100644
--- a/doc/tr/intro/index.md
+++ b/doc/tr/intro/index.md
@@ -2,14 +2,46 @@
 
 **JavaScript Garden** JavaScript programlama dilinin acayiplikleri üzerine
 derlenmiş bir döküman koleksiyonudur. Henüz ustalaşmamış JavaScript 
-programcılarının sıkça yaptığı yanlışlar, dile has ince hatalar ve performans
+programcılarının sıkça yaptığı yanlışlar, dile has incelikler ve performans
 sorunlarına karşı tavsiyeler içerir.
 
 JavaScript Garden'ın amacı size JavaScript öğretmek **değildir**. Bu rehberde
 anlatılan konuları anlamak için JavaScript dilini önceden biliyor olmanız
-şiddetle tavsiye edilir. Eğer JavaScript dilinin temellerini öğrenmek
-istiyorsanız, lütfen Mozilla Programcı Ağı'nda bulunan mükemmel [rehbere][1]
-başvurun.
+gerekir. Eğer JavaScript dilinin temellerini öğrenmek istiyorsanız, lütfen 
+Mozilla Programcı Ağı'nda bulunan mükemmel [rehbere][1] başvurun.
+
+## Yazarlar
+
+Bu rehber, sevimli birer [Stack Overflow][2] kullanıcısı olan [Ivo Wetzel][3] (Yazım)
+ve [Zhang Yi Jiang][4] (Tasarım) tarafından hazırlanmıştır.
+
+## Katkıda Bulunanlar
+
+- [Katkıda Bulunanlar](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## Sunum
+
+JavaScript Garden GitHub üzerinden, ve ayrıca [Cramer Development][7] 
+tarafından desteklenen [JavaScriptGarden.info][8] adresinden sunulmaktadır.
+
+## Lisans
+
+JavaScript Garden [MIT lisansı][9] altında yayınlanmıştır ve [GitHub][10]
+üzerinde bulunmaktadır. Eğer rehberde yanlışlıklar veya yazım hatalarına
+rastlarsanız lütfen [sorunu bize bildirin][11] veya bir `pull request` gönderin.
+Bizi ayrıca Stack Overflow'da [JavaScript sohbet odasında][12] da 
+bulabilirsiniz.
 
 [1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
 
diff --git a/doc/tr/intro/license.md b/doc/tr/intro/license.md
deleted file mode 100644
index a0484d74..00000000
--- a/doc/tr/intro/license.md
+++ /dev/null
@@ -1,13 +0,0 @@
-## Lisans
-
-JavaScript Garden [MIT lisansı][1] altında yayınlanmıştır ve [GitHub][2]
-üzerinde bulunmaktadır. Eğer rehberde yanlışlıklar veya yazım hatalarına
-rastlarsanız lütfen [sorunu bildirin][3] veya bir `pull request` gönderin.
-Bizi ayrıca Stack Overflow'da [JavaScript sohbet kanalında][4] da 
-bulabilirsiniz.
-
-[1]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
-[2]: https://github.com/BonsaiDen/JavaScript-Garden
-[3]: https://github.com/BonsaiDen/JavaScript-Garden/issues
-[4]: http://chat.stackoverflow.com/rooms/17/javascript
-
diff --git a/doc/tr/object/forinloop.md b/doc/tr/object/forinloop.md
index be20e072..ab82e62c 100644
--- a/doc/tr/object/forinloop.md
+++ b/doc/tr/object/forinloop.md
@@ -32,7 +32,7 @@ nesnesinin [`hasOwnProperty`](#object.hasownproperty) metodu ile yapılır.
 
 Doğru kullanım bu yeni versiyonda gösterildiği gibidir. `hasOwnProperty` kontrol
 edildiği için **sadece** `moo` yazacaktır. `hasOwnProperty` kullanılmaz ise ve
-`Object.protype` 'ın baz özellikleri değiştirilmişse, program bazı hatalara
+`Object.prototype` 'ın baz özellikleri değiştirilmişse, program bazı hatalara
 yatkın olabilir.
 
 Bunu yapan ve yaygın olarak kullanılan bir JavaScript sistemi [Prototype][1]
diff --git a/doc/tr/object/general.md b/doc/tr/object/general.md
index b112a582..fd99ecaf 100644
--- a/doc/tr/object/general.md
+++ b/doc/tr/object/general.md
@@ -4,7 +4,7 @@ JavaScript'te iki istisna dışında her şey bir nesne olarak davranır;
 bu istisnalar da [`null`](#core.undefined) ve [`undefined`](#core.undefined) 
 'dır.
 
-    false.toString() // 'false'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
     
     function Foo(){}
@@ -21,7 +21,7 @@ Bu hatayı aşıp sayı sabitlerinin de nesne olarak davranmasını sağlamak i
 uygulanabilecek bazı çözümler vardır. 
 
     2..toString(); // ikinci nokta doğru şekilde algılanır
-    2 .toString(); // noktanın solundki boşluğa dikkat edin
+    2 .toString(); // noktanın solundaki boşluğa dikkat edin
     (2).toString(); // ilk önce 2 değerlendirilir
 
 ### Bir veri türü olarak nesneler
@@ -44,7 +44,7 @@ hiçbir [baz özelliğe](#object.hasownproperty) sahip olmayacaktır.
 Bir nesnenin özelliklerine iki yolla erişilebilir, ya nokta notasyonu ile veya
 köşeli parantez notasyonu ile.
     
-    var foo = {name: 'Kitten'}
+    var foo = {name: 'kitten'}
     foo.name; // kitten
     foo['name']; // kitten
     
@@ -61,8 +61,8 @@ açabilecek özellik isimlerinin kullanılmasına izin vermesidir.
 ### Özellikleri silmek
 
 Bir nesnenin özelliklerinden birini silmenin tek yolu `delete` operatörünü 
-kullanmaktır; özelliğe `undefined` veya `null` değerlerini atamak **sadece**
-özelliğin değerini kaldırır, anahtarı değil.
+kullanmaktır; özelliğe `undefined` veya `null` değerlerini atamak sadece
+özelliğin *değerini* kaldırır, *anahtarı* değil.
 
     var obj = {
         bar: 1,
diff --git a/doc/tr/object/hasownproperty.md b/doc/tr/object/hasownproperty.md
index e5eb5df0..634b3695 100644
--- a/doc/tr/object/hasownproperty.md
+++ b/doc/tr/object/hasownproperty.md
@@ -42,8 +42,9 @@ doğru sonuç alabilmek için `hasOwnProperty `*haricen* kullanılmalıdır.
 
     foo.hasOwnProperty('bar'); // her zaman false verir
 
-    // hasOwnProperty haricen kullanıldığında 'this' foo olur
-    {}.hasOwnProperty.call(foo, 'bar'); // true
+    // hasOwnProperty başka bir nesne üzerinde
+    // kullanıldığında 'this' foo olur
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
 
 ### Sonuç
 
diff --git a/doc/tr/object/prototype.md b/doc/tr/object/prototype.md
index a158176a..d8b8522a 100644
--- a/doc/tr/object/prototype.md
+++ b/doc/tr/object/prototype.md
@@ -39,7 +39,7 @@ yapılmasıdır.
     // Sonuçta ortaya çıkan prototip zinciri
     test [bir Bar sınıfı nesnesi]
         Bar.prototype [bir Foo sınıfı nesnesi] 
-            { foo: 'Hello World' }
+            { foo: 'Hello World', value: 42 }
             Foo.prototype
                 { method: ... }
                 Object.prototype
@@ -63,7 +63,7 @@ nesneyi kullanmasıdır; bu nedenle, tüm `Bar` nesneleri **aynı** `value`
 Bir nesnenin özelliklerine erişildiğinde, JavaScript, istenen isimdeki özelliği
 bulana kadar prototip zincirinde **yukarı** doğru dolaşır.
 
-Zincirin en üstüne ulaştığında (yani `Object.protype`) ve hala istenen özelliği
+Zincirin en üstüne ulaştığında (yani `Object.prototype`) ve hala istenen özelliği
 bulamamışsa sonuç olarak [`undefined`](#core.undefined) verecektir.
 
 ### prototype özelliği
@@ -90,7 +90,7 @@ yapıldığında da prototip zinciri üzerindeki **tüm** özelliklere bakılaca
 
 ### Temel prototiplerin genişletilmesi
 
-Sıklıkla yapılan bir hata `Object.protype` 'ı veya diğer baz prototipleri 
+Sıklıkla yapılan bir hata `Object.prototype` 'ı veya diğer baz prototipleri 
 genişletmektir.
 
 Bu tekniğe [*monkey patching*][1] denir ve *kapsüllemeyi* bozar. Bu teknik
diff --git a/doc/tr/other/timeouts.md b/doc/tr/other/timeouts.md
index 594ba83c..ef5de1c9 100644
--- a/doc/tr/other/timeouts.md
+++ b/doc/tr/other/timeouts.md
@@ -111,8 +111,8 @@ olarak `eval` kullanılır.
 
 > **Not:** Zamanlama fonksiyonları ECMAScript Standartında bulunmadığı için,
 > bir katar argümanı almaları durumundaki çalışma şekilleri JavaScript motorları
-> arasında farklılık gösterebilir. Gerçekten de, Microsoft'un JScript motoru
-> `eval` yerine `Function` oluşturucusunu kullanır.
+> arasında farklılık gösterebilir. Mesela, Microsoft'un JScript motoru `eval`
+> yerine `Function` oluşturucusunu kullanır.
 
     function foo() {
         // setTimeOut ile bu fonksiyon çağrılacaktır
@@ -140,10 +140,10 @@ kullanılması tavsiye **edilmez**.
 
     // Bunu yerine isimsiz bir fonksiyon kullanın
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
-> **Not:** `setTimeout(foo, 1000, a, b, c)` sentaksının kullanılması da mümkün
+> **Not:** `setTimeout(foo, 1000, 1, 2, 3)` sentaksının kullanılması da mümkün
 > olmasına karşın tavsiye edilmez, çünkü bu kullanım [metodlarla](#function.this)
 > birlikte fark edilmesi zor hatalara neden olabilir.
 
@@ -157,5 +157,4 @@ bulunduran bir *isimsiz fonksiyon* kullanılmalıdır.
 Ayrıca, `setInterval` fonksiyonu çalışan JavaScript programı tarafından bloke
 olmadığı için tercih edilmemelidir.
 
-[1]: http://en.wikipedia.org/wiki/Document_Object_Model 
-
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
diff --git a/doc/tr/types/equality.md b/doc/tr/types/equality.md
index a0d5d296..3240a54e 100644
--- a/doc/tr/types/equality.md
+++ b/doc/tr/types/equality.md
@@ -3,11 +3,11 @@
 JavaScript'de nesnelerin değerlerinin eşitliğini kontrol etmenin iki farklı yolu
 vardır. 
 
-### Eşittir operatörü
+### Eşitlik operatörü
 
-Eşittir operatörü iki adet eşittir işaretinden oluşur: `==`
+Eşitlik operatörü iki adet eşittir işaretinden oluşur: `==`
 
-JavaScript *weakly typed* bir dildir, bu nedenle, eşittir operatörü ile
+JavaScript *weakly typed* bir dildir. Bu nedenle, eşitlik operatörü ile
 değişkenleri karşılaştırırken **tip dönüşümü** yapar.
 
     ""           ==   "0"           // false
diff --git a/doc/zh/array/general.md b/doc/zh/array/general.md
index e7140e8f..5e222e8d 100755
--- a/doc/zh/array/general.md
+++ b/doc/zh/array/general.md
@@ -1,6 +1,6 @@
 ##数组遍历与属性
 
-虽然在 JavaScript 中数组是是对象，但是没有好的理由去使用 [`for in` 循环](#object.forinloop) 遍历数组。
+虽然在 JavaScript 中数组是对象，但是没有好的理由去使用 [`for in` 循环](#object.forinloop) 遍历数组。
 相反，有一些好的理由**不去**使用 `for in` 遍历数组。
 
 > **注意:** JavaScript 中数组**不是** *关联数组*。
diff --git a/doc/zh/function/arguments.md b/doc/zh/function/arguments.md
index b86e72f6..ac6967eb 100755
--- a/doc/zh/function/arguments.md
+++ b/doc/zh/function/arguments.md
@@ -9,7 +9,7 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 `arguments` 变量**不是**一个数组（`Array`）。
 尽管在语法上它有数组相关的属性 `length`，但它不从 `Array.prototype` 继承，实际上它是一个对象（`Object`）。
 
-因此，无法对 `arguments` 变量使用标准的数组方法，比如 `push`, `pop` 或者 `slice`。
+因此，无法对 `arguments` 变量使用标准的数组方法，比如 `push`、`pop` 或者 `slice`。
 虽然使用 `for` 循环遍历也是可以的，但是为了更好的使用数组方法，最好把它转化为一个真正的数组。
 
 ###转化为数组
@@ -22,13 +22,13 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 
 ###传递参数
 
-下面将参数从一个函数传递到另一个函数，是推荐的做法。
+下面是将参数从一个函数传递到另一个函数的推荐做法。
 
     function foo() {
         bar.apply(null, arguments);
     }
     function bar(a, b, c) {
-        // do stuff here
+        // 干活
     }
 
 另一个技巧是同时使用 `call` 和 `apply`，创建一个快速的解绑定包装器。
@@ -39,7 +39,7 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
         console.log(this, a, b, c);
     };
 
-    // Create an unbound version of "method" 
+    // 创建一个解绑定的 "method"
     // 输入参数为: this, arg1, arg2...argN
     Foo.method = function() {
 
@@ -77,10 +77,9 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 
 ### 性能真相
 
-`arguments` 对象总会被创建，除了两个特殊情况 - 作为局部变量声明和作为形式参数。
-而不管它是否有被使用。
+不管它是否有被使用，`arguments` 对象总会被创建，除了两个特殊情况 - 作为局部变量声明和作为形式参数。
 
-`arguments` 的 *getters* 和 *setters* 方法总会被创佳；因此使用 `arguments` 对性能不会有什么影响。
+`arguments` 的 *getters* 和 *setters* 方法总会被创建；因此使用 `arguments` 对性能不会有什么影响。
 除非是需要对 `arguments` 对象的属性进行多次访问。
 
 > **ES5 提示:** 这些 *getters* 和 *setters* 在严格模式下（strict mode）不会被创建。
@@ -94,19 +93,19 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 	  return [a, arguments[0]];
 	}
 	var pair = f(17);
-	assert(pair[0] === 42);
-	assert(pair[1] === 17);
+	console.assert(pair[0] === 42);
+	console.assert(pair[1] === 17);
 
 然而，的确有一种情况会显著的影响现代 JavaScript 引擎的性能。这就是使用 `arguments.callee`。
 
     function foo() {
-        arguments.callee; // do something with this function object
-        arguments.callee.caller; // and the calling function object
+        arguments.callee; // 使用这个函数对象
+        arguments.callee.caller; // 以及这个函数对象的调用者
     }
 
     function bigLoop() {
         for(var i = 0; i < 100000; i++) {
-            foo(); // Would normally be inlined...
+            foo(); // 通常情况会作为内联函数...
         }
     }
 
diff --git a/doc/zh/function/closures.md b/doc/zh/function/closures.md
index b547be0d..df474a65 100755
--- a/doc/zh/function/closures.md
+++ b/doc/zh/function/closures.md
@@ -3,6 +3,8 @@
 闭包是 JavaScript 一个非常重要的特性，这意味着当前作用域**总是**能够访问外部作用域中的变量。
 因为 [函数](#function.scopes) 是 JavaScript 中唯一拥有自身作用域的结构，因此闭包的创建依赖于函数。
 
+> 译者注：ES2015 中增加了块级作用域。
+
 ###模拟私有变量
 
     function Counter(start) {
@@ -23,7 +25,7 @@
     foo.get(); // 5
 
 这里，`Counter` 函数返回两个闭包，函数 `increment` 和函数 `get`。 这两个函数都维持着
-对外部作用域 `Counter` 的引用，因此总可以访问此作用域内定义的变量 `count`.
+对外部作用域 `Counter` 的引用，因此总可以访问此作用域内定义的变量 `count`。
 
 ###为什么不可以在外部访问私有变量
 
@@ -44,24 +46,24 @@
 
     for(var i = 0; i < 10; i++) {
         setTimeout(function() {
-            console.log(i);  
+            console.log(i);
         }, 1000);
     }
 
 上面的代码不会输出数字 `0` 到 `9`，而是会输出数字 `10` 十次。
 
-当 `console.log` 被调用的时候，*匿名*函数保持对外部变量 `i` 的引用，此时 `for`循环已经结束， `i` 的值被修改成了 `10`. 
+当 `console.log` 被调用的时候，*匿名*函数保持对外部变量 `i` 的引用，此时 `for`循环已经结束， `i` 的值被修改成了 `10`。
 
 为了得到想要的结果，需要在每次循环中创建变量 `i` 的**拷贝**。
 
 ###避免引用错误
 
-为了正确的获得循环序号，最好使用 [匿名包裹器](#function.scopes)（**[译者注][30]：**其实就是我们通常说的自执行匿名函数）。
+为了正确的获得循环序号，最好使用 [匿名包装器](#function.scopes)（**[译者注][30]：**其实就是我们通常说的自执行匿名函数）。
 
     for(var i = 0; i < 10; i++) {
         (function(e) {
             setTimeout(function() {
-                console.log(e);  
+                console.log(e);
             }, 1000);
         })(i);
     }
@@ -70,14 +72,14 @@
 
 当传递给 `setTimeout` 的匿名函数执行时，它就拥有了对 `e` 的引用，而这个值是**不会**被循环改变的。
 
-有另一个方法完成同样的工作；那就是从匿名包装器中返回一个函数。这和上面的代码效果一样。
+有另一个方法完成同样的工作，那就是从匿名包装器中返回一个函数。这和上面的代码效果一样。
 
     for(var i = 0; i < 10; i++) {
         setTimeout((function(e) {
             return function() {
                 console.log(e);
-            }
-        })(i), 1000)
+            };
+        })(i), 1000);
     }
 
 	
diff --git a/doc/zh/function/general.md b/doc/zh/function/general.md
index 41a63a3d..04414900 100755
--- a/doc/zh/function/general.md
+++ b/doc/zh/function/general.md
@@ -1,16 +1,16 @@
 ##函数声明与表达式
 
-函数是JavaScript中的一等对象，这意味着可以把函数像其它值一样传递。
-一个常见的用法是把*匿名函数*作为回调函数传递对异步函数中。
+函数是 JavaScript 中的一等对象，这意味着可以把函数像其它值一样传递。
+一个常见的用法是把*匿名函数*作为回调函数传递到异步函数中。
 
 ###函数声明
 
     function foo() {}
 
 上面的方法会在执行前被 [解析(hoisted)](#function.scopes)，因此它存在于当前上下文的*任意*一个地方，
-即使在函数定义体的上面被调用也是对的。 
+即使在函数定义体的上面被调用也是对的。
 
-    foo(); // 正常运行，因为foo在代码运行前已经被创建
+    foo(); // 正常运行，因为 foo 在代码运行前已经被创建
     function foo() {}
 
 ### 函数赋值表达式
@@ -39,5 +39,6 @@
 `bar` 函数声明外是不可见的，这是因为我们已经把函数赋值给了 `foo`；
 然而在 `bar` 内部依然可见。这是由于 JavaScript 的 [命名处理](#function.scopes) 所致，
 函数名在函数内*总是*可见的。
+> **注意: **在 IE8 及 IE8 以下版本浏览器 bar 在外部也是可见的，是因为浏览器对命名函数赋值表达式进行了错误的解析，
+> 解析成两个函数 `foo` 和 `bar`
 
-[30]: http://cnblogs.com/sanshi/
diff --git a/doc/zh/function/scopes.md b/doc/zh/function/scopes.md
index 4a66188d..32fe9370 100755
--- a/doc/zh/function/scopes.md
+++ b/doc/zh/function/scopes.md
@@ -136,7 +136,7 @@ JavaScript 会**提升**变量声明。这意味着 `var` 表达式和 `function
 
 没有块级作用域不仅导致 `var` 表达式被从循环内移到外部，而且使一些 `if` 表达式更难看懂。
 
-在原来代码中，`if` 表达式看起来修改了*全部变量* `goo`，实际上在提升规则被应用后，却是在修改*局部变量*。
+在原来代码中，`if` 表达式看起来修改了*全局变量* `goo`，实际上在提升规则被应用后，却是在修改*局部变量*。
 
 如果没有提升规则（hoisting）的知识，下面的代码看起来会抛出异常 `ReferenceError`。
 
@@ -214,7 +214,7 @@ JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别
 推荐使用*匿名包装器*（**[译者注][30]：**也就是自执行的匿名函数）来创建命名空间。这样不仅可以防止命名冲突，
 而且有利于程序的模块化。
 
-另外，使用全局变量被认为是**不好的习惯**。这样的代码倾向于产生错误和带来高的维护成本。
+另外，使用全局变量被认为是**不好的习惯**。这样的代码容易产生错误并且维护成本较高。
 
 [1]: http://net.tutsplus.com/tutorials/javascript-ajax/quick-tip-javascript-hoisting-explained/
 [30]: http://cnblogs.com/sanshi/
diff --git a/doc/zh/function/this.md b/doc/zh/function/this.md
index dd700690..967c9dfb 100755
--- a/doc/zh/function/this.md
+++ b/doc/zh/function/this.md
@@ -9,7 +9,8 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 当在全部范围内使用 `this`，它将会指向*全局*对象。
 
-> **[译者注][30]：**浏览器中运行的 JavaScript 脚本，这个全局对象是 `window`。
+> **[译者注][30]：**浏览器中运行的 JavaScript 脚本，这个全局对象是 `window`；
+> 在 nodejs 环境中运行的 Javascript 脚本，这个全局对象是 `global`。
 
 ###函数调用
 
@@ -22,13 +23,13 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 ###方法调用
 
-    test.foo(); 
+    test.foo();
 
 这个例子中，`this` 指向 `test` 对象。
 
 ###调用构造函数
 
-    new foo(); 
+    new foo();
 
 如果函数倾向于和 `new` 关键词一块使用，则我们称这个函数是 [构造函数](#function.constructors)。
 在函数内部，`this` 指向*新创建*的对象。
@@ -39,7 +40,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
                           
     var bar = {};
     foo.apply(bar, [1, 2, 3]); // 数组将会被扩展，如下所示
-    foo.call(bar, 1, 2, 3); // 传递到foo的参数是：a = 1, b = 2, c = 3
+    foo.call(bar, 1, 2, 3); // 传递到 foo 的参数是：a = 1, b = 2, c = 3
 
 当使用 `Function.prototype` 上的 `call` 或者 `apply` 方法时，函数内的 `this` 将会被
 **显式设置**为函数调用的第一个参数。
@@ -53,14 +54,14 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 ###常见误解
 
 尽管大部分的情况都说的过去，不过第一个规则（**[译者注][30]：**这里指的应该是第二个规则，也就是直接调用函数时，`this` 指向全局对象）
-被认为是JavaScript语言另一个错误设计的地方，因为它**从来**就没有实际的用途。
+被认为是 JavaScript 语言另一个错误设计的地方，因为它**从来**就没有实际的用途。
 
     Foo.method = function() {
         function test() {
             // this 将会被设置为全局对象（译者注：浏览器环境中也就是 window 对象）
         }
         test();
-    }
+    };
 
 一个常见的误解是 `test` 中的 `this` 将会指向 `Foo` 对象，实际上**不是**这样子的。
 
@@ -72,7 +73,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
             // 使用 that 来指向 Foo 对象
         }
         test();
-    }
+    };
 
 `that` 只是我们随意起的名字，不过这个名字被广泛的用来指向外部的 `this` 对象。
 在 [闭包](#function.closures) 一节，我们可以看到 `that` 可以作为参数传递。
@@ -86,7 +87,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 上例中，`test` 就像一个普通的函数被调用；因此，函数内的 `this` 将不再被指向到 `someObject` 对象。
 
-虽然 `this` 的晚绑定特性似乎并不友好，但是这确实[基于原型继承](#object.prototype)赖以生存的土壤。
+虽然 `this` 的晚绑定特性似乎并不友好，但这确实是[基于原型继承](#object.prototype)赖以生存的土壤。
 
     function Foo() {}
     Foo.prototype.method = function() {};
diff --git a/doc/zh/intro/contributors.md b/doc/zh/intro/contributors.md
index fd049216..a704d4a2 100755
--- a/doc/zh/intro/contributors.md
+++ b/doc/zh/intro/contributors.md
@@ -1,7 +1,6 @@
 ##贡献者
 
- - [Caio Romão][1] （拼写检查）
- - [Andreas Blixt][2] （语言修正）
+- [贡献者](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
 
 ##中文翻译
  - [三生石上][29]
diff --git a/doc/zh/intro/license.md b/doc/zh/intro/license.md
index 33aa7406..057dd8a6 100755
--- a/doc/zh/intro/license.md
+++ b/doc/zh/intro/license.md
@@ -1,7 +1,7 @@
 ##许可
 
 JavaScript 秘密花园在 [MIT license][1] 许可协议下发布，并存放在 [GitHub][2] 开源社区。
-如果你发现错误或者打字错误，请[新建一个任务单][3]或者发一个抓取请求。
+如果你发现错误，请[新建一个任务单][3]或者发一个抓取请求（Pull Request）。
 你也可以在 Stack Overflow 的 [JavaScript 聊天室][4]找到我们。
 
 [1]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
diff --git a/doc/zh/object/forinloop.md b/doc/zh/object/forinloop.md
index ea7d389d..16f9faaa 100755
--- a/doc/zh/object/forinloop.md
+++ b/doc/zh/object/forinloop.md
@@ -30,12 +30,11 @@
 如果不使用 `hasOwnProperty`，则这段代码在原生对象原型（比如 `Object.prototype`）被扩展时可能会出错。
 
 一个广泛使用的类库 [Prototype][1] 就扩展了原生的 JavaScript 对象。
-因此，但这个类库被包含在页面中时，不使用 `hasOwnProperty` 过滤的 `for in` 循环难免会出问题。
+因此，当这个类库被包含在页面中时，不使用 `hasOwnProperty` 过滤的 `for in` 循环难免会出问题。
 
 ###总结
 
 推荐**总是**使用 `hasOwnProperty`。不要对代码运行的环境做任何假设，不要假设原生对象是否已经被扩展了。
 
 [1]: http://www.prototypejs.org/
-[30]: http://cnblogs.com/sanshi/
 
diff --git a/doc/zh/object/general.md b/doc/zh/object/general.md
index b75b0fea..3ada17fa 100755
--- a/doc/zh/object/general.md
+++ b/doc/zh/object/general.md
@@ -1,15 +1,15 @@
 ##对象使用和属性
 
-JavaScript 中所有变量都是对象，除了两个例外 [`null`](#core.undefined) 和 [`undefined`](#core.undefined)。
+JavaScript 中所有变量都可以当作对象使用，除了两个例外 [`null`](#core.undefined) 和 [`undefined`](#core.undefined)。
 
-    false.toString() // 'false'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
     
     function Foo(){}
     Foo.bar = 1;
     Foo.bar; // 1
 
-一个常见的误解是数字的字面值（literal）不是对象。这是因为 JavaScript 解析器的一个错误，
+一个常见的误解是数字的字面值（literal）不能当作对象使用。这是因为 JavaScript 解析器的一个错误，
 它试图将*点操作符*解析为浮点数字面值的一部分。
 
     2.toString(); // 出错：SyntaxError
@@ -25,7 +25,7 @@ JavaScript 中所有变量都是对象，除了两个例外 [`null`](#core.undef
 JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命名的键与值的对应关系。
 
 使用对象的字面语法 - `{}` - 可以创建一个简单对象。这个新创建的对象从 `Object.prototype`
-[继承](#object.prototype)下面，没有任何[自定义属性](#object.hasownproperty)。
+[继承](#object.prototype)下来，没有任何[自定义属性](#object.hasownproperty)。
 
     var foo = {}; // 一个空对象
 
@@ -34,9 +34,9 @@ JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命
 
 ### 访问属性
 
-有两种方式来访问对象的属性，点操作符或者中括号操作符。
+有两种方式来访问对象的属性，点操作符和中括号操作符。
     
-    var foo = {name: 'Kitten'}
+    var foo = {name: 'kitten'}
     foo.name; // kitten
     foo['name']; // kitten
     
diff --git a/doc/zh/object/hasownproperty.md b/doc/zh/object/hasownproperty.md
index 935d7aa0..c9b3fc21 100755
--- a/doc/zh/object/hasownproperty.md
+++ b/doc/zh/object/hasownproperty.md
@@ -8,8 +8,8 @@
 
 `hasOwnProperty` 是 JavaScript 中唯一一个处理属性但是**不**查找原型链的函数。
 
-    // 修改Object.prototype
-    Object.prototype.bar = 1; 
+    // 修改 Object.prototype
+    Object.prototype.bar = 1;
     var foo = {goo: undefined};
     
     foo.bar; // 1
@@ -18,8 +18,8 @@
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-只有 `hasOwnProperty` 可以给出正确和期望的结果，这在遍历对象的属性时会很有用。
-**没有**其它方法可以用来排除原型链上的属性，而不是定义在对象*自身*上的属性。
+只有 `hasOwnProperty` 可以给出正确和期望的结果。可以查看 [`for in` 循环](#object.forinloop)
+章节来获取关于在迭代遍历对象属性的时候，何时使用 `hasOwnProperty` 的更多信息。
 
 ###`hasOwnProperty` 作为属性
 
@@ -35,8 +35,8 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 
     foo.hasOwnProperty('bar'); // 总是返回 false
 
-    // 使用其它对象的 hasOwnProperty，并将其上下为设置为foo
-    {}.hasOwnProperty.call(foo, 'bar'); // true
+    // 使用其它对象的 hasOwnProperty，并将其上下文设置为 foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
 
 ###结论
 
@@ -44,4 +44,3 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 同时在使用 [`for in` loop](#object.forinloop) 遍历对象时，推荐**总是**使用 `hasOwnProperty` 方法，
 这将会避免[原型](#object.prototype)对象扩展带来的干扰。
 
-[30]: http://cnblogs.com/sanshi/
diff --git a/doc/zh/object/prototype.md b/doc/zh/object/prototype.md
index a9e09841..25a1d89d 100755
--- a/doc/zh/object/prototype.md
+++ b/doc/zh/object/prototype.md
@@ -1,9 +1,9 @@
 ##原型
 
-JavaScript 不包含传统的类继承模型，而是使用 *prototypal* 原型模型。
+JavaScript 不包含传统的类继承模型，而是使用 *prototype* 原型模型。
 
 虽然这经常被当作是 JavaScript 的缺点被提及，其实基于原型的继承模型比传统的类继承还要强大。
-实现传统的类继承模型是很简单，但是实现 JavaScript 中的原型继承则要困难的多。
+例如，很容易通过原型继承实现传统的类继承模型，但是反过来，通过传统的类继承模型来实现原型继承模型就困难得多。
 (It is for example fairly trivial to build a classic model on top of it, while the
 other way around is a far more difficult task.)
 
@@ -23,19 +23,19 @@ other way around is a far more difficult task.)
 
     function Bar() {}
 
-    // 设置Bar的prototype属性为Foo的实例对象
+    // 设置 Bar 的 prototype 属性为 Foo 的实例对象
     Bar.prototype = new Foo();
     Bar.prototype.foo = 'Hello World';
 
-    // 修正Bar.prototype.constructor为Bar本身
+    // 修正 Bar.prototype.constructor 为 Bar 本身
     Bar.prototype.constructor = Bar;
 
-    var test = new Bar() // 创建Bar的一个新实例
+    var test = new Bar(); // 创建Bar的一个新实例
 
     // 原型链
     test [Bar的实例]
         Bar.prototype [Foo的实例] 
-            { foo: 'Hello World' }
+            { foo: 'Hello World', value: 42 }
             Foo.prototype
                 {method: ...};
                 Object.prototype
@@ -46,7 +46,7 @@ other way around is a far more difficult task.)
 需要注意的是 `new Bar()` **不会**创造出一个新的 `Foo` 实例，而是
 重复使用它原型上的那个实例；因此，所有的 `Bar` 实例都会共享**相同**的 `value` 属性。
 
-> **注意:** **不要**使用 `Bar.prototype = Foo`，因为这不会执行 `Foo` 的原型，而是指向函数 `Foo`。
+> **注意:** **不要**使用 `Bar.prototype = Foo`，因为这不会指向 `Foo` 的原型，而是指向函数 `Foo`。
 > 因此原型链将会回溯到 `Function.prototype` 而不是 `Foo.prototype`，因此 `method` 将不会在 Bar 的原型链上。
 
 ###属性查找
@@ -58,7 +58,7 @@ other way around is a far more difficult task.)
 ###原型属性
 
 当原型属性用来创建原型链时，可以把**任何**类型的值赋给它（prototype）。
-然而将原子类型赋给 prototype 的操作将会被忽略。
+然而将原子类型（primitives）赋给 prototype 的操作将会被忽略。
 
     function Foo() {}
     Foo.prototype = 1; // 无效
@@ -67,16 +67,16 @@ other way around is a far more difficult task.)
 
 ###性能
 
-如果一个属性在原型链的上端，则对于查找时间将带来不利影响。特别的，试图获取一个不存在的属性将会遍历整个原型链。
+如果一个属性在原型链的上端，则对于查找时间将带来不利影响。注意，试图获取一个不存在的属性将会遍历整个原型链。
 
 并且，当使用 [`for in`](#object.forinloop) 循环遍历对象的属性时，原型链上的**所有**属性都将被访问。
 
 ###扩展内置类型的原型
 
-一个错误特性被经常使用，那就是扩展 `Object.prototype` 或者其他内置类型的原型对象。
+扩展 `Object.prototype` 或者其他内置类型的原型对象，作为一个错误特性，经常被使用。
 
 这种技术被称之为 [monkey patching][1] 并且会破坏*封装*。虽然它被广泛的应用到一些 JavaScript 类库中比如 [Prototype][2],
-但是我仍然不认为为内置类型添加一些*非标准*的函数是个好主意。
+但是我仍然不赞同为内置类型添加一些*非标准*的函数。
 
 扩展内置类型的**唯一**理由是为了和新的 JavaScript 保持一致，比如 [`Array.forEach`][3]。
 
diff --git a/doc/zh/other/timeouts.md b/doc/zh/other/timeouts.md
index 5993e362..4b2cc5d0 100755
--- a/doc/zh/other/timeouts.md
+++ b/doc/zh/other/timeouts.md
@@ -35,14 +35,14 @@
 `setTimeout` 只会执行回调函数一次，不过 `setInterval` - 正如名字建议的 - 会每隔 `X` 毫秒执行函数一次。
 但是却不鼓励使用这个函数。
 
-当回调函数的执行被阻塞时，`setInterval` 仍然会发布更多的毁掉指令。在很小的定时间隔情况下，这会导致回调函数被堆积起来。
+当回调函数的执行被阻塞时，`setInterval` 仍然会发布更多的回调指令。在很小的定时间隔情况下，这会导致回调函数被堆积起来。
 
     function foo(){
         // 阻塞执行 1 秒
     }
     setInterval(foo, 100);
 
-上面代码中，`foo` 会执行一次随后被阻塞了一分钟。
+上面代码中，`foo` 会执行一次随后被阻塞了一秒钟。
 
 在 `foo` 被阻塞的时候，`setInterval` 仍然在组织将来对回调函数的调用。
 因此，当第一次 `foo` 函数调用结束时，已经有 **10** 次函数调用在等待执行。
@@ -101,7 +101,7 @@
     }
     bar();
 
-由于 `eval` 在这种情况下不是被[直接](#core.eval)调用，因此传递到 `setTimeout` 的字符串会自*全局作用域*中执行；
+由于 `eval` 在这种情况下不是被[直接](#core.eval)调用，因此传递到 `setTimeout` 的字符串会到*全局作用域*中执行；
 因此，上面的回调函数使用的不是定义在 `bar` 作用域中的局部变量 `foo`。
 
 建议**不要**在调用定时器函数时，为了向回调函数传递参数而使用字符串的形式。
@@ -113,10 +113,10 @@
 
     // 可以使用匿名函数完成相同功能
     setTimeout(function() {
-        foo(a, b, c);
+        foo(1, 2, 3);
     }, 1000)
 
-> **注意:** 虽然也可以使用这样的语法 `setTimeout(foo, 1000, a, b, c)`，
+> **注意:** 虽然也可以使用这样的语法 `setTimeout(foo, 1000, 1, 2, 3)`，
 > 但是不推荐这么做，因为在使用对象的[属性方法](#function.this)时可能会出错。
 >（**译者注：**这里说的是属性方法内，`this` 的指向错误）
 
diff --git a/doc/zh/types/equality.md b/doc/zh/types/equality.md
index eef0e9da..006c02bf 100755
--- a/doc/zh/types/equality.md
+++ b/doc/zh/types/equality.md
@@ -18,16 +18,16 @@ JavaScript 是*弱类型*语言，这就意味着，等于操作符会为了比
     null         ==   undefined     // true
     " \t\r\n"    ==   0             // true
 
-上面的表格展示了强类型转换，这也是使用 `==` 被广泛认为是不好编程习惯的主要原因，
+上面的表格展示了强制类型转换，这也是使用 `==` 被广泛认为是不好编程习惯的主要原因，
 由于它的复杂转换规则，会导致难以跟踪的问题。
 
-此外，强制类型转换也会带来性能消耗，比如一个字符串为了和一个数组进行比较，必须事先被强制转换为数字。
+此外，强制类型转换也会带来性能消耗，比如一个字符串为了和一个数字进行比较，必须事先被强制转换为数字。
 
 ###严格等于操作符
 
 严格等于操作符由**三**个等号组成：`===`
 
-不想普通的等于操作符，严格等于操作符**不会**进行强制类型转换。
+不像普通的等于操作符，严格等于操作符**不会**进行强制类型转换。
 
     ""           ===   "0"           // false
     0            ===   ""            // false
@@ -53,6 +53,7 @@ JavaScript 是*弱类型*语言，这就意味着，等于操作符会为了比
 
 这里等于操作符比较的**不是**值是否相等，而是是否属于同一个**身份**；也就是说，只有对象的同一个实例才被认为是相等的。
 这有点像 Python 中的 `is` 和 C 中的指针比较。
+> **注意:**为了更直观的看到`==`和`===`的区别,可以参见[JavaScript Equality Table](http://dorey.github.io/JavaScript-Equality-Table/) 
 
 ###结论
 
diff --git a/doc/zh/types/instanceof.md b/doc/zh/types/instanceof.md
index 191c43c4..e2783ef7 100755
--- a/doc/zh/types/instanceof.md
+++ b/doc/zh/types/instanceof.md
@@ -12,7 +12,7 @@
     new Bar() instanceof Bar; // true
     new Bar() instanceof Foo; // true
 
-    // 如果仅仅设置 Bar.prototype 为函数 Foo 本省，而不是 Foo 构造函数的一个实例
+    // 如果仅仅设置 Bar.prototype 为函数 Foo 本身，而不是 Foo 构造函数的一个实例
     Bar.prototype = Foo;
     new Bar() instanceof Foo; // false
 
diff --git a/doc/zh/types/typeof.md b/doc/zh/types/typeof.md
index 8a322b2f..fec6fcf7 100755
--- a/doc/zh/types/typeof.md
+++ b/doc/zh/types/typeof.md
@@ -6,7 +6,7 @@
 尽管 `instanceof` 还有一些极少数的应用场景，`typeof` 只有一个实际的应用（**[译者注][30]：**这个实际应用是用来检测一个对象是否已经定义或者是否已经赋值），
 而这个应用却**不是**用来检查对象的类型。
 
-> **注意:** 由于 `typeof` 也可以像函数的语法被调用，比如 `typeof(obj)`，但这并是一个函数调用。
+> **注意:** 由于 `typeof` 也可以像函数的语法被调用，比如 `typeof(obj)`，但这并不是一个函数调用。
 > 那两个小括号只是用来计算一个表达式的值，这个返回值会作为 `typeof` 操作符的一个操作数。
 > 实际上**不存在**名为 `typeof` 的函数。
 
@@ -75,7 +75,7 @@ JavaScript 标准文档只给出了一种获取 `[[Class]]` 值的方法，那
 	Object.prototype.toString.call(undefined)	// "[object Undefined]"
 	
 	
-###测试为定义变量
+###测试未定义变量
 
     typeof foo !== 'undefined'
 
diff --git a/doc/zhtw/array/constructor.md b/doc/zhtw/array/constructor.md
new file mode 100644
index 00000000..fd952497
--- /dev/null
+++ b/doc/zhtw/array/constructor.md
@@ -0,0 +1,28 @@
+## `Array` 的建構函式
+
+`Array` 的建構函式在處理參數上一直有模糊的地帶，所以建議使用 `array`的字面語法來使用 - `[]` - 來新增一個的Array
+
+    [1, 2, 3]; // 結果: [1, 2, 3]
+    new Array(1, 2, 3); // 結果: [1, 2, 3]
+
+    [3]; // 結果: [3]
+    new Array(3); // 結果: []
+    new Array('3') // 結果: ['3']
+
+在上面的範例 `new Array(3)` 當只有一個參數傳入到 `Array` 的建構函數
+且那個參數是一個數字，建構函數會回傳空值
+但是 `Array` 長度的屬性會變成跟那個參數一樣（以此範例來看他回傳的長度為 3）
+**注意** 只有他長度的屬性會被設定，整個 Array裡面的數值都不會初始化
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, 數值沒有被設定進去
+
+被設定用來當做 `Array` 的長度只有少數情況使用
+先設定 `Array` 的長度可以用一下的範例來避免使用 `for loop` 的麻煩
+
+    new Array(count + 1).join(stringToRepeat);
+
+### 結語
+
+`Array` 的建構函式需要避免，建議使用字面語法。因為他們比較簡短、也更增加閱讀性
diff --git a/doc/zhtw/array/general.md b/doc/zhtw/array/general.md
new file mode 100644
index 00000000..1a59d72e
--- /dev/null
+++ b/doc/zhtw/array/general.md
@@ -0,0 +1,46 @@
+## Array 迴圈和屬性
+
+雖然在 Javascript 中 Array 都是 Objects，但是沒有好的理由要使用他
+在 [`for in`](#object.forinloop) 的迴圈中。事實上有很多原因要避免使用 `for in` 在 Array 之中
+
+> **注意:** Javascript Arrays **不是** *關連性 Arrays*
+> 只有 [objects](#object.general) 來管理建值的相對應關係
+> Arrays 是**保持** 順序的，Objects **則沒有**
+
+因為 `for in` 迴圈會使用[`hasOwnProperty`](#object.hasownproperty)，所以它會列舉所有在原型 Array 上的屬性，這會使得 Array 比原本的 `for` 迴圈慢上二十幾倍
+
+### 迴圈
+
+為了要達到最好的性能所以最好使用 `for` 迴圈來讀取一個 Array 裡面的數值。
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+在上面的例子中利用 `l = list.length` 來處理 Array 的長度問題。
+
+雖然 `length` 屬性是屬於 Array 中其中一個屬性，但是他在每次循環還是有一定的性能消耗。
+近期 Javascript **可能**使用來解決在這上面的效率問題，但是在現在的引擎上還不一定有支援。
+
+實際上，不使用暫存 Array 長度的方式比使用暫存的版本還要慢很多。
+
+### `length` 的屬性
+
+`length` 屬性中的 *getter* 直接回傳在 Array 之中的程度，而 *setter* 可以用來 **刪除** Array。
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo.push(4);
+    foo; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+在上面的例子可以看到，如果給的長度比較小他就會去刪除 Array 中的數值。如果比較大的話，他就會自己增加一些 `undefined` 的數值進去
+
+### 結語
+
+為了達到更好的效率，建議使用 `for` 迴圈還有暫存 `length` 的屬性。
+而 `for in` 迴圈則是會讓程式中有更多的錯誤和性能問題。
+
diff --git a/doc/zhtw/core/delete.md b/doc/zhtw/core/delete.md
new file mode 100644
index 00000000..091693bb
--- /dev/null
+++ b/doc/zhtw/core/delete.md
@@ -0,0 +1,78 @@
+## `delete` 控制符
+
+簡單來說，那是 *不可能* 去刪除一個全域變數，函式和其他東西在 JavaScript 中有一個 `DontDelete` 的屬性
+
+### 全域和函式
+
+當一個變數或是一個函式在一個全域範圍被定義或是在一個 [funciton scope](#function.scopes) ，這些屬性可能是動態的物件或是全域的物件。這些特性有一系列的屬性。其中一個就是 `DontDelete`。
+在這些變數和函式的宣告都會有一個屬性叫 `DontDelete`，這會使得它無法被刪除。
+
+    // 全域變數
+    var a = 1; // DontDelete 屬性被建立
+    delete a; // false
+    a; // 1
+
+    // normal function:
+    function f() {} // DontDelete 屬性被建立
+    delete f; // false
+    typeof f; // "function"
+
+    // reassigning doesn't help:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### 明確的屬性
+
+明確的屬性可以被簡單的刪除。
+
+    // explicitly set property:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+在上面的例子中， `obj.x` 和 `obj.y` 可以被刪除是因為他們沒有 `DontDelete` 的屬性。
+所以下面的例子也可以這樣用。
+
+    // 可以運作，除了 IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - just a global var
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+這裡我們想要去刪除 `a`。 [`this`](#funciton.this) 這裡指向一個全域的物件，和我們明確了地定義 `a` 是它的屬性，所以可以刪除它。
+
+IE 有些臭蟲，所以上面的程式碼無法使用（至少 6~8）
+
+### 函式的參數和內建
+
+函式的普通參數，[`arguments` object](#function.arguments) 還有一些內建的屬性都有 `DontDelete` 的建立
+
+    // function 參數和屬性
+    (function (x) {
+    
+      delete arguments; // false
+      typeof arguments; // "object"
+      
+      delete x; // false
+      x; // 1
+      
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+      
+    })(1);
+
+### 接受物件
+ 
+控制符可以接受無法預測的物件。由於一些特別的情況，會允許它能夠 `delete`
+
+### 結語
+
+`delete` 控制符通常都有難以預料的行為，所以我們只可以安全的刪除顯著的屬性在普通的物件上。
+
+
diff --git a/doc/zhtw/core/eval.md b/doc/zhtw/core/eval.md
new file mode 100644
index 00000000..26b7d332
--- /dev/null
+++ b/doc/zhtw/core/eval.md
@@ -0,0 +1,42 @@
+## 為什麼不要使用 `eval`
+
+因為 `eval` 函數會在 Javascript 的區域性的區間執行那段程式碼。
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+
+但是， `eval` 只接受直接的呼叫而且那個函數只能叫做 `eval`，才能在一個區段中執行。
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+所有的 `eval` 都應該去比免試用。有 99.9% 的使用情況都可以 **不必** 使用到而達到同等效果。
+    
+### 偽裝的 `eval`
+ 
+[定時函數](#other.timeouts) `setTimeout` 和 `setInterval` 都可以接受一個字串當做他們第一個參數。這些字串 **永遠** 都會在全域範圍內執行，因此在這種情況下 `eval` 沒有被直接的使用。
+
+### 安全上的顧慮
+
+`eval` 同樣有安全上的問題，因為所有的程式碼都可以被直接執行。
+而他不應去執行一串未知的字串或是來自不信任的來源。
+
+### 結語
+
+`eval` 應該永遠不要去只用它，任何的程式在被他執行後都有性能和安全上的考慮。如果有情況需要去使用他，他都不應該列為第一順位的解決方法。
+
+應該有更好的方法能夠去使用，但是最好都不要去使用 `eval`。
+
diff --git a/doc/zhtw/core/semicolon.md b/doc/zhtw/core/semicolon.md
new file mode 100644
index 00000000..aab71355
--- /dev/null
+++ b/doc/zhtw/core/semicolon.md
@@ -0,0 +1,103 @@
+## 自動插入分號
+
+雖然 JavaScript 有 C 語言的語法，但是他不強制一定要加上分號。
+所以分號可以被忽略。
+
+Javascript 並 **不是** 一個不需要分號的語言。實際上，它需要分號來讓程式碼更容易被理解。因此 Javascript 的編譯器中遇到了缺少分號的情形，它會自動的在程式碼中插入分號。
+
+    var foo = function() {
+    } // 編輯錯誤，因沒分號
+    test()
+
+這時候編譯器在編輯的時候，會自動的加上分號，然後重新編輯。
+
+    var foo = function() {
+    }; // 沒有錯誤，編輯繼續
+    test()
+
+自動的加入分號是被認為 **最大** 的設計缺陷之一，因為它能改變程式碼的行為。
+
+### 工作原理
+
+下面的程式碼中沒有使用任何的分號，所以編譯器需要去決定在哪些地方加入分號。
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+下面的程式碼是編譯器 **猜測** 的結果。
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // 沒有加入分號，兩行被合併為一行
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- 插入分號
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- 插入分號
+
+            return; // <- 插入分號，改變了 return 的表達行為
+            { // 作為另一個程式碼的處理
+
+                // 被當做一個獨立的函數來看
+                foo: function() {} 
+            }; // <- 插入分號
+        }
+        window.test = test; // <- 插入分號
+
+    // 兩行又被合併
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- 插入分號
+
+    })(window); //<- 插入分號
+
+> **注意:** 在這個範例中 Javascript 編譯器沒有正確的處理 `return` ，因為緊接的換行符號。
+> 雖然這不能算是自動分號插入的錯誤，但是它是非常不樂見的效果。
+
+編譯器在上面的程式碼中改變了原本程式碼的行為。在一些情況下，會做出 **錯誤的行為**
+
+### 前置括號
+
+在這種前置括號的情況下，編譯器 **不會** 自動的插入分號。
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+上面的程式碼被編譯器轉為只有一行程式
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+以上的範例中 `log` 有 **很大** 的可能 **不是** 回傳一個函數。然而這個情況下會出現 `TypeError` 的錯誤或是會出現 `undefined is not a function` .
+
+### 結語
+
+建議永遠 **不要** 忽略分號。同樣的也建議大括號應在他對應的表達式在同一行。在 `if... else...`的表達式中也是如此，不應省略大括號。
+這個習慣可以不僅僅是讓你的程式更一致，也可以避免編譯器因為改變程式而出錯。
+
diff --git a/doc/zhtw/core/undefined.md b/doc/zhtw/core/undefined.md
new file mode 100644
index 00000000..501dfb95
--- /dev/null
+++ b/doc/zhtw/core/undefined.md
@@ -0,0 +1,53 @@
+## `undefined` 和 `null`
+
+JavaScript 中有兩個表示空值的方式， `null` 和 `undefined` ， `undefined`是比較常用的一種。
+
+### `undefined` 的值
+
+`undefined` 是一個值為 `undefined` 的類型。
+
+語言中也定義了一個全域變數，它的值為 `undefined`，這個變數的被稱作 `undefined` 。
+這個變數 **不是** 一個常數，也不是一個關鍵字。這表示它的值可以被輕易的覆蓋。
+
+> **ES5 提示: ** `undefined` 在 ECMAScript 5 裡 **不再是** *可寫* 的
+> 但是它的名稱還是可以被隱藏，比如說定義一個函數為 `undefined`。
+
+這裡有一些例子會回傳 `undefined` 的值：
+
+ - 進入尚未修改的全域變數 `undefined`。
+ - 進入一個宣告但 **尚未** 初始化的變數。
+ - `return` 表示式中沒有返回任何內容。
+ - 呼叫不存在的屬性。
+ - 函式參數沒有被傳遞數值。
+ - 任何被被設定為 `undefined` 的變數。
+ - 任何表達式中形式為 `void(expression)`
+
+### 處理 `undefined` 值的改變
+
+由於全域變數 `undefined` 只有保存 `undefined` 類型實際值的一個副本，指定了一個新的值並 **不會** 改變 `undefined`類型裡面的值。
+
+為了避免去改變 `undefined` 的值，常用的技巧就是加上一個新的變數到 [匿名包裝器](#function.scopes)。在使用的時候，這個參數不會接受任何的值。
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // undefined 在區域區間內得到了 `undefined` 的值
+
+    })('Hello World', 42);
+
+另外一個可以得到同樣的效果就是在內部宣告一個變數
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+唯一的不同就是在下者會多 4 個多 bytes 用來壓縮檔案，而且函數內也沒有其他需要使用 `var`
+
+### 使用 `null`
+
+JavaScript 中所使用的 `undefined` 類似別的語言中的 *null* , 但實際上在 JavaScript 中的 `null` 算是另外一個類型。
+
+它在 JavaScript 有些可以使用的地方 （例如說宣告一個原型的終結，例如 `Foo.prototype = null` ）。
+但是在大部分的時候可以用 `undefined`，來取代。
diff --git a/doc/zhtw/function/arguments.md b/doc/zhtw/function/arguments.md
new file mode 100644
index 00000000..39aa58f0
--- /dev/null
+++ b/doc/zhtw/function/arguments.md
@@ -0,0 +1,103 @@
+## `arguments` 物件
+
+所有函數在 JavaScript 中都可以有個特別的參數 `arguments`。
+這個變數掌握了一列傳入函數中的參數
+
+> **注意:** 由於 `arguments` 都已經在函數中被定義了
+> 經過 `var` 定義或是用 `arguments` 宣告參數
+> `arguments` 物件都不會被建立
+
+`arguments` 物件 **不是** 一個 `Array`，雖然都有很多 Array 的語法 - 就像是 `length` 屬性 - 但是它沒有繼承來自 `Array.prototype` 事實上它繼承 `object`。
+
+由於這些原因，這 **不可能** 用 Array 的一些功能像是 `push`、`pop`或是 `slice` 在 `arguments`。
+但是像 `for` 迴圈這些迴圈都是可以用的，如果真的需要使用一些標準的 `Array` 功能可以先把它轉成真的 `Array` 再去使用。
+
+### 轉為 Array
+
+下面的程式可以回傳一個新的 `Array` 包含所有的元素在 `Arguments`的物件中
+
+    Array.prototype.slice.call(arguments);
+
+這種轉化方式比較 **慢** ，如果在追求效率的程式中，不建議使用這種作法。
+
+
+### 傳遞參數
+
+下面是建議用這種方式去傳參數到另一個函數
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // 在這裡做一些事情
+    }
+
+另一個技巧是用 `call` 和 `apply` 放在一起來創造一個更快的解綁定包裝器
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Create an unbound version of "method" 
+    // 輸入的參數: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // 結果: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### 自動更新
+
+在 `Arguments` 物件創造的 *getter* 和 *setter* 的函數方法，可以被視為原本函數的變數。
+
+因此，改變了一個形式參將數會跟著改變對應的 `arguments` 的屬性，反之亦然。
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### 性能
+
+`arguments` 總是會被宣告，但除了兩個情況，一個是在一個函式中或是在其中一個參入。而不論他是否有被使用。
+
+*getters* 和 *setter* 會永遠被創造。然而，他們對任何性能都沒有影響，除非對它的屬性有多次的訪問
+
+
+> **ES5 提示:** 那些 *getters* 和 *setters* 在嚴格的模式像不會被建立
+
+然而會有一種情況來降低 JavaScript 引擎的效能。就是使用 `arguments.callee`。
+
+    function foo() {
+        arguments.callee; // 做一些在這個函數物件
+        arguments.callee.caller; // 然後呼叫這個函數物件
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // 通常會在內聯
+        }
+    }
+
+在上面的程式中， `foo` 不再是一個單存的互聯函數
+因為它需要知道他自己和它的調用者。
+這不僅減低了它的性能，而且還破壞的封裝
+
+**強烈建議不要使用**  `arguments.callee` 或是其他它的屬性
+
+> **ES5 Note:** 在嚴格的模式下 `arguments.callee` 會丟出一個 `TypeError`， 因為這種方法已經被廢除了
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+
+
diff --git a/doc/zhtw/function/closures.md b/doc/zhtw/function/closures.md
new file mode 100644
index 00000000..11bcda4d
--- /dev/null
+++ b/doc/zhtw/function/closures.md
@@ -0,0 +1,85 @@
+## Closures 和 References
+
+JavaScript 有一個很重要的特徵就是 **closures**
+因為有 Closures，所以作用域 **永遠** 能夠去訪問作用區間外面的變數。
+[函數區間](#function.scopes) 是JavaScript 中唯一擁有自生作用域的結構，因此 Closures 的創立需要依賴函數
+
+### 模仿私有變數
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+這裡，`Counter` 返回兩個 Closures，函數 `increment` 還有 `get`。這兩個函數都維持著對外部作用域 `Counter` 的引用，因此總可以訪問作用域的變數 `count`。
+
+
+### 為什麼不可以在外部訪問私有變數
+
+因為 Javascript **不可以** 對作用域進行引用或賦值。因此外部的地方沒有辦法訪問 `count` 變數。
+唯一的途徑就是經過那兩個 Closures
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+在上面的例子中 `count` **不會** 改變到 `Counter` 裡面的 `count` 的值。因為 `foo.hack` 沒有在 **那個** 作用域內被宣告。它只有會覆蓋或者建立在一個 **全域** 的變數 `count`
+
+### 在循環內的 Closures
+
+一個常見的錯誤就是在 Closures 中使用迴圈，假設我們要使用每次迴圈中所使用的進入變數
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);
+        }, 1000);
+    }
+
+在上面的例子中它 **不會** 輸出數字從 `0` 到 `9`，但只會出現數字 `10` 十次。
+在 `console.log` 被呼叫的時候，這個 *匿名* 函數中保持一個 **參考** 到 i ，此時 `for`迴圈已經結束， `i` 的值被修改成了 `10`。
+為了要達到想要的結果，需要在每次創造 **副本** 來儲存 `i` 的變數。
+
+### 避免引用錯誤
+
+為了要有達到正確的效果，最好是把它包在一個
+[匿名函數](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);
+            }, 1000);
+        })(i);
+    }
+
+匿名外部的函數被呼叫，並把 `i` 作為它第一個參數，此時函數內 `e` 變數就擁有了一個 `i` 的拷貝。
+當傳遞給 `setTimeout` 這個匿名函數執行時，它就擁有了對 `e` 的引用，而這個值 **不會** 被循環改變。
+另外有一個方法也可以完成這樣的工作，那就是在匿名函數中返回一個函數，這和上面的程式碼有同樣的效果。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+另外也可以透過 `.bind` 完成此工作，它可以將 `this` 及參數傳入函數內，行為就如同上面程式碼一樣。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
+
diff --git a/doc/zhtw/function/constructors.md b/doc/zhtw/function/constructors.md
new file mode 100644
index 00000000..a74a10db
--- /dev/null
+++ b/doc/zhtw/function/constructors.md
@@ -0,0 +1,101 @@
+## 建構函式 
+
+JavaScript 中的建構函式和其他語言中的建構函式是不同的。
+用 `new` 的關鍵字方式調用的函式都被認為是建構函式。
+在建構函式內部 - 被呼叫的函式 - `this` 指向一個新建立的 `object`。[prototype](#object.prototype) 這是一個新的物件一個被指向函式的 `prototype` 的建構函式。
+
+如果被使用的函式沒有明顯的呼叫 `return` 的表達式，它會回傳一個隱性的 `this` 的新物件。
+
+    function Foo() {
+        this.bla = 1;
+    }
+
+    Foo.prototype.test = function() {
+        console.log(this.bla);
+    };
+
+    var test = new Foo();
+
+在上面的例子中 `Foo` 建立一個建構函式，並設立一個 `prototype` 來創建一個新的物件叫 `Foo.prototype`。
+這個情況下它顯示的 `return` 一個表達式，但他 **只** 返回一個 `Object`。
+
+    function Bar() {
+        return 2;
+    }
+    new Bar(); // 返回一個新物件
+
+    function Test() {
+        this.value = 2;
+
+        return {
+            foo: 1
+        };
+    }
+    new Test(); // 回傳物件
+
+如果 `new` 的關鍵字被忽略，函式就 **不會** 回傳一個新的物件。
+
+    function Foo() {
+        this.bla = 1; // 獲取一個全域的參數
+    }
+    Foo(); // undefined
+
+雖然上面有些情況也能正常運行，但是由於 JavaScript 中 [`this`](#funciton.this) 的工作原理，這裡的 `this` 指向 *全域對象*。
+
+### 工廠模式
+
+為了不使用 `new` 關鍵字，建構函式必須顯性的返回一個值。
+
+    function Bar() {
+        var value = 1;
+        return {
+            method: function() {
+                return value;
+            }
+        }
+    }
+    Bar.prototype = {
+        foo: function() {}
+    };
+
+    new Bar();
+    Bar();
+
+上面兩個呼叫 `Bar` 的方法回傳的值都一樣，一個新創建的擁有 `method` 屬性被返回，這裡創建了一個 [Closure](#function.closures).
+
+還有注意， `new Bar()` 並 **不會** 改變返回物件的原型。
+因為建構函式的原型會指向剛剛創立的新物件，而在這裡的 `Bar` 沒有把這個新物件返回。
+在上面的例子中，使用或者不使用 `new` 關鍵字沒有什麼功能性的區別
+
+
+### 通過工廠模式創建的新對象
+
+常聽到建議 **不要** 使用 `new`，因為如果忘記如何使用它會造成錯誤。
+為了創建一個新的物件，我們可以用工廠方法，來創造一個新的物件在那個方法中。
+
+    function Foo() {
+        var obj = {};
+        obj.value = 'blub';
+
+        var private = 2;
+        obj.someMethod = function(value) {
+            this.value = value;
+        }
+
+        obj.getPrivate = function() {
+            return private;
+        }
+        return obj;
+    }
+
+雖然上面的方式比起 `new` 的調用方式更不容易出錯，並且可以充分的使用 [私有變數](#function.closures)所帶來的便利，但是還是有一些不好的地方
+
+
+1.  會占用更多的記憶體，因為創建的物件 **沒有** 辦法放在在同一個原型上。
+2.  為了要用繼承的方式，工廠方法需要複製所有的屬性或是把一個物件作為新的物件的原型。
+3.  放棄原型鏈僅僅是因為防止遺漏 `new` 所帶來的問題，這與語言本身的思想鄉違背。
+
+### 結語
+
+雖然遺漏 `new` 關鍵字可能會導致問題，但這並 **不是** 放棄只用原型的藉口。
+最終使用哪種方式取決於應用程式的需求，選擇一種程式語言風格並堅持下去才是最重要的。
diff --git a/doc/zhtw/function/general.md b/doc/zhtw/function/general.md
new file mode 100644
index 00000000..fe400880
--- /dev/null
+++ b/doc/zhtw/function/general.md
@@ -0,0 +1,43 @@
+## 函式的宣告和表達方式
+
+函式在 JavaScript 是第一等物件。這表示他們可以把函式當做值一樣傳遞。
+一個常見的用法是用 *匿名函式* 當做一個回傳去呼叫另一個函式，這是一種非同步函式
+
+### 函式的宣告
+
+    function foo() {}
+
+上面的函式在被執行之前會被 [解析(hoisted)](#function.scopes)，因此它可以在 **任意** 的地方都是 *有宣告的* ，就算是在比這個函式還早呼叫。
+
+
+    foo(); // 可以執行，因為 foo 已經在運行前就被建立
+    function foo() {}
+
+### `function` 的表達式
+
+    var foo = function() {};
+
+這個例子把一個 *匿名* 函式賦值給變數 `foo`。
+
+    foo; // 'undefined'
+    foo(); // 錯誤: TypeError
+    var foo = function() {};
+
+由於 `var` 已經宣告變數 `foo` 在所有的程式碼執行之前。
+所以 `foo`已經在程式運行前就已經被定義過了。
+但是因為賦值只會在運行時去執行，所以在程式碼執行前，`foo` 的值還沒被宣告所以為 [undefined](#core.undefined)。
+
+
+### 命名函式的賦值表達式
+
+另一個特殊狀況是將一個命名函式賦值給一個變數。
+
+    var foo = function bar() {
+        bar(); // 可以運行
+    }
+    bar(); // 錯誤：ReferenceError
+
+`bar` 不可以在外部的區域被執行，因為它只有在 `foo` 的函式內才可以執行。
+然而在 `bar` 內部還是可以看見。這是由於 JavaScript的 [命名處理](#function.scopes)所致。
+函式名在函式內 *都* 可以使用。
+
diff --git a/doc/zhtw/function/scopes.md b/doc/zhtw/function/scopes.md
new file mode 100644
index 00000000..d443656f
--- /dev/null
+++ b/doc/zhtw/function/scopes.md
@@ -0,0 +1,199 @@
+## 作用域和命名空間
+
+儘管 JavaScript 支持一個大括號創建的程式碼，但並不支持塊級作用域。
+而僅僅支援 *函式作用域*
+
+    function test() { // 一個作用域
+        for(var i = 0; i < 10; i++) { // 不是一個作用域
+            // 算數
+        }
+        console.log(i); // 10
+    }
+
+> **注意:** 如果不是用在變數賦予值的宣告中、return 的回傳值中或者函數的參數中， `{...}` 將會被解析為一個程式區塊(block scope)，而不是被解析為物件實體語法(object literal)。
+> 如果考慮到 [自動分號插入](#core.semicolon)，可能會造成一些不易察覺的錯誤。
+
+JavaScript 中沒有寫示的命名空間定義，這代表著它所有定義的東西都是 *全域共享* 在同一個命名空間下。
+
+每次引用一個變數，JavaScript 會向上找整個作用域直到找到這個變數為止。
+如果在全域中無法找到那個變數，它會拋出 `ReferenceError` 錯誤碼。
+
+### 全域變數的壞處
+
+    // script A
+    foo = '42';
+
+    // script B
+    var foo = '42'
+
+上面兩個腳本 *不會* 有同樣的效果。腳本 A 在 *全域* 空間定義了變數 `foo`，腳本 B 定義了 `foo` 在目前的區間內。
+
+再次強調，上面的效果是 **完全不同**，不使用 `var` 會導致隱性的全域變數。
+
+    // 全域作用區
+    var foo = 42;
+    function test() {
+        // 局部作用區
+        foo = 21;
+    }
+    test();
+    foo; // 21
+
+在函數 `test` 中部使用 `var` 會覆蓋到原本在外面的 `foo`。
+雖然看起來不是什麼大問題，但是當程式有幾千行的時候沒有使用 `var` 會照成難以追蹤的臭蟲。
+
+    
+    // 全域作用域
+    var items = [/* some list */];
+    for(var i = 0; i < 10; i++) {
+        subLoop();
+    }
+
+    function subLoop() {
+        // subLoop 的作用域
+        for(i = 0; i < 10; i++) { // 缺少了 var
+            // 做一些事情
+        }
+    }
+    
+在外面的迴圈在呼叫第一次 `subLoop` 之後就會停止，因為 `subLoop` 全域變數中的 `i` 被覆蓋了。
+在第二次使用 `for` 迴圈的時候，使用 `var` 就可以避免這種錯誤。
+在宣告變數的時候 **絕對不要** 忘記 `var`，除非就是 `希望他的效果` 是取改變外部的作用域。
+
+### 局部變數
+
+在 javascript 中能用兩種方式來宣告局部變數。
+[函式](#function.general) 參數和透過 `var` 來宣告變數。
+
+    // 全域變數
+    var foo = 1;
+    var bar = 2;
+    var i = 2;
+
+    function test(i) {
+        // 函式 test 內部的局部作用域
+        i = 5;
+
+        var foo = 3;
+        bar = 4;
+    }
+    test(10);
+
+`foo` 和 `i` 是它的局部變數在 `test` 函式中，但是在 `bar` 的賦值會覆蓋全區域的作用域內的同名變數。
+
+### 變數宣告
+
+JavaScript 會 **提昇** 變數宣告， 這代表著 `var` 和 `function` 的圈告都會被提升到當前作用域的頂端。
+
+    bar();
+    var bar = function() {};
+    var someValue = 42;
+
+    test();
+    function test(data) {
+        if (false) {
+            goo = 1;
+
+        } else {
+            var goo = 2;
+        }
+        for(var i = 0; i < 100; i++) {
+            var e = data[i];
+        }
+    }
+
+在上面的程式碼會被轉化在執行之前。 JavaScript 會把 `var`，和 `function` 宣告，放到最頂端最接近的作用區間
+
+    // var 被移到這裡
+    var bar, someValue; //  值等於 'undefined'
+
+    // function 的宣告也被搬上來
+    function test(data) {
+        var goo, i, e; // 沒有作用域的也被搬至頂端
+        if (false) {
+            goo = 1;
+
+        } else {
+            goo = 2;
+        }
+        for(i = 0; i < 100; i++) {
+            e = data[i];
+        }
+    }
+
+    bar(); // 出錯：TypeError ， bar 還是 'undefined'
+    someValue = 42; // 賦值語句不會被提昇規則影響
+    bar = function() {};
+
+    test();
+
+沒有作用域區間不只會把 `var` 放到迴圈之外，還會使得 `if` 表達式更難看懂。
+
+在一般的程式中，雖然 `if` 表達式中看起來修改了 *全域變數* `goo`，但實際上在提昇規則被運用後，卻是在修改 *局部變數*
+
+如果沒有提昇規則的話，可能會出現像下面的看起來會出現 `ReferenceError` 的錯誤。
+
+    // 檢查 SomeImportantThing 是否已經被初始化
+    if (!SomeImportantThing) {
+        var SomeImportantThing = {};
+    }
+
+但是它沒有錯誤，因為 `var` 的表達式會被提升到 *全域作用域* 的頂端。
+
+    var SomeImportantThing;
+
+    // 有些程式，可能會初始化。
+    SomeImportantThing here, or not
+
+    // 檢查是否已經被初始化。
+    if (!SomeImportantThing) {
+        SomeImportantThing = {};
+    }
+
+### 名稱解析順序
+ 
+JavaScript 中所有的作用區，包括 *全域作用域*，都有一個特殊的名字 [`this`](#function.this), 在它們裡面被定義，指向當前的物件
+
+函式作用域也有一個名稱叫做 [`arguments`](#function.arguments), 定義它們，其中包括傳到函式內的參數。
+
+例如，它們開始試著進入到 `foo` 的作用域裡面， JavaScript 會依照下面的順序去查詢：
+
+ 1. 當作用域內是否有 `var foo` 的定義。
+ 2. 函式形式參數是否有使用 `foo` 名稱定義。
+ 3. 函式自身是否叫做 `foo`。
+ 4. 回溯到上一個層級然後再從第一個開始往下去查。
+
+> **注意: ** 自定義 `arguments` 參數會阻止原生的 `arguments` 的物件創立
+
+### 命名空間
+
+只有一個全域作用域會導致常見的錯誤是命名衝突。在 JavaScript 中可以透過 *匿名包裝器* 來解決。
+
+    (function() {
+        // 自己本身的匿名空間
+        
+        window.foo = function() {
+            // 對外公開的函式
+        };
+
+    })(); // 馬上執行這個匿名函式
+
+匿名函式被認為是 [表達式](#function.general)因此為了要可以調用，它們會先被執行。
+
+    ( // 小括號內的先被執行
+    function() {}
+    ) // 回傳函數對象
+    () // 調用上面的執行結果
+
+還有其他方式也可以像上面一樣調用函式的方式達到
+
+    !function(){}()
+    +function(){}()
+    (function(){}());
+    // and so on...
+
+### 結語
+
+建議最好是都用 *匿名包裝器* 來封裝你的程式碼在自己的命名區間內。這不僅是要防止命名衝突也可以使得程序更有模組化。
+
+另外，全域變數是個 **不好的** 習慣，因為它會帶來錯誤和更難去維護。
diff --git a/doc/zhtw/function/this.md b/doc/zhtw/function/this.md
new file mode 100644
index 00000000..361a06c4
--- /dev/null
+++ b/doc/zhtw/function/this.md
@@ -0,0 +1,105 @@
+## `this` 的工作原理
+
+JavaScript 有一道完全不屬於其他語言處理 `this` 的處理機制。
+在 **五** 種不同的情況下， `this` 指向的各不相同
+
+### 全域變數
+
+    this;
+
+如果再全域範圍內使用 `this`，會指向 *全域* 的物件
+
+
+### 呼叫一個函式
+
+    foo();
+
+這裡 `this` 也會指向 *全域* 物件。
+
+> **ES5 注意:** 在嚴格模式下，不存在全域變數。
+> `this` 將會是 `undefined`。
+
+### 呼叫一個方法
+
+    test.foo(); 
+
+這個例子中， `this` 指向 `test` 物件。
+
+### 呼叫一個建構函式
+
+    new foo(); 
+
+如果函式傾向用 `new` 關鍵詞使用，我們稱這個函式為 [建構函式](#function.constructors)。
+在函式內部， `this` 指向 *新物件的創立*
+
+### 顯示的設置 `this`
+
+    function foo(a, b, c) {}
+                          
+    var bar = {};
+    foo.apply(bar, [1, 2, 3]); // Array 會被擴展，如下所示
+    foo.call(bar, 1, 2, 3); // 傳遞參數 a = 1, b = 2, c = 3
+
+當使用 `function.prototype` 上的 `call` 或只 `apply` 方法時，函式內的 `this` 將會被 **顯示設置** 為函式調用的第一個參數。
+
+因此，在以上的例子中已不適用*函式調用*的原則，而且`this`會被設定指向`bar`。
+
+> **Note:** `this` **cannot** be used to refer to the object inside of an `Object`
+> literal. So `var obj = {me: this}` will **not** result in `me` referring to
+> `obj`, since `this` only gets bound by one of the five listed cases.
+
+### 常見誤解
+
+儘管大部分的例子都合理，但第一個例子(譯者注: 應該是指前面呼叫一個函式的那個例子)可以被視為一個語言的不良設計，因為它**從來**就沒有實際用途。
+
+    Foo.method = function() {
+        function test() {
+            // this 設定為全域
+        }
+        test();
+    };
+
+一個常見的誤解是 `test` 中的 `this` 指向 `Foo` 物件，但實際上並**不是**。
+
+為了在 `test` 中使用 `Foo` 物件，我們需要在 `method` 函式内部建立一個區域變數指向 `Foo`。
+
+    Foo.method = function() {
+        var that = this;
+        function test() {
+            // 這裡使用 that 而非 this
+        }
+        test();
+    };
+
+`that` 只是普通的名字，不過這個名字常被用用來指向外部的 `this`。 在 [閉包](#function.closures) 一節，可以看到它(`that`)可以取代 `this` 傳遞。
+
+在 ECMAScript 5 ，你可以使用 `bind` 結合匿名函式達到相同結果。
+
+    Foo.method = function() {
+        var test = function() {
+            // this 指向 Foo
+        }.bind(this);
+        test();
+    };
+
+### 函式表達式
+
+另一個在 JavaScript 中**不會**運作的就是 function aliasing，也就是函式**賦值**給一個變數。
+
+    var test = someObject.methodTest;
+    test();
+
+上例中，`test` 就像一個普通的函式被调用；因此，函式内的 this 將不再指向 `someObject`。
+
+雖然起初 `this` 的绑定特性似乎像是個壞主意，但事實上，它使得 [原型繼承](#object.prototype)得以運作。
+
+    function Foo() {}
+    Foo.prototype.method = function() {};
+
+    function Bar() {}
+    Bar.prototype = Foo.prototype;
+
+    new Bar().method();
+
+當 `method` 被呼叫時，`this` 將會指向 `Bar` 的實體物件。
+
diff --git a/doc/zhtw/index.json b/doc/zhtw/index.json
new file mode 100644
index 00000000..37533c13
--- /dev/null
+++ b/doc/zhtw/index.json
@@ -0,0 +1,69 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden 繁體中文翻譯",
+    "description": "JavaScript 語言中古怪用法及缺點的文件總集",
+    "sections": [
+        {
+            "title": "簡介",
+            "dir": "intro",
+            "articles": ["index"]
+        },
+        {
+            "title": "物件",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "函式",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "陣列",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "類型",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "核心",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon",
+                "delete"
+            ]
+        },
+        {
+            "title": "其他",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/zhtw/intro/index.md b/doc/zhtw/intro/index.md
new file mode 100644
index 00000000..5de42228
--- /dev/null
+++ b/doc/zhtw/intro/index.md
@@ -0,0 +1,53 @@
+## 簡介
+
+JavaScript Garden 是一個不斷更新的文件，最主要是要去了解一些 Javascript 比較古怪的部份。
+給一些意見來防止遇到一些常見的錯誤和一些難以發現的問題，以及性能問題和不好的習慣。
+初學者也可以藉此去了解 Javascript 這項語言的特性。
+
+JavaScript Garden 並 **不是** 要教導你 Javascript 的語言。
+如果要能夠理解這篇文章的內容，你需要事先學習 JavaScript 的基礎知識。
+在 Mozilla 開發者網路中有一系列非常棒的學習[guide][1]。
+
+
+## 作者
+
+這個使用手冊是來自於 [Stack Overflow][2] 的使用者, [Ivo Wetzel][3]
+(寫作) 和 [Zhang Yi Jiang][4] (設計)。
+
+目前為 [Tim Ruffles](http://truffles.me.uk) 維護此專案。
+
+## 貢獻者
+
+- [貢獻者](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors)
+
+## 繁體中文翻譯
+
+ - [紀力榮][29]
+ - [張仲威][30]
+ - [Bo-Yi Wu][31]
+
+## 存放空間
+
+JavaScript Garden 目前存放於 GitHub，但是 [Cramer Development][7] 讓我們有另一個存放位置在 [JavaScriptGarden.info][8]。
+
+## 許可
+
+JavaScript Garden 是在 [MIT license][9] 許可協議下發佈，並存在於
+[GitHub][10]，如果你有發現錯誤或是打字上的錯誤 [新增一個任務][11] 或者發一個請求。
+你也可以在 StackOverflow 的 [JavaScript room][12] 上面找到我們。
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
+[2]: http://stackoverflow.com/
+[3]: http://stackoverflow.com/users/170224/ivo-wetzel
+[4]: http://stackoverflow.com/users/313758/yi-jiang
+[5]: https://github.com/caio
+[6]: https://github.com/blixt
+[7]: http://cramerdev.com/
+[8]: http://javascriptgarden.info/
+[9]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[10]: https://github.com/BonsaiDen/JavaScript-Garden
+[11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[12]: http://chat.stackoverflow.com/rooms/17/javascript
+[29]: https://github.com/chilijung
+[30]: https://github.com/wwwy3y3
+[31]: https://github.com/appleboy
diff --git a/doc/zhtw/object/forinloop.md b/doc/zhtw/object/forinloop.md
new file mode 100644
index 00000000..06b248a6
--- /dev/null
+++ b/doc/zhtw/object/forinloop.md
@@ -0,0 +1,40 @@
+## `for in` 迴圈
+
+就像其他的 `in` 操作符一樣， `for in` 循環也進入所有在物件中的屬性
+
+> **注意: ** `for in` 迴圈 **不會** 進入那些 `enumerable` 屬性是 `false`，舉例來說，陣列中 `length` 的屬性
+
+    // 修改 Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // 輸出兩個屬性：bar 和 moo
+    }
+
+由於不可能改變 `for in` 本身的行為，因為有必要過濾出那些不希望在迴圈出現的屬性，這可以用 `Object.prototype` 原型上的 [`hasOwnProperty`](#object.hasownproperty) 的函數來完成。
+
+> **注意: ** 由於 `for in` 總是要到所有原型鏈裡，因此如果物件的繼承層次太深的話會影響性能。
+
+
+### 用 `hasOwnProperty` 來過濾
+
+    // foo 變數是上面範例中的
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+這個版本的程式碼是唯一正確的寫法。由於我們使用了 `hasOwnProperty`，這次 **只** 輸出 `moo`。
+如果不使用這個程式碼在原型物件中(比如 `Object.prototype`)被擴展可能會出錯。
+
+一個廣泛使用的舊函式庫 [Prototype][1]就擴展了原型的 JavaScript 物件。
+因此，當這個函式庫包含在頁面中時，不使用 `hasOwnProperty` 過濾的 `for in` 迴圈難免會出問題。
+
+### 總結
+
+推薦 **總是** 使用 `hasOwnProperty`。不要對程式碼的環境做任何假設，不要假設原生的對象是否被擴張。
+
+[1]: http://www.prototypejs.org/
+
diff --git a/doc/zhtw/object/general.md b/doc/zhtw/object/general.md
new file mode 100644
index 00000000..6cd56600
--- /dev/null
+++ b/doc/zhtw/object/general.md
@@ -0,0 +1,85 @@
+## 物件的使用和屬性
+
+在 Javascript 中全部都是物件，除了 [`null`](#core.undefined) 和 [`undefined`](#core.undefined)。
+
+    false.toString(); // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+一個常見的誤解就是字面值（literal）不是物件。這是因為 JavaScript 編譯器的一個錯誤，它試圖把 *點操作符* 解析為浮點數的字面值的一部分。
+
+    2.toString(); // 出錯： SyntaxError
+
+有很多變通方法可以讓數字的字面值看起來像物件。
+
+    2..toString(); // 第二個點號可以正常解析
+    2 .toString(); // 注意點號前面的空格
+    (2).toString(); // 2 先被計算
+
+### 物件做為數據類型
+
+JavaScript 的物件可以作為 [*Hashmaps*][1]使用，主要用來保存命名的鍵與值的對應關係。
+
+使用物件的字面語法 - `{}` - 可以創建一個簡單的物件。 這個新創建的物件[繼承](#object.prototype) 自 `Object.prototype` ，沒有任何 [自定義屬性](#object.hasownproperty)。
+
+    var foo = {}; // 一個空的物件
+
+    // 一個新的物件，有值為 12 的自定義屬性 'test'
+    var bar = {test: 12}; 
+
+### 訪問屬性
+
+有兩種方式來訪問物件的屬性，點操作或是中括號操作。
+    
+    var foo = {name: 'kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+    
+    var get = 'name';
+    foo[get]; // kitten
+    
+    foo.1234; // SyntaxError
+    foo['1234']; // works
+
+兩種語法是相等的，唯一的差別是，使用中括號允許你動態的設定屬性，使用點操作不允許屬性為變數，否則會造成語法錯誤
+
+### 刪除屬性
+
+唯一刪除屬性的方式就是用 `delete` 操作符。設置屬性為 `undefined` 或是 `null` 只有刪除的屬性和值的關聯，沒有真的刪掉屬性
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+上面的輸出結果有 `bar undefined` 和 `foo null`
+只有 `baz` 真正被刪除而已，所以從輸出結果中消失。
+
+
+### 屬性名的語法
+
+    var test = {
+        'case': 'I am a keyword, so I must be notated as a string',
+        delete: 'I am a keyword, so me too' // raises SyntaxError
+    };
+
+物件的屬性名可以使用字符串或是普通的宣告。但是由於 JavaScript 編譯器存在一個錯誤設計。
+上面的兩種方式在 ECMAScript 5之前都會拋出 `SyntaxError` 的錯誤。
+
+這個錯誤的原因是 `delete` 是 JavaScript 語言的一個 *關鍵字* 因此為了在更低的版本能執行最好用 *string literal*
+
+[1]: http://en.wikipedia.org/wiki/Hashmap
+
diff --git a/doc/zhtw/object/hasownproperty.md b/doc/zhtw/object/hasownproperty.md
new file mode 100644
index 00000000..5d8403b4
--- /dev/null
+++ b/doc/zhtw/object/hasownproperty.md
@@ -0,0 +1,45 @@
+## `hasOwnProperty`
+
+為了判斷一個物件是否包含 *自定義* 屬性而 *不是* [原型](#object.prototype)上的屬性，我們需要使用繼承 `Object.prototype` 的 `hasOwnProperty` 方法。
+
+> **注意:** 判斷一個屬性是否 `undefined` 是 **不夠的**。
+> 因為一個屬性可能存在，但是它的值被設成 `undefined`。
+
+`hasOwnProperty` 是 JavaScript 中唯一一個處理屬性但是 **不** 找原型鏈的函式。
+
+    // 修改 Object.prototype
+    Object.prototype.bar = 1;
+    var foo = {goo: undefined};
+
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+只有 `hasOwnProperty` 給予正確的結果，這對進入物件的屬性很有效果，**沒有** 其他方法可以用來排除原型上的屬性，而不是定義在物件 *自己* 上的屬性。
+
+### `hasOwnProperty` 作為屬性
+
+JavaScript **不會** 保護 `hasOwnProperty`被占用，因此如果碰到存在這個屬性，就需要使用 *外部* 的 `hasOwnProperty` 來獲取正確的結果。
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // 永遠返回 false
+
+    // 使用其他對象的 hasOwnProperty，並將其上下設置為 foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+    // 也可以透過原生 Object prototype 的 hasOwnProperty 函數來達成目的
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+
+### 結論
+
+當檢查一個物件是否存在的時候， `hasOwnProperty` 是 **唯一** 可用的方法。
+同時在使用 [`for in loop`](#object.forinloop)
+建議使用 `hasOwnProperty` 避免 [原型](#object.prototype)所帶來的干擾。
diff --git a/doc/zhtw/object/prototype.md b/doc/zhtw/object/prototype.md
new file mode 100644
index 00000000..83ad784a
--- /dev/null
+++ b/doc/zhtw/object/prototype.md
@@ -0,0 +1,87 @@
+## Prototype
+
+JavaScript 不包含傳統繼承的模型，它使用的是*原型*模型。
+
+儘管常常有人提及 JavaScript 的缺點，但基於原型的繼承模型比傳統繼承更強大。
+實現傳統的類繼承模型是很簡單。但是在 JavaScript 中實現原型的繼承模型則要困難很多。
+
+由於 JavaScript 是唯一一個被廣泛使用的基於原型繼承的語言，所以我們必須要花時間來理解這兩者的不同。
+
+第一個不同之處在於 JavaScript 使用 *原型鏈* 的繼承方式。
+
+> **注意: ** 簡單的使用 `Bar.prototype = Foo.prototype` 將會導致兩個對象共享 **相同** 的原型。
+>因此，改變任一個原型都會去影響到另外一個，這在大部分的時候不是想得到的結果。
+
+    function Foo() {
+        this.value = 42;
+    }
+    Foo.prototype = {
+        method: function() {}
+    };
+
+    function Bar() {}
+
+    // 設置 Bar 的 prototype 屬性為 Foo 的實例對象
+    Bar.prototype = new Foo();
+    Bar.prototype.foo = 'Hello World';
+
+    // 修正 Bar.prototype.constructor 為 Bar 本身
+    Bar.prototype.constructor = Bar;
+
+    var test = new Bar(); // 開啟一個新的實例
+
+    // 原型鏈
+    test [instance of Bar]
+        Bar.prototype [instance of Foo]
+            { foo: 'Hello World', value: 42 }
+            Foo.prototype
+                { method: ... }
+                Object.prototype
+                    { toString: ... /* etc. */ }
+
+上面的例子中，物件 `test` 會繼承來自 `Bar.prototype` 和 `Foo.prototype`。因此它可以進入來自 `Foo` 原型的方法 `method`。
+同時它也可以訪問 **那個** 定義在原型上的 `Foo` 實例屬性 `value`。
+
+要注意的是 `new Bar()` **沒有** 創立一個新的 `Foo` 實例，它重複利用的原本的 prototype。因此， `Bar` 的實例會分享到 **相同** 的 `value` 屬性。
+
+> **注意:** **不要** 使用 `Bar.prototype = Foo`，因為這不會執行 `Foo` 的原型，而是指向函式 `Foo`。
+> 因此原型鏈將回碩到 `Function.prototype` 而不是 `Foo.prototype` ，因此 `method` 將不會在 Bar 的原型鏈上。
+
+### 屬性查詢
+
+當查詢一個物件的屬性時，JavaScript 會 **向上** 查詢，直到查到指定名稱的屬性為止。
+
+如果他查到原型鏈的頂部 - 也就是 `Object.prototype` - 但是仍然沒有指定的屬定，就會返回 [undefined](#core.undefined)。
+
+### 原型屬性
+
+當原型屬性用來建造原型鏈，它還是有可能去把 **任意** 類型的值給它
+
+    function Foo() {}
+    Foo.prototype = 1; // 無效
+
+分派物件，在上面的例子中，將會動態的創建原型鏈。
+
+### 效能
+
+如果看在屬性在原型鏈的上端，對於查詢都會有不利的影響。特別的，試圖獲取一個不存在的屬性將會找遍所有原型鏈。
+
+並且，當使用 [迴圈](#object.forinloop)找尋所有物件的屬性時，原型鏈上的 **所有** 屬性都會被訪問。
+
+### 擴展 Native Prototype
+
+一個經常發生的錯誤，那就是擴展 `Object.prototype` 或者是其他內建類型的原型物件。
+
+這種技術叫做 [monkey patching][1] 並且會破壞 *封裝*。雖然被廣泛的應用到一些 Javascript 的架構，像是 [Prototype](http://prototypejs.org) ， 但仍然沒有好的理由新增一個 *非標準* 的功能去搞亂內建型別。
+
+擴展內置類型的 **唯一** 理由是為了和新的 JavaScript 保持一致，比如說 [`Array.forEach`][3]
+
+### 總結
+
+在寫複雜的程式碼的時候，要 **充分理解** 所有程式繼承的屬性還有原型鏈。
+還要提防原型鏈過長帶來的性能問題，並知道如何通過縮短原型鏈來提高性能。
+絕對 **不要使用** `native prototype` 除非是為了和新的 JavaScript 引擎作兼容。
+
+[1]: http://en.wikipedia.org/wiki/Monkey_patch
+[2]: http://prototypejs.org/
+[3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
diff --git a/doc/zhtw/other/timeouts.md b/doc/zhtw/other/timeouts.md
new file mode 100644
index 00000000..d717a81e
--- /dev/null
+++ b/doc/zhtw/other/timeouts.md
@@ -0,0 +1,135 @@
+### `setTimeout` 和 `setInterval`
+
+由於 Javascript 具有非同步的特性，因此可以用 `setTimeout` 和 `setInterval` 來執行一個函式。
+
+> **注意:** Timeouts 不在 ECMAScript 的標準中。它們是 [DOM][1] 其中的一部分
+
+    function foo() {}
+    var id = setTimeout(foo, 1000); // returns a Number > 0
+
+當 `setTimeout` 被呼叫，它會回傳一個 ID 標準並且 **大約** 1000 毫秒後在在去呼叫 `foo` 函式。
+`foo` 函式只會被執行 **一次**。
+
+基於 JavaScript 引擎的計時策略，以及基本的單線程運行的方式，所以其他的程式碼可以被阻塞。
+因此 **沒法確保**函式會在 `setTimeout` 指定的時可被調用。
+
+第一個參數被函式呼叫的會在 *全域物件* 被呼叫，這代表 [`this`](#function.this)在這個函式會指向全域物件。
+
+    function Foo() {
+        this.value = 42;
+        this.method = function() {
+            // 指向全域
+            console.log(this.value); // 會跑出 undefined
+        };
+        setTimeout(this.method, 500);
+    }
+    new Foo();
+
+> **注意: ** `setTimeout` 第一個參數是 **參數的物件**，這是一個很常見的錯誤使用 `setTimeout(foo(), 1000)，
+> 這裡會調用 `foo` 的 **return value** 而 **不是** `foo` 本身。
+> 如果函式返回 `undefined` ， `setTimeout` 也不會出錯。
+
+### `setInterval` 的堆調用
+
+`setTimeout` 只會在函式上跑一次而已， `setInterval` - 則會在每隔 `X` 毫秒執行函式一次。但不鼓勵這種寫法。
+
+當回傳函式的執行被阻塞時， `setInterval` 仍然會發佈更多的回傳函式。在很小的定時間隔情況像會使得回傳函式被堆疊起來。
+
+    function foo(){
+        // 執行 1 秒
+    }
+    setInterval(foo, 100);
+
+上面的程式中， `foo` 會執行一次然後被阻塞了一分鐘
+
+在 `foo` 被阻塞的時候 `setInterval` 還是會組織將對回傳函式的調用。因此當第一次 `foo` 函式調用結束時，已經有 **10** 次函式的調用在等待執行。
+
+### 處理可能被阻塞的調用
+
+最簡單的解決方法，也是最容易控制的解決方法，就是在函式中使用 `setTimeout`。
+
+    function foo(){
+        // something that blocks for 1 second
+        setTimeout(foo, 100);
+    }
+    foo();
+
+這樣不只封裝了 `setTimeout`，也防止了堆疊的呼叫，還有給它更多的控制。 `foo` 可以去決定要不要繼續執行。
+
+### 手動清理 Timeouts
+
+清除 timeouts 所產生的 ID 標準傳遞給 `clearTimeout` 或 `clearInterval` 函式來清除定時，
+至於使用哪個函式取決於調用的時候使用的是 `setTimeout` 還是 `setInterval`。
+
+    var id = setTimeout(foo, 1000);
+    clearTimeout(id);
+
+### 清除所有 Timeouts
+
+由於沒有一個內建的方法可以一次清空所有的 timeouts 和 intervals，所以只有用暴力法來達到這樣的需求。
+
+    // clear "all" timeouts
+    for(var i = 1; i < 1000; i++) {
+        clearTimeout(i);
+    }
+
+可能還有一些定時器不會在上面的代碼中被清除，因此我們可以事先保存所有的定時器 ID，然後一把清除。
+
+
+    // clear "all" timeouts
+    var biggestTimeoutId = window.setTimeout(function(){}, 1),
+    i;
+    for(i = 1; i <= biggestTimeoutId; i++) {
+        clearTimeout(i);
+    }
+
+### 隱藏使用 `eval`
+
+`setTimeout` and `setInterval` 也可以使用字串當作他們的第一個參數.
+不過這個特性 **絕對** 不要使用， 因為在內部他將利用 `eval` 來實作。
+
+> **注意:** 由於 timeout 函式 **並未** 被列入 ECMAScript 
+> 標準中，當你將字串當成參數傳入時，在不同的 Javscript 
+> 實作中很有可能會造成不一樣的行為。比如說：在 Microsoft 的 JScript 中，就使用 `Function` 
+> 建構子來取代 `eval`。
+
+
+
+    function foo() {
+        // will get called
+    }
+
+    function bar() {
+        function foo() {
+            // never gets called
+        }
+        setTimeout('foo()', 1000);
+    }
+    bar();
+
+在這個範例中，由於 `eval` 沒有被[直接](#core.eval)呼叫，在 `setTimeout` 中被傳入的字串將會在 *全域* 範圍中被執行，因此，他將不會使用在 `bar` 區域的 `foo`。
+
+我們進一步建議 **不要** 用字串當作參數傳到會被 timeout 呼叫的函式中。
+
+
+    function foo(a, b, c) {}
+
+    // NEVER use this
+    setTimeout('foo(1, 2, 3)', 1000)
+
+    // Instead use an anonymous function
+    setTimeout(function() {
+        foo(1, 2, 3);
+    }, 1000)
+
+> **注意** 儘管使用 `setTimeout(foo, 1000, 1, 2, 3)` 
+> 這樣的文法是可能的，但我們卻不建議這樣做，因為這和 [方法](#function.this) 
+> 一起使用時可能會導致微妙的錯誤。
+
+### 結論
+
+**絕對** 不要使用字串當作 `setTimeout` 或 `setInterval` 參數。當參數要被當成呼叫的函式時，這絕對是 **不好** 的程式碼，相反的，利用 *匿名函式* 來完成這樣的行為。
+
+此外，應該避免使用 `setInterval`，因為他將不會被 Javascript 給中斷。
+
+[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
diff --git a/doc/zhtw/types/casting.md b/doc/zhtw/types/casting.md
new file mode 100644
index 00000000..e6aa2cfa
--- /dev/null
+++ b/doc/zhtw/types/casting.md
@@ -0,0 +1,62 @@
+## 類型轉換
+
+JavaScript 是一個 *弱類型* 的程式語言，所以在 **任何** 情況下都可以 *強制類型轉換*。
+
+    // 這些都是真
+    new Number(10) == 10; // Number.toString() is converted
+                          // back to a number
+
+    10 == '10';           // Strings gets converted to Number
+    10 == '+10 ';         // More string madness
+    10 == '010';          // And more 
+    isNaN(null) == false; // null converts to 0
+                          // which of course is not NaN
+    
+    // 下面都假
+    10 == 010;
+    10 == '-10';
+
+> **ES5 注意:** 如果數字字面值的開頭是 `0` 它會強制轉為八進位數字解析。
+> 而在 ES5 嚴格模式下，它已經被刪除了。
+
+為了去避免上驗的事件發生，我們會用 [嚴格等於操作符](#types.equality) 這是強烈建議。
+因為它可以避免很多常見的問題，但 JavaScript 的弱類型系同仍然會導致一些其他問題。
+
+### 內置類型的建構函式
+
+內置類型（比如 `Number` 和 `String`)在被調用時，使用或不使用 `new` 的結果完全不同。
+
+    new Number(10) === 10;     // False, Object and Number
+    Number(10) === 10;         // True, Number and Number
+    new Number(10) + 0 === 10; // True, due to implicit conversion
+
+使用內置類型 `Number` 作為建構函式會建造一個新的 `Number` 物件，而在不使用 `new` 關鍵字的 `Number` 函式更像是一個數字轉換器。
+
+另外，在比較中引入物件的字面值會導致更加複雜的強制類型轉換。
+
+最好的方式是比較值的 **顯示** 的轉換成最有可能的三種形態
+
+### 轉換成字符串
+
+    '' + 10 === '10'; // true
+
+將一個值加上空字符串可以輕鬆轉為字符串類型。
+
+### 轉換成一個數字
+
+    +'10' === 10; // true
+
+使用 **一元** 的加號操作符，可以把字符串轉為數字。
+
+### 轉換成一個 Bool
+通過使用 **否** 操作符兩字，可以把一個值轉換為 Bool。
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
+
+
diff --git a/doc/zhtw/types/equality.md b/doc/zhtw/types/equality.md
new file mode 100644
index 00000000..1f20c6c1
--- /dev/null
+++ b/doc/zhtw/types/equality.md
@@ -0,0 +1,60 @@
+## 相等與比較
+
+JavaScript 有兩個不同的方式來比較兩個物件是否相等。
+
+### 等於操作符
+
+等於操作符是由兩個等號組成: `==`
+
+JavaScript 是一個 *弱類型* 語言。這代表它會為了比較兩個值而做 **強制類型轉換**。
+    
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+上面的表格可以看出來這些結果強制轉換類型，這也代表說用 `==` 是一個不好的習慣，因為它會很難追蹤問題由於它複雜的規則。
+
+此外，也有效率上面的問題在強制轉換類型。
+例如說一個字串會被轉成數字來和別的數字做比較。
+
+### 嚴格等於操作符
+
+不像普通的等於操作符 `===` 不會做強制類型轉換。
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+上面的結果比較清楚，也有利於程式碼的分析。如果這兩個操作數的類型不一樣都就不會相等，有助於它性能的提昇。
+
+### 比較物件
+
+雖然 `==` 和 `===` 都是等於操作符，但其中有一個操作數為物件時，它的行為就會不同。
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+在這裡等於操作符比較 **不是** 值的相等，而是否是 **相同** 的身分。
+有點像 Python 的 `is` 和 C 中的指標。
+
+### 結論
+
+強烈建議使用 **嚴格等於**
+如果要轉換類型，應該要在 [explicitly](#types.casting)的時候轉換，而不是在語言本身用複雜的轉換規則。
+
+
diff --git a/doc/zhtw/types/instanceof.md b/doc/zhtw/types/instanceof.md
new file mode 100644
index 00000000..fa5e8c30
--- /dev/null
+++ b/doc/zhtw/types/instanceof.md
@@ -0,0 +1,32 @@
+## `instanceof` 操作符
+
+`instanceof` 操作符用來比較兩個建構函數的操作數。只有在比較自定義的物件時才有意義。這和 [typeof operator](#types.typeof)一樣用處不大。
+
+### 比較定意義物件
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // This just sets Bar.prototype to the function object Foo,
+    // but not to an actual instance of Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### `instanceof` 比較內置類型
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+有一點需要注意的， `instanceof` 不會在來自不同的上下文的物件運作（例如：瀏覽器中不同的文檔結構），因為它的建構函數不一樣。
+
+### In Conclusion
+
+`instanceof` 操作符應該 **只** 用來比較同一個 JavaScript 上下文定意義的物件。
+正如 [`typeof`](#types.typeof)操作符一樣，任何其他用法都要避免。
diff --git a/doc/zhtw/types/typeof.md b/doc/zhtw/types/typeof.md
new file mode 100644
index 00000000..0a0908b0
--- /dev/null
+++ b/doc/zhtw/types/typeof.md
@@ -0,0 +1,74 @@
+## `typeof` 操作符
+
+`typeof` 操作符 (和
+[`instanceof`](#types.instanceof)) 可能是最大的設計錯誤在 JavaScript，因為它幾乎不可能從它們那裡得到想要的結果。
+
+雖然 `instanceof` 還是有一些限制上的使用， `typeof` 只有一個實際上的運用情形，但是 **不是** 用在檢查物件的類型。
+
+> **注意:** 由於 `typeof` 也可以像函式的語法被調用，例如 `typeof(obj)`，但這並是一個函數調用。
+> 那兩個小括號只是用來計算一個表達式的值，這個返回值會作為 `typeof` 操作符的一個操作數。
+> 實際上 **不存在** 名為 `typeof` 的函式。 
+
+
+### JavaScript 類型表格
+
+    Value               Class      Type
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function in Nitro/V8)
+    new RegExp("meow")  RegExp     object (function in Nitro/V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+上面的表格中， *Type* 這一系列表示 `typeof` 的操作符的運算結果。可以看到，這個值的大多數情況下都返回物件。
+
+*Class* 表示物件內部的屬性 `[[Class]]` 的值。
+
+
+> **JavaScript 標準文檔中定義：** `[[Class]]`的值只可能是下面字符串中的一個：
+> `Arguments`, `Array`, `Boolean`, `Date`, `Error`,
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`
+
+為了獲取對象的 `[[Class]]`，我們可以使用定義在 `Object.prototype` 上的方法 `toString`。
+
+### 物件的類定義
+
+JavaScript 標準文檔只給出了一種獲取 `[[Class]]` 值的方法，那就是使用 `Object.prototype.toString`。
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+上面的例子中，**`Object.prototype.toString` 用 [this](#function.this)的值來來調用被設置需要獲取 `[[Class]]` 值的物件。
+
+> **ES5 Note:** 為了回傳 `Object.prototyp.toString` 值的方便
+> `null` 和 `undefined` 被 **改變** 從 `object` 到 `null` 和 `undefined` 在 ECMAScript 5。
+
+### 測試未定義變數
+
+    typeof foo !== 'undefined'
+
+上面的例子確認 `foo` 是否真的被宣告。如果沒有定義會導致 `ReferenceError` 這是 `typeof` 唯一有用的地方
+
+### 結語
+
+為了去檢查一個物件，強烈建議去使用 `Object.prototype.toString` 因為這是唯一可以依賴的方式。
+正如上面所看到的 `typeof` 的事先返回值在標準文檔中未定義，因此不同的引擎可能不同。
+
+除非為了檢測一個變數是否定義，我們應該避免使用 `typeof` 操作符。
+
+
diff --git a/garden.jade b/garden.jade
index 7f41c533..bb67c1d1 100644
--- a/garden.jade
+++ b/garden.jade
@@ -1,9 +1,11 @@
-!!! 5
+doctype html
 html(lang=language)
   head
     title #{title}
     meta(charset='utf-8')
     meta(name='description', content=description)
+    meta(name='viewport', content='width=device-width, initial-scale=1')
+    link(rel='shortcut icon' href='http://github.com/' + pathPrefix + 'favicon.ico?v=2')
 
     - if (language === baseLanguage)
       link(rel='stylesheet', href='http://github.com/style/garden.css', media='all')
@@ -22,7 +24,7 @@ html(lang=language)
     // Navigation
     nav(id='nav_main')
       div
-        ul 
+        ul
           - each lang in languages
             li(class=lang.id === language ? 'active' : '')
               - if (lang.id === baseLanguage)
@@ -39,12 +41,11 @@ html(lang=language)
             h1
               a(href='#' + section.link) #{section.title}
 
-            - if (section.parsed.index || section.articles.length > 0)
-              ul
-                  
-                - each article in section.articles
-                  li
-                    a(href='#' + article.link)!=article.title
+            ul
+                - if (section.articles.length > 0 && !section.isIntro)
+                    - each article in section.articles
+                      li
+                        a(href='#' + article.link)!=article.title
 
     // Mobile navigation
     nav(id='nav_mobile')
@@ -53,7 +54,7 @@ html(lang=language)
 
       a(id='nav_next_section', href='#') next section
         span(class='nav_section_name') section name
-      
+
       a(id='show_menu') show menu
 
     // Sections
@@ -63,38 +64,32 @@ html(lang=language)
         // Introduction
         header(id=section.link + '.intro')
           h1 #{section.title}
-          - if (section.parsed.index)
-            div!=section.parsed.index.text
+          - if (section.index)
+            div!=section.index.text
 
         // Articles
         - each article in section.articles
           article(id=article.link)
             h2!=article.title
 
-            - each sub in article.parsed.subs
+            - each sub in article.subs
               div!=sub
 
     // Footer
     footer
-      p Copyright &copy; 2011. Built with
-        | 
-        a(href='http://nodejs.org/') Node.js 
-        | using a
-        a(href='https://github.com/visionmedia/jade/') jade 
-        | template. 
-        | Hosted by 
-        a(href='http://cramerdev.com/') Cramer Development
-        .
-
-    script(src='http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js')
-    
+      p Copyright &copy;. Built with
+        |
+        a(href='http://nodejs.org/')  Node.js
+        |  using a
+        a(href='https://github.com/visionmedia/jade/')  jade
+        |  template.
+
+    script(src='http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js')
+
     - if (language === baseLanguage)
       script(src='http://github.com/javascript/prettify.js')
-      script(src='http://github.com/javascript/plugin.js')
       script(src='http://github.com/javascript/garden.js')
-    
+
     - else
       script(src='http://github.com/javascript/prettify.js')
-      script(src='http://github.com/javascript/plugin.js')
       script(src='http://github.com/javascript/garden.js')
-
diff --git a/package.json b/package.json
index 98500980..a9662f9f 100644
--- a/package.json
+++ b/package.json
@@ -1,12 +1,16 @@
 {
-    "name": "javascript-garden",
-    "description": "A collection of documentation about the most quirky parts of the JavaScript language.",
-    "version": "0.0.0",
-    "dependencies": {
-        "fomatto": "0.5.0",
-        "forever": "0.4.1",
-        "jade": "0.9.1",
-        "neko": "1.1.2",
-        "node-markdown": "0.1.0"
-    }
+  "name": "javascript-garden",
+  "description": "A collection of documentation about the most quirky parts of the JavaScript language.",
+  "version": "0.0.0",
+  "scripts": {
+    "build": "node build.js"
+  },
+  "dependencies": {
+    "fomatto": "0.5.0",
+    "forever": "0.10.8",
+    "jade": "0.35.0",
+    "neko": "1.1.2",
+    "marked": "~0.2.9",
+    "lodash": "~2.2.1"
+  }
 }
diff --git a/server.js b/server.js
deleted file mode 100644
index fb64b73d..00000000
--- a/server.js
+++ /dev/null
@@ -1,33 +0,0 @@
-// This server implements a post-receive hook handler for github that will build the site
-var build = require('./build').build,
-    qs = require('querystring'),
-    port = 9900,
-    repoURL = "https://github.com/cramerdev/JavaScript-Garden";
-
-require('http').createServer(function (request, response) {
-    var payload = '';
-    try {
-        if (request.method === 'POST') {
-            request.setEncoding('utf8');
-            request.on('data', function (data) {
-                payload += data;
-            });
-            request.on('end', function () {
-                console.log(payload);
-                payload = JSON.parse(qs.parse(payload).payload);
-                if (payload.repository.url === repoURL) {
-                    build();
-                } else {
-                    response.writeHead(400); // Bad Request
-                }
-            });
-            response.writeHead(200); // OK
-        } else {
-            response.writeHead(405); // Method Not Allowed
-        }
-    } catch (e) {
-        console.error("Error: " + e);
-        response.writeHead(500); // Internal Server Error
-    }
-    response.end();
-}).listen(port);
diff --git a/site/favicon.ico b/site/favicon.ico
new file mode 100644
index 00000000..29998189
Binary files /dev/null and b/site/favicon.ico differ
diff --git a/site/javascript/garden.js b/site/javascript/garden.js
index 3795bcc4..3939a2c7 100644
--- a/site/javascript/garden.js
+++ b/site/javascript/garden.js
@@ -18,10 +18,10 @@ Sections.prototype = {
     },
 
     map: function() {
-        this.names = $('section [id]').map(function(idx, ele) {
+        this.names = $('section>[id]').map(function(idx, ele) {
             return {
                 id: this.id.replace('.intro', ''),
-                offset: $(this).offset().top - 20,
+                offset: $(this).offset().top - 100,
                 title: $(this).find(':header:first').html()
             };
 
@@ -33,7 +33,7 @@ Sections.prototype = {
             articleID = this.names[this.names.length - 1].id;
 
         for(var i = 0, l = this.names.length; i < l; i++) {
-            if (this.names[i].offset > scroll) {
+            if (scroll >= 0 && this.names[i].offset > scroll) {
                 articleID = this.names[i - 1].id;
                 break;
             }
@@ -60,18 +60,18 @@ Sections.prototype = {
         }
     },
 
-    expand: function (sectionName) {
+    expand: function(sectionName) {
         var nav = this.page.nav,
             index = nav.find('a[href=#' + sectionName + ']')
                        .closest('nav > ul > li').index();
 
         var height = this.page.window.height()
                      - $('nav > div').height()
-                     - (33 * this.heights.length),
+                     - (33 * this.heights.length);
 
-                     sections = [],
-                     currentHeight = 0,
-                     distance = 0;
+        var sections = [],
+            currentHeight = 0,
+            distance = 0;
 
         while ((currentHeight + this.heights[index]) < height) {
             sections.push(index);
@@ -135,7 +135,7 @@ function Page() {
         section: null,
         articule: null
     });
-    
+
     this.sections = new Sections(this);
     this.init();
 }
@@ -143,48 +143,35 @@ function Page() {
 Page.prototype = {
     init: function() {
         var that = this,
-            mainNav = $('#nav_main');
+            $mainNav = $('#nav_main');
 
         $.extend(this, {
             scrollLast: 0,
             resizeTimeout: null
         });
-        
+
         this.window.scroll(function() {
             that.onScroll();
         });
-        
+
         this.window.resize(function() {
             that.onResize();
         });
 
-        that.sections.map();
+        this.sections.map();
         setTimeout(function() {
             that.sections.highlight();
         }, 10);
 
-        // Mobile, for position: fixed
-        if ($.mobile) {
-            var navs = $('#nav_mobile, #nav_main');
-            navs.css('position', 'absolute');
-            this.window.scroll(function(){
-                navs.offset({
-                    top: that.window.scrollTop()
-                });
-            });
-        }
-        
-        // Show menu for tablets
-        $('#show_menu').click(function (){
-            var scrollTop = $.mobile ? that.window.scrollTop() : 0;
-            
-            mainNav.slideDown(300).css('top', scrollTop);
+        // Show menu for tablets and smart phones
+        $('#show_menu').click(function() {
+            $mainNav.slideDown(300);
             return false;
         });
-        
-        $('#nav_main').click(function(){
+
+        $mainNav.click(function() {
             if(that.window.width() < 1000)
-                mainNav.slideUp(300);
+                $mainNav.slideUp(300, function() { $mainNav.removeAttr('style'); });
         });
     },
 
diff --git a/site/javascript/plugin.js b/site/javascript/plugin.js
deleted file mode 100644
index 9461358a..00000000
--- a/site/javascript/plugin.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * jQuery.browser.mobile (http://detectmobilebrowser.com/)
- *
- * Copyright (c) 2010 Chad Smith (http://twitter.com/chadsmith)
- * Dual licensed under the MIT and GPL licenses.
- * http://www.opensource.org/licenses/mit-license.php
- * http://www.opensource.org/licenses/gpl-license.php
- *
- * jQuery.browser.mobile will be true if the browser is a mobile device
- *
- **/
-(function(a){jQuery.browser.mobile=/android|avantgo|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|e\-|e\/|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(di|rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|xda(\-|2|g)|yas\-|your|zeto|zte\-/i.test(a.substr(0,4))})(navigator.userAgent||navigator.vendor||window.opera);
\ No newline at end of file
diff --git a/site/style/garden.css b/site/style/garden.css
index d6843ce2..b6d29302 100644
--- a/site/style/garden.css
+++ b/site/style/garden.css
@@ -72,29 +72,30 @@ body {
 
 nav {
 	position: fixed;
-	margin-left: 750px;
 	top: 0;
-    padding-bottom: 20px;
+	right: 0;
+	padding-bottom: 20px;
 	height: 100%;
-	
 	text-shadow: none;
-	width: 240px;
+	width: 225px;
 }
 
 nav > div li {
-    float: left;
-    margin-right: 1px;
+	float: left;
+	margin-right: 1px;
 }
 
 nav > div li a, #top, #hide_menu {
-	padding: 7px 10px 9px 10px;
+	padding: 8px 6px 7px;
 	cursor: pointer;
+	font-size: 12px;
+	font-weight: bold;
 }
 
 nav > div li.active a {
 	border-top: 4px solid #0D2E4C;
-	padding-top: 3px;
-    color: #FFC76D;
+	padding-top: 4px;
+	color: #FFC76D;
 }
 
 #hide_menu {
@@ -112,12 +113,18 @@ nav > div li.active a {
 
 #nav_main > div ul {
 	float: left;
+	width: 200px;
+}
+
+#nav_main > ul {
+	height: calc(100% - 4em);
+	overflow-y: auto;
 }
 
 nav li {
 	font-size: 16px;
-    margin: 0px;
-    list-style: none;
+	margin: 0px;
+	list-style: none;
 }
 
 nav > ul li:last-child a {
@@ -179,12 +186,15 @@ nav li a.active:hover {
 nav a:hover, nav ul.active a:hover, nav a, nav li {
 	-moz-transition-property: background-color, color;
 	-moz-transition-duration: 0.3s;
-	
+
 	-webkit-transition-property: background-color, color;
 	-webkit-transition-duration: 0.3s;
-	
+
 	-o-transition-property: background-color, color;
 	-o-transition-duration: 0.3s;
+
+	transition-property: background-color, color;
+	transition-duration: 0.3s;
 }
 
 #nav_mobile {
@@ -237,9 +247,9 @@ code {
 section pre code {
 	font-size: 0.8125em;
 	line-height: 1.4em;
-    padding: 0px;
-    margin-top: 3px;
-    margin-bottom: 1px;
+	padding: 0px;
+	margin-top: 3px;
+	margin-bottom: 1px;
 	background: #0F192A;
 }
 
@@ -261,7 +271,7 @@ section h1 {
 }
 
 section header + section h1 {
-	
+
 }
 
 /* Adding 'icon' to the side of sections */
@@ -330,7 +340,7 @@ aside {
 	width: 180px;
 	right: -190px;
 	opacity: 0.7;
-	
+
 	-moz-transition: opacity 0.3s;
 	-webkit-transition: opacity 0.3s;
 	-o-transition: opacity 0.3s;
@@ -363,7 +373,7 @@ aside.es5:after {
 	font-style: italic;
 	top: -18px;
 	right: -3px;
-	
+
 	-ms-filter: “progid:DXImageTransform.Microsoft.Alpha(Opacity=25)”; /* Just kill me already... */
 	opacity: 0.25;
 }
@@ -371,7 +381,7 @@ aside.es5:after {
 /* Article elements */
 
 section ol {
-    margin-bottom: 2em;
+	margin-bottom: 2em;
 	list-style: decimal;
 }
 
@@ -432,10 +442,10 @@ a abbr {
 
 /* "Tablet" Styles */
 
-@media screen and (max-width: 1000px) {
+@media screen and (max-width: 999px) {
 	body {
 		width: 100%;
-		max-width: 1000px;
+		max-width: 999px;
 		overflow-x: hidden;
 	}
 
@@ -444,7 +454,20 @@ a abbr {
 		margin-left: 30px;
 		margin-right: 0;
 	}
-	
+
+	#nav_main > div ul {
+		width: auto;
+	}
+
+	nav > div li a, #top, #hide_menu {
+		font-size: 14px;
+		padding: 12px 12px 10px;
+	}
+
+	nav > div li.active a {
+		padding-top: 8px;
+	}
+
 	#nav_main {
 		display: none;
 		height: auto;
@@ -452,29 +475,29 @@ a abbr {
 		width: 100%;
 		z-index: 100;
 		padding: 0;
-		
+
 		-moz-box-shadow: 0 3px 3px rgba(0, 0, 0, 0.3);
 		-webkit-box-shadow: 0 3px 3px rgba(0, 0, 0, 0.3);
 		box-shadow: 0 3px 3px rgba(0, 0, 0, 0.3);
 	}
-	
+
 	#nav_main ul ul {
 		display: none !important;
 	}
-	
+
 	#nav_main > ul > li {
 		float: left;
 		text-align: center;
 		width: 14.28%;
 		border-bottom: 0;
 	}
-	
+
 	#nav_main li h1 a {
 		background-image: none;
 		height: 5em;
 		padding: 1.5em 0 2em;
 	}
-	
+
 	#nav_main li h1 a:after {
 		display: block;
 		font-family: Georgia;
@@ -482,21 +505,21 @@ a abbr {
 		font-weight: normal;
 		margin-top: 10px;
 	}
-	
+
 	#nav_main > div ul {
 		height: auto;
 	}
-	
+
 	nav a:hover,
 	nav li.active,
 	nav li.active a {
 		background-color: #0D2E4C;
 	}
-		
+
 	#hide_menu {
 		display: block;
 	}
-	
+
 	#nav_mobile {
 		position: fixed;
 		width: 24%;
@@ -505,7 +528,7 @@ a abbr {
 		display: block;
 		z-index: 50;
 	}
-	
+
 	#nav_mobile a {
 		display: block;
 		background-color: #556C81;
@@ -513,12 +536,12 @@ a abbr {
 		margin-bottom: 1px;
 		text-align: right;
 	}
-	
+
 	#nav_next_section, #nav_prev_section {
 		font-size: 0.55em;
 		text-transform: uppercase;
 	}
-	
+
 	#nav_next_section .nav_section_name,
 	#nav_prev_section .nav_section_name {
 		display: block;
@@ -528,12 +551,12 @@ a abbr {
 		line-height: 1.3em;
 		text-transform: none;
 	}
-	
+
 	#show_menu {
 		font-weight: bold;
 		cursor: pointer;
 	}
-	
+
 	pre {
 		border-left: 0;
 		padding-left: 12px;
@@ -548,7 +571,7 @@ a abbr {
 		right: -33%;
 		width: 30%;
 	}
-	
+
 	section:after {
 		display: none;
 	}
@@ -556,17 +579,16 @@ a abbr {
 
 /* "Smartphone" styles */
 
-@media screen and (max-width: 600px),
-screen and (-webkit-min-device-pixel-ratio: 2) {
+@media screen and (max-width: 600px) {
 	body {
 		max-width: 600px;
 	}
-	
+
 	section {
 		margin-right: 30px;
 		width: auto;
 	}
-	
+
 	section:after {
 		right: 0;
 		font-size: 60px;
@@ -580,16 +602,29 @@ screen and (-webkit-min-device-pixel-ratio: 2) {
 		border-top: 1px solid #9eabb7;
 		opacity: 0.85;
 	}
-	
+
 	#nav_main > ul > li {
-		width: 25%;
+		float: left;
+		text-align: center;
+		border-bottom: 0;
 	}
-	
+
 	#nav_mobile {
 		width: 160px;
 	}
-	
+
 	aside.es5:after {
 		display: none;
 	}
 }
+
+/* Small Screen "Smarphone" Vertical Mode */
+
+@media screen and (max-width: 360px) {
+	#nav_main > ul > li {
+		float: left;
+		text-align: center;
+		width: 33.33%;
+		border-bottom: 0;
+	}
+}