From 510eeb7684748afc83eb14e27d95a6b6c65deff4 Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Wed, 30 Sep 2015 22:40:46 -0300
Subject: [javascript pt-br] : first part

---
 pt-br/javascript-pt.html.markdown | 533 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 533 insertions(+)
 create mode 100644 pt-br/javascript-pt.html.markdown

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
new file mode 100644
index 00000000..c4115b3e
--- /dev/null
+++ b/pt-br/javascript-pt.html.markdown
@@ -0,0 +1,533 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+filename: javascript.js
+---
+
+JavaScript foi criada por Brendan Eich, funcionário da Netscape, em 1995. Ela
+foi originalmente criada para ser uma linguagem de script para websites,
+complementando o uso de Java para aplicações web mais complexas, mas a sua
+integração com páginas web e seu suporte nativo nos browsers fez com que
+ela se tornasse mais comum que Java no frontend web.
+
+Javascript não é somente limitado a browsers web, no entanto: existe o Node.js,
+que é um projeto que fornece um interpretador baseado no motor V8 do Google 
+Chrome e está se tornando cada vez mais famoso.
+
+
+Feedback são muito apreciados! Você me encontrar em
+[@adambrenecki](https://twitter.com/adambrenecki), ou
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Comentários são como em C. Comentários de uma linha começam com duas barras,
+/* e comentários de múltplas linhas começam com barra-asterisco
+   e fecham com asterisco-barra */
+
+// comandos podem ser terminados com  ;
+facaAlgo();
+
+// ... mas eles não precisam ser, assim como o ponto-e-vírgula é automaticamente
+// inserido quando há uma nova linha, exceto alguns casos.
+facaAlgo()
+
+// Porque esses casos podem causar resultados inesperados, vamos continuar 
+// a usar ponto-e-vírgula neste guia.
+
+///////////////////////////////////
+// 1. Numbers, Strings and Operators
+
+// JavaScript has one number type (which is a 64-bit IEEE 754 double).
+// Doubles have a 52-bit mantissa, which is enough to store integers
+//    up to about 9✕10¹⁵ precisely.
+3; // = 3
+1.5; // = 1.5
+
+// Some basic arithmetic works as you'd expect.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Including uneven division.
+5 / 2; // = 2.5
+
+// Bitwise operations also work; when you perform a bitwise operation your float
+// is converted to a signed int *up to* 32 bits.
+1 << 2; // = 4
+
+// Precedence is enforced with parentheses.
+(1 + 3) * 2; // = 8
+
+// There are three special not-a-real-number values:
+Infinity; // result of e.g. 1/0
+-Infinity; // result of e.g. -1/0
+NaN; // result of e.g. 0/0
+
+// There's also a boolean type.
+true;
+false;
+
+// Strings are created with ' or ".
+'abc';
+"Hello, world";
+
+// Negation uses the ! symbol
+!true; // = false
+!false; // = true
+
+// Equality is ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Inequality is !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// More comparisons
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings are concatenated with +
+"Hello " + "world!"; // = "Hello world!"
+
+// and are compared with < and >
+"a" < "b"; // = true
+
+// Type coercion is performed for comparisons with double equals...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...unless you use ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...which can result in some weird behaviour...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// You can access characters in a string with `charAt`
+"This is a string".charAt(0);  // = 'T'
+
+// ...or use `substring` to get larger pieces.
+"Hello world".substring(0, 5); // = "Hello"
+
+// `length` is a property, so don't use ().
+"Hello".length; // = 5
+
+// There's also `null` and `undefined`.
+null;      // used to indicate a deliberate non-value
+undefined; // used to indicate a value is not currently present (although
+           // `undefined` is actually a value itself)
+
+// false, null, undefined, NaN, 0 and "" are falsy; everything else is truthy.
+// Note that 0 is falsy and "0" is truthy, even though 0 == "0".
+
+///////////////////////////////////
+// 2. Variables, Arrays and Objects
+
+// Variables are declared with the `var` keyword. JavaScript is dynamically
+// typed, so you don't need to specify type. Assignment uses a single `=`
+// character.
+var someVar = 5;
+
+// if you leave the var keyword off, you won't get an error...
+someOtherVar = 10;
+
+// ...but your variable will be created in the global scope, not in the scope
+// you defined it in.
+
+// Variables declared without being assigned to are set to undefined.
+var someThirdVar; // = undefined
+
+// There's shorthand for performing math operations on variables:
+someVar += 5; // equivalent to someVar = someVar + 5; someVar is 10 now
+someVar *= 10; // now someVar is 100
+
+// and an even-shorter-hand for adding or subtracting 1
+someVar++; // now someVar is 101
+someVar--; // back to 100
+
+// Arrays are ordered lists of values, of any type.
+var myArray = ["Hello", 45, true];
+
+// Their members can be accessed using the square-brackets subscript syntax.
+// Array indices start at zero.
+myArray[1]; // = 45
+
+// Arrays are mutable and of variable length.
+myArray.push("World");
+myArray.length; // = 4
+
+// Add/Modify at specific index
+myArray[3] = "Hello";
+
+// JavaScript's objects are equivalent to "dictionaries" or "maps" in other
+// languages: an unordered collection of key-value pairs.
+var myObj = {key1: "Hello", key2: "World"};
+
+// Keys are strings, but quotes aren't required if they're a valid
+// JavaScript identifier. Values can be any type.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Object attributes can also be accessed using the subscript syntax,
+myObj["my other key"]; // = 4
+
+// ... or using the dot syntax, provided the key is a valid identifier.
+myObj.myKey; // = "myValue"
+
+// Objects are mutable; values can be changed and new keys added.
+myObj.myThirdKey = true;
+
+// If you try to access a value that's not yet set, you'll get undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Logic and Control Structures
+
+// The syntax for this section is almost identical to Java's. 
+
+// The `if` structure works as you'd expect.
+var count = 1;
+if (count == 3){
+    // evaluated if count is 3
+} else if (count == 4){
+    // evaluated if count is 4
+} else {
+    // evaluated if it's not either 3 or 4
+}
+
+// As does `while`.
+while (true){
+    // An infinite loop!
+}
+
+// Do-while loops are like while loops, except they always run at least once.
+var input;
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// The `for` loop is the same as C and Java:
+// initialisation; continue condition; iteration.
+for (var i = 0; i < 5; i++){
+    // will run 5 times
+}
+
+// && is logical and, || is logical or
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (colour == "red" || colour == "blue"){
+    // colour is either red or blue
+}
+
+// && and || "short circuit", which is useful for setting default values.
+var name = otherName || "default";
+
+
+// The `switch` statement checks for equality with `===`.
+// use 'break' after each case 
+// or the cases after the correct one will be executed too. 
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Functions, Scope and Closures
+
+// JavaScript functions are declared with the `function` keyword.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Note that the value to be returned must start on the same line as the
+// `return` keyword, otherwise you'll always return `undefined` due to
+// automatic semicolon insertion. Watch out for this when using Allman style.
+function myFunction()
+{
+    return // <- semicolon automatically inserted here
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// JavaScript functions are first class objects, so they can be reassigned to
+// different variable names and passed to other functions as arguments - for
+// example, when supplying an event handler:
+function myFunction(){
+    // this code will be called in 5 seconds' time
+}
+setTimeout(myFunction, 5000);
+// Note: setTimeout isn't part of the JS language, but is provided by browsers
+// and Node.js.
+
+// Function objects don't even have to be declared with a name - you can write
+// an anonymous function definition directly into the arguments of another.
+setTimeout(function(){
+    // this code will be called in 5 seconds' time
+}, 5000);
+
+// JavaScript has function scope; functions get their own scope but other blocks
+// do not.
+if (true){
+    var i = 5;
+}
+i; // = 5 - not undefined as you'd expect in a block-scoped language
+
+// This has led to a common pattern of "immediately-executing anonymous
+// functions", which prevent temporary variables from leaking into the global
+// scope.
+(function(){
+    var temporary = 5;
+    // We can access the global scope by assiging to the "global object", which
+    // in a web browser is always `window`. The global object may have a
+    // different name in non-browser environments such as Node.js.
+    window.permanent = 10;
+})();
+temporary; // raises ReferenceError
+permanent; // = 10
+
+// One of JavaScript's most powerful features is closures. If a function is
+// defined inside another function, the inner function has access to all the
+// outer function's variables, even after the outer function exits.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    // Inner functions are put in the local scope by default, as if they were
+    // declared with `var`.
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout is asynchronous, so the sayHelloInFiveSeconds function will
+    // exit immediately, and setTimeout will call inner afterwards. However,
+    // because inner is "closed over" sayHelloInFiveSeconds, inner still has
+    // access to the `prompt` variable when it is finally called.
+}
+sayHelloInFiveSeconds("Adam"); // will open a popup with "Hello, Adam!" in 5s
+
+///////////////////////////////////
+// 5. More about Objects; Constructors and Prototypes
+
+// Objects can contain functions.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// When functions attached to an object are called, they can access the object
+// they're attached to using the `this` keyword.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// What this is set to has to do with how the function is called, not where
+// it's defined. So, our function doesn't work if it isn't called in the
+// context of the object.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Inversely, a function can be assigned to the object and gain access to it
+// through `this`, even if it wasn't attached when it was defined.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// We can also specify a context for a function to execute in when we invoke it
+// using `call` or `apply`.
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// The `apply` function is nearly identical, but takes an array for an argument
+// list.
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// This is useful when working with a function that accepts a sequence of
+// arguments and you want to pass an array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// But, `call` and `apply` are only temporary. When we want it to stick, we can
+// use `bind`.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// `bind` can also be used to partially apply (curry) a function.
+
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// When you call a function with the `new` keyword, a new object is created, and
+// made available to the function via the this keyword. Functions designed to be
+// called like that are called constructors.
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Every JavaScript object has a 'prototype'. When you go to access a property
+// on an object that doesn't exist on the actual object, the interpreter will
+// look at its prototype.
+
+// Some JS implementations let you access an object's prototype on the magic
+// property `__proto__`. While this is useful for explaining prototypes it's not
+// part of the standard; we'll get to standard ways of using prototypes later.
+var myObj = {
+    myString: "Hello world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+myObj.myFunc(); // = "hello world!"
+
+// Of course, if your property isn't on your prototype, the prototype's
+// prototype is searched, and so on.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// There's no copying involved here; each object stores a reference to its
+// prototype. This means we can alter the prototype and our changes will be
+// reflected everywhere.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// We mentioned that `__proto__` was non-standard, and there's no standard way to
+// change the prototype of an existing object. However, there are two ways to
+// create a new object with a given prototype.
+
+// The first is Object.create, which is a recent addition to JS, and therefore
+// not available in all implementations yet.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// The second way, which works anywhere, has to do with constructors.
+// Constructors have a property called prototype. This is *not* the prototype of
+// the constructor function itself; instead, it's the prototype that new objects
+// are given when they're created with that constructor and the new keyword.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Built-in types like strings and numbers also have constructors that create
+// equivalent wrapper objects.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Except, they aren't exactly equivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // This code won't execute, because 0 is falsy.
+}
+if (Number(0)){
+    // This code *will* execute, because Number(0) is truthy.
+}
+
+// However, the wrapper objects and the regular builtins share a prototype, so
+// you can actually add functionality to a string, for instance.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// This fact is often used in "polyfilling", which is implementing newer
+// features of JavaScript in an older subset of JavaScript, so that they can be
+// used in older environments such as outdated browsers.
+
+// For instance, we mentioned that Object.create isn't yet available in all
+// implementations, but we can still use it with this polyfill:
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // make a temporary constructor with the right prototype
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // then use it to create a new, appropriately-prototyped object
+        return new Constructor();
+    }
+}
+```
+
+## Further Reading
+
+The [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides
+excellent documentation for JavaScript as it's used in browsers. Plus, it's a
+wiki, so as you learn more you can help others out by sharing your own
+knowledge.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+covers much of the concepts covered here in more detail. This guide has quite
+deliberately only covered the JavaScript language itself; if you want to learn
+more about how to use JavaScript in web pages, start by learning about the
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges. 
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
+guide of all the counter-intuitive parts of the language.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book. 
+
+In addition to direct contributors to this article, some content is adapted
+from Louie Dinh's Python tutorial on this site, and the [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+on the Mozilla Developer Network.
-- 
cgit v1.2.3


From ed2bc5a84c4dfc1af45c05ea8b1a20122ac72620 Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Thu, 1 Oct 2015 22:23:18 -0300
Subject: =?UTF-8?q?[javascript=20pt-br]=20:=201.=20N=C3=BAmeros,=20Strings?=
 =?UTF-8?q?=20e=20Operadores?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/javascript-pt.html.markdown | 75 ++++++++++++++++++++-------------------
 1 file changed, 39 insertions(+), 36 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index c4115b3e..72f4cf0f 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -37,96 +37,99 @@ facaAlgo()
 // a usar ponto-e-vírgula neste guia.
 
 ///////////////////////////////////
-// 1. Numbers, Strings and Operators
+// 1. Números, Strings e Operadores
 
-// JavaScript has one number type (which is a 64-bit IEEE 754 double).
-// Doubles have a 52-bit mantissa, which is enough to store integers
-//    up to about 9✕10¹⁵ precisely.
+// Javascript tem um tipo de número (que é o 64-bit IEEE 754 double).
+// Doublas tem uma mantissa 52-bit, que é suficiente para guardar inteiros
+// acima de 9✕10¹⁵ precisamente.
 3; // = 3
 1.5; // = 1.5
 
-// Some basic arithmetic works as you'd expect.
+// A aritmética básica funciona seria de esperar.
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
 10 * 2; // = 20
 35 / 5; // = 7
 
-// Including uneven division.
+// Inclusive divisão desigual.
 5 / 2; // = 2.5
 
-// Bitwise operations also work; when you perform a bitwise operation your float
-// is converted to a signed int *up to* 32 bits.
+// Operadores Bitwise também funcionam; quando você faz uma operação bitwise
+// seu float é convertido para um int de até 32 bits.
 1 << 2; // = 4
 
-// Precedence is enforced with parentheses.
+// A precedência é aplicada com parênteses.
 (1 + 3) * 2; // = 8
 
 // There are three special not-a-real-number values:
-Infinity; // result of e.g. 1/0
--Infinity; // result of e.g. -1/0
-NaN; // result of e.g. 0/0
+// Existem três especiais valores não-é-número-real:
+Infinity; // resultado de 1/0
+-Infinity; // resultado de -1/0
+NaN; // resultado de 0/0
 
-// There's also a boolean type.
+// Existe também o tipo booleano.
 true;
 false;
 
-// Strings are created with ' or ".
+// Strings são criados com ' ou ".
 'abc';
-"Hello, world";
+"Olá, mundo";
 
 // Negation uses the ! symbol
+// Negação usa o símbolo !
 !true; // = false
 !false; // = true
 
-// Equality is ===
+// Igualdade é ===
 1 === 1; // = true
 2 === 1; // = false
 
-// Inequality is !==
+// Desigualdade é !==
 1 !== 1; // = false
 2 !== 1; // = true
 
-// More comparisons
+// Mais comparações
 1 < 10; // = true
 1 > 10; // = false
 2 <= 2; // = true
 2 >= 2; // = true
 
-// Strings are concatenated with +
-"Hello " + "world!"; // = "Hello world!"
+// Strings são concatenadas com +
+"Olá " + "mundo!"; // = "Olá mundo!"
 
-// and are compared with < and >
+// e comparadas com < e >
 "a" < "b"; // = true
 
-// Type coercion is performed for comparisons with double equals...
+// A coerção de tipos é feita para comparações com dois iguais...
 "5" == 5; // = true
 null == undefined; // = true
 
-// ...unless you use ===
+// ...a menos que use ===
 "5" === 5; // = false
 null === undefined; // = false 
 
-// ...which can result in some weird behaviour...
+// ...que irá resultar num comportamento estranho...
 13 + !0; // 14
 "13" + !0; // '13true'
 
-// You can access characters in a string with `charAt`
-"This is a string".charAt(0);  // = 'T'
+// Você pode acessar caracteres de uma String usando o `charAt`
+"Isto é uma String".charAt(0);  // = 'I'
 
-// ...or use `substring` to get larger pieces.
-"Hello world".substring(0, 5); // = "Hello"
+// ...ou usar `substring` para pegar pedaços maiores.
+"Olá mundo".substring(0, 3); // = "Olá"
 
-// `length` is a property, so don't use ().
-"Hello".length; // = 5
+// `length` é uma propriedade, portanto não use ().
+"Olá".length; // = 3
 
-// There's also `null` and `undefined`.
-null;      // used to indicate a deliberate non-value
-undefined; // used to indicate a value is not currently present (although
-           // `undefined` is actually a value itself)
+// Existe também o `null` e o `undefined`.
+null;      // usado para indicar um valor não considerado
+undefined; // usado para indicar um valor que não é a atualmente definido
+           // (entretando `undefined` é usado como um próprio valor
 
-// false, null, undefined, NaN, 0 and "" are falsy; everything else is truthy.
-// Note that 0 is falsy and "0" is truthy, even though 0 == "0".
+// false, null, undefined, NaN, 0 and "" são valores falsy;
+// qualquer outro valor é truthy
+// Note que 0 é falsy e "0" é truthy, até mesmo 0 == "0".
 
 ///////////////////////////////////
 // 2. Variables, Arrays and Objects
-- 
cgit v1.2.3


From 716e0ced466ef98f7fb9d78d15a5ab606b6b755c Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Thu, 1 Oct 2015 23:48:05 -0300
Subject: =?UTF-8?q?[javascript=20pt-br]=20:=202.=20Vari=C3=A1veis,=20Array?=
 =?UTF-8?q?s=20e=20Objetos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/javascript-pt.html.markdown | 57 ++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 27 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 72f4cf0f..6667a77d 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -132,62 +132,65 @@ undefined; // usado para indicar um valor que não é a atualmente definido
 // Note que 0 é falsy e "0" é truthy, até mesmo 0 == "0".
 
 ///////////////////////////////////
-// 2. Variables, Arrays and Objects
+// 2. Variáveis, Arrays e Objetos
 
-// Variables are declared with the `var` keyword. JavaScript is dynamically
-// typed, so you don't need to specify type. Assignment uses a single `=`
-// character.
+// Variáveis são declarados com a palavra-chave `var`. O Javascript é 
+// dinâmicamente tipado, portanto você não precisa especificar o tipo.
+// Atribuições usam um simples caracter de `=`.
 var someVar = 5;
 
-// if you leave the var keyword off, you won't get an error...
+// se você deixar de colocar a palavra-chave var, você não receber um erro...
 someOtherVar = 10;
 
-// ...but your variable will be created in the global scope, not in the scope
-// you defined it in.
+// ...mas sua variável será criada no escopo global, não no escopo em que você
+// definiu ela.
 
-// Variables declared without being assigned to are set to undefined.
+// Variáveis declaradas sem receberem um valor são definidas como `undefined`.
 var someThirdVar; // = undefined
 
-// There's shorthand for performing math operations on variables:
-someVar += 5; // equivalent to someVar = someVar + 5; someVar is 10 now
-someVar *= 10; // now someVar is 100
+// Existe um shorthad para operações matemáticas em variáveis:
+someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora
+someVar *= 10; // agora someVar é 100
 
-// and an even-shorter-hand for adding or subtracting 1
+// e um para adição e subtração de 1
 someVar++; // now someVar is 101
 someVar--; // back to 100
 
-// Arrays are ordered lists of values, of any type.
-var myArray = ["Hello", 45, true];
+// Arrays são listas ordenadas de valores, de qualquer tipo.
+var myArray = ["Olá", 45, true];
 
-// Their members can be accessed using the square-brackets subscript syntax.
-// Array indices start at zero.
+// Seus membros podem ser acessados usando a sintaxe de colchetes.
+// O indíce de um Array começa pelo 0.
 myArray[1]; // = 45
 
-// Arrays are mutable and of variable length.
+// Arrays são mutáveis e de tamanho variável.
 myArray.push("World");
 myArray.length; // = 4
 
-// Add/Modify at specific index
+// Adicionar/modificar em um índice específico
 myArray[3] = "Hello";
 
-// JavaScript's objects are equivalent to "dictionaries" or "maps" in other
-// languages: an unordered collection of key-value pairs.
-var myObj = {key1: "Hello", key2: "World"};
+// Objetos de Javascript são equivalentes aos dicionários ou maps de outras
+// linguagens: uma coleção não ordenada de pares chave-valor.
+var myObj = {chave1: "Olá", chave2: "Mundo"};
 
-// Keys are strings, but quotes aren't required if they're a valid
-// JavaScript identifier. Values can be any type.
+// Chaves são strings, mas as aspas não são necessárias se elas são
+// identificadores válidos no Javascript. Valores podem ser de qualquer tipo.
 var myObj = {myKey: "myValue", "my other key": 4};
 
-// Object attributes can also be accessed using the subscript syntax,
+// Atributos de objetos também podem ser acessados com a sintaxe de colchetes.
 myObj["my other key"]; // = 4
 
-// ... or using the dot syntax, provided the key is a valid identifier.
+// ... ou usando a sintaxe de ponto, passando a chave que é um identificador
+// válido.
 myObj.myKey; // = "myValue"
 
-// Objects are mutable; values can be changed and new keys added.
+// Objetos são mutáveis, valores podem ser modificados e novas chaves 
+// adicionadas.
 myObj.myThirdKey = true;
 
-// If you try to access a value that's not yet set, you'll get undefined.
+// Se você tentar acessar um valor que não foi determinado ainda, você irá
+// receber `undefined`.
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
-- 
cgit v1.2.3


From 32caaabe05e2d920c4be42c278e2e6d51ddea6ed Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Fri, 2 Oct 2015 01:05:31 -0300
Subject: =?UTF-8?q?[javascript=20pt-br]=20:=203.=20L=C3=B3gica=20e=20Estru?=
 =?UTF-8?q?turas=20de=20Controle?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/javascript-pt.html.markdown | 42 ++++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 6667a77d..14d82146 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -194,52 +194,54 @@ myObj.myThirdKey = true;
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
-// 3. Logic and Control Structures
+// 3. Lógica e Estruturas de Controle
 
-// The syntax for this section is almost identical to Java's. 
+// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
 
 // The `if` structure works as you'd expect.
-var count = 1;
+// A estrutura `if` funciona como deveria ser.
+var count = 1
 if (count == 3){
-    // evaluated if count is 3
+    // executa se count é 3
 } else if (count == 4){
-    // evaluated if count is 4
+    // executa se count é 4
 } else {
-    // evaluated if it's not either 3 or 4
+    // executa se count não é 3 nem 4
 }
 
-// As does `while`.
+// Como se faz `while`.
 while (true){
-    // An infinite loop!
+    // Um loop infinito!
 }
 
-// Do-while loops are like while loops, except they always run at least once.
-var input;
+// Os loops do-while são como os loops de while, exceto quando eles sempre
+// executam pelo menos uma vez.
 do {
     input = getInput();
 } while (!isValid(input))
 
 // The `for` loop is the same as C and Java:
 // initialisation; continue condition; iteration.
+
+// O loop `for` é o mesmo de C e Java:
+// inicialização, condição de continuar; iteração
 for (var i = 0; i < 5; i++){
-    // will run 5 times
+    // vai rodar cinco vezes
 }
 
-// && is logical and, || is logical or
+// && é o `e` lógico , || é o `ou` lógico
 if (house.size == "big" && house.colour == "blue"){
     house.contains = "bear";
 }
-if (colour == "red" || colour == "blue"){
-    // colour is either red or blue
+if (cor == "red" || cor == "blue"){
+    // cor é vermelha OU azul
 }
 
-// && and || "short circuit", which is useful for setting default values.
-var name = otherName || "default";
-
+// && e || "pequeno circuito", é útil para determinar valores padrões.
+var name = otherName || "padrão";
 
-// The `switch` statement checks for equality with `===`.
-// use 'break' after each case 
-// or the cases after the correct one will be executed too. 
+// O `switch` checa pela igualdade com `===`.
+// Use `break` após cada `case`
 grade = 'B';
 switch (grade) {
   case 'A':
-- 
cgit v1.2.3


From 2534c71c4f5cc8f6b806914857da11b8ae89f45d Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Fri, 2 Oct 2015 01:23:46 -0300
Subject: =?UTF-8?q?[javascript=20pt-br]=20:=20Fun=C3=A7=C3=B5es,=20Escopos?=
 =?UTF-8?q?=20e=20Closures?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/javascript-pt.html.markdown | 79 +++++++++++++++++++++------------------
 1 file changed, 42 insertions(+), 37 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 14d82146..08448d0b 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -209,7 +209,7 @@ if (count == 3){
     // executa se count não é 3 nem 4
 }
 
-// Como se faz `while`.
+// Como se faz um `while`.
 while (true){
     // Um loop infinito!
 }
@@ -224,7 +224,7 @@ do {
 // initialisation; continue condition; iteration.
 
 // O loop `for` é o mesmo de C e Java:
-// inicialização, condição de continuar; iteração
+// inicialização, condição para continuar; iteração
 for (var i = 0; i < 5; i++){
     // vai rodar cinco vezes
 }
@@ -260,79 +260,84 @@ switch (grade) {
 
 
 ///////////////////////////////////
-// 4. Functions, Scope and Closures
+// 4. Funções, Escopos e Closures
 
-// JavaScript functions are declared with the `function` keyword.
+// Funções Javascript são declaradas com a palavra-chave `function`.
 function myFunction(thing){
     return thing.toUpperCase();
 }
 myFunction("foo"); // = "FOO"
 
-// Note that the value to be returned must start on the same line as the
-// `return` keyword, otherwise you'll always return `undefined` due to
-// automatic semicolon insertion. Watch out for this when using Allman style.
+// Repare que o valor a ser retornado deve começar na mesma linha que
+// a palavra-chave `return`, senão você sempre irá retornar `undefined` 
+// visto que o ponto-e-vírgula é inserido automáticamente nas quebras de 
+// linha. Preste atenção quando usar o estilo Allman.
 function myFunction()
 {
-    return // <- semicolon automatically inserted here
+    return // <- ponto-e-vírgula adicionado automaticamente aqui
     {
         thisIsAn: 'object literal'
     }
 }
 myFunction(); // = undefined
 
-// JavaScript functions are first class objects, so they can be reassigned to
-// different variable names and passed to other functions as arguments - for
-// example, when supplying an event handler:
+// Funções Javascript são objetos de primeira classe, portanto elas podem
+// ser atribuídas a nomes de variáveis e serem passadas para outras funções
+// como argumentos - por exemplo, quando criamos um manipulador de eventos:
 function myFunction(){
-    // this code will be called in 5 seconds' time
+    // este código será chamado em 5 segundos
 }
 setTimeout(myFunction, 5000);
-// Note: setTimeout isn't part of the JS language, but is provided by browsers
-// and Node.js.
+// Nota: `setTimeout` não é parte da linguagem Javascript, mas é provido pelos
+// browsers e o Node.js.
 
-// Function objects don't even have to be declared with a name - you can write
-// an anonymous function definition directly into the arguments of another.
+// Objetos de funções não precisam nem serem declarados com nome - você pode 
+// escrever a definição de uma função anônima diretamente nos argumentos de 
+// outra função.
 setTimeout(function(){
-    // this code will be called in 5 seconds' time
+    // este código será chamado em 5 segundos
 }, 5000);
 
-// JavaScript has function scope; functions get their own scope but other blocks
-// do not.
+// O Javascript tem escopo de função; as funções tem seu próprio escopo, 
+// mas outros blocos não.
 if (true){
     var i = 5;
 }
-i; // = 5 - not undefined as you'd expect in a block-scoped language
+i; // = 5 - não `undefined` como você esperaria numa linguagem de blogo-escopo
 
-// This has led to a common pattern of "immediately-executing anonymous
-// functions", which prevent temporary variables from leaking into the global
-// scope.
+// Isso levou a padrão comum chamado de IIFE (Imediately Invoked Function 
+// Expression) ou (Expressão de Função Invocada Imediatamente), que previne
+// que variáveis temporárias vazem para o escopo global.
 (function(){
     var temporary = 5;
-    // We can access the global scope by assiging to the "global object", which
-    // in a web browser is always `window`. The global object may have a
-    // different name in non-browser environments such as Node.js.
+    // Nós podemos acessar o escopo global definindo o "objeto global", que
+    // no browser vai ser sempre `window`. O objeto global pode ter um nome
+    // diferente para ambiente não-browser como o Node.js.
     window.permanent = 10;
 })();
-temporary; // raises ReferenceError
+temporary; // levanta um erro de referência inexiste
 permanent; // = 10
 
-// One of JavaScript's most powerful features is closures. If a function is
-// defined inside another function, the inner function has access to all the
-// outer function's variables, even after the outer function exits.
+// Uma das principais características do Javascript é a closure. Que é
+// uma função definida dentro de outra função, a função interna pode acessar
+// todas as variáveis da função externa, mesmo depois da função de fora
+// finalizar sua execução.
 function sayHelloInFiveSeconds(name){
     var prompt = "Hello, " + name + "!";
-    // Inner functions are put in the local scope by default, as if they were
-    // declared with `var`.
+
+    // Funções internas são colocadas no escopo local por padrão, assim como
+    // se fossem declaradas com `var`. 
     function inner(){
         alert(prompt);
     }
     setTimeout(inner, 5000);
-    // setTimeout is asynchronous, so the sayHelloInFiveSeconds function will
-    // exit immediately, and setTimeout will call inner afterwards. However,
-    // because inner is "closed over" sayHelloInFiveSeconds, inner still has
-    // access to the `prompt` variable when it is finally called.
+    // `setTimeout` é assíncrono, portanto a função `sayHelloInFiveSeconds`
+    // vai sair imediatamente, e o `setTimeout` irá chamar a interna depois.
+    // Entretanto. como a interna é fechada dentro de "sayHelloInFiveSeconds",
+    // a interna permanece podendo acessar a variável `prompt` quando depois
+    // de chamada.
 }
-sayHelloInFiveSeconds("Adam"); // will open a popup with "Hello, Adam!" in 5s
+sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s
 
 ///////////////////////////////////
 // 5. More about Objects; Constructors and Prototypes
-- 
cgit v1.2.3


From 466b51d9fa4a223014b0d1d79d3d55709c32373d Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Sat, 3 Oct 2015 13:49:07 -0300
Subject: [javascript pt-br] : 5. More about Objects; Constructors and
 Prototypes

---
 pt-br/javascript-pt.html.markdown | 134 ++++++++++++++++++++------------------
 1 file changed, 69 insertions(+), 65 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 08448d0b..097a1a8e 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -340,75 +340,74 @@ function sayHelloInFiveSeconds(name){
 sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s
 
 ///////////////////////////////////
-// 5. More about Objects; Constructors and Prototypes
+// 5. Mais sobre Objetos; Construtores e Prototypes
 
-// Objects can contain functions.
+// Objetos podem conter funções.
 var myObj = {
     myFunc: function(){
-        return "Hello world!";
+        return "Olá mundo!";
     }
 };
-myObj.myFunc(); // = "Hello world!"
+myObj.myFunc(); // = "Olá mundo!"
 
-// When functions attached to an object are called, they can access the object
-// they're attached to using the `this` keyword.
+// Quando uma função ligada a um objeto é chamada, ela pode acessar o objeto
+// da qual foi ligada usando a palavra-chave `this`. 
 myObj = {
-    myString: "Hello world!",
+    myString: "Olá mundo!",
     myFunc: function(){
         return this.myString;
     }
 };
-myObj.myFunc(); // = "Hello world!"
+myObj.myFunc(); // = "Olá mundo!"
 
-// What this is set to has to do with how the function is called, not where
-// it's defined. So, our function doesn't work if it isn't called in the
-// context of the object.
+// O `this` só funciona para dentro do escopo do objeto, portanto, se chamarmos 
+// um método do objeto fora de seu escopo, este não irá funcionar.
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// Inversely, a function can be assigned to the object and gain access to it
-// through `this`, even if it wasn't attached when it was defined.
+// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// através do `this`, até mesmo se ela não for chamada quando foi definida.
 var myOtherFunc = function(){
     return this.myString.toUpperCase();
 }
 myObj.myOtherFunc = myOtherFunc;
-myObj.myOtherFunc(); // = "HELLO WORLD!"
+myObj.myOtherFunc(); // = "OLÁ MUNDO!"
 
-// We can also specify a context for a function to execute in when we invoke it
-// using `call` or `apply`.
+// Nós podemos também especificar um contexto onde a função irá executar, 
+// usando o `call` ou `apply`.
 
 var anotherFunc = function(s){
     return this.myString + s;
 }
-anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+anotherFunc.call(myObj, " E Olá Lua!"); // = "Olá mundo! E Olá Lua!"
 
-// The `apply` function is nearly identical, but takes an array for an argument
-// list.
+// A função `apply` é praticamente a mesma coisa,  mas ela pega um array
+// como lista de argumentos.
 
-anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+anotherFunc.apply(myObj, [" E Olá Sol!"]); // = "Olá mundo! E Olá Sol!"
 
-// This is useful when working with a function that accepts a sequence of
-// arguments and you want to pass an array.
+// Isto é util quando trabalhamos com uma função que aceita uma sequência de
+// argumentos e você quer passar um array.
 
 Math.min(42, 6, 27); // = 6
 Math.min([42, 6, 27]); // = NaN (uh-oh!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// But, `call` and `apply` are only temporary. When we want it to stick, we can
-// use `bind`.
+// Mas, o `call` e `apply` são somente temporários. Quando você quiser que 
+// permaneça sempre no escopo, use `bind`.
 
 var boundFunc = anotherFunc.bind(myObj);
-boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+boundFunc(" E Olá Saturno!"); // = "Olá mundo! E Olá Saturno!"
 
-// `bind` can also be used to partially apply (curry) a function.
+// `bind` também pode ser usado para parcialmente aplicar (curry) uma função.
 
 var product = function(a, b){ return a * b; }
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
-// When you call a function with the `new` keyword, a new object is created, and
-// made available to the function via the this keyword. Functions designed to be
-// called like that are called constructors.
+// Quando você invoca uma função com a palavra-chave `new`, um novo objeto
+// é criado, e fica disponível para a função pela palavra-chave `this`. 
+// Funções são desenhadas para serem invocadas como se invocam os construtores.
 
 var MyConstructor = function(){
     this.myNumber = 5;
@@ -416,15 +415,17 @@ var MyConstructor = function(){
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
-// Every JavaScript object has a 'prototype'. When you go to access a property
-// on an object that doesn't exist on the actual object, the interpreter will
-// look at its prototype.
+// Todo objeto JavaScript possui um `prototype`. Quando você tenta acessar 
+// uma propriedade de um objeto que não existe no objeto atual, o interpretador
+// vai olhar imediatamente para o seu prototype.
+
+// Algumas implementações em JS deixam você acessar o objeto prototype com a 
+// propriedade mágica `__proto__`. Enquanto isso é util para explicar 
+// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de 
+// usar prototypes depois.
 
-// Some JS implementations let you access an object's prototype on the magic
-// property `__proto__`. While this is useful for explaining prototypes it's not
-// part of the standard; we'll get to standard ways of using prototypes later.
 var myObj = {
-    myString: "Hello world!"
+    myString: "Olá Mundo!"
 };
 var myPrototype = {
     meaningOfLife: 42,
@@ -437,34 +438,36 @@ myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
 
 // This works for functions, too.
-myObj.myFunc(); // = "hello world!"
+// Isto funciona para funções, também.
+myObj.myFunc(); // = "olá mundo!"
 
-// Of course, if your property isn't on your prototype, the prototype's
-// prototype is searched, and so on.
+// É claro, se sua propriedade não está em seu prototype, 
+// o prototype do prototype será procurado e por aí vai.
 myPrototype.__proto__ = {
     myBoolean: true
 };
 myObj.myBoolean; // = true
 
-// There's no copying involved here; each object stores a reference to its
-// prototype. This means we can alter the prototype and our changes will be
-// reflected everywhere.
+// Não há cópia envolvida aqui; cada objeto guarda uma referência do
+// prototype. Isso significa que podemos alterar o prototype e nossas mudanças
+// serão refletidas em qualquer lugar.
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
-// We mentioned that `__proto__` was non-standard, and there's no standard way to
-// change the prototype of an existing object. However, there are two ways to
-// create a new object with a given prototype.
 
-// The first is Object.create, which is a recent addition to JS, and therefore
-// not available in all implementations yet.
+// Nós mencionamos que o `__proto__` não é uma forma padrão, e não há uma 
+// forma padrão de mudar o prototype de um objeto já existente. Entretanto, 
+// existem duas formas de se criar um objeto com um dado prototype.
+
+// A primeira forma é `Object.create`, que é uma adição recente do JS,
+// e ainda não está disponível em todas as implementações.
 var myObj = Object.create(myPrototype);
 myObj.meaningOfLife; // = 43
 
-// The second way, which works anywhere, has to do with constructors.
-// Constructors have a property called prototype. This is *not* the prototype of
-// the constructor function itself; instead, it's the prototype that new objects
-// are given when they're created with that constructor and the new keyword.
+// A segunda forma, que funciona em qualquer lugar, é feita com construtores.
+// Construtores tem uma propriedade chamada prototype. Este *não* é o prototype
+// do construtor em si; ao invés disso, ele é o prototype dos novos objetos
+// criados pelo construtor.
 MyConstructor.prototype = {
     myNumber: 5,
     getMyNumber: function(){
@@ -476,42 +479,43 @@ myNewObj2.getMyNumber(); // = 5
 myNewObj2.myNumber = 6
 myNewObj2.getMyNumber(); // = 6
 
-// Built-in types like strings and numbers also have constructors that create
-// equivalent wrapper objects.
+// Tipos originais da linguagem como strings e números também possuem
+// construtores equivalentes. 
 var myNumber = 12;
 var myNumberObj = new Number(12);
 myNumber == myNumberObj; // = true
 
-// Except, they aren't exactly equivalent.
+// Exceto, que eles não são totalmente equivalentes.
 typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
 if (0){
-    // This code won't execute, because 0 is falsy.
+    // O código não vai executar, porque 0 é um valor falso.
 }
 if (Number(0)){
-    // This code *will* execute, because Number(0) is truthy.
+    // O código *vai* executar, porque `Number(0)` é um valor verdadeiro.
 }
 
-// However, the wrapper objects and the regular builtins share a prototype, so
-// you can actually add functionality to a string, for instance.
+// Entretanto, esses objetos encapsulados e as funções originais compartilham
+// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// por exemplo.
 String.prototype.firstCharacter = function(){
     return this.charAt(0);
 }
 "abc".firstCharacter(); // = "a"
 
-// This fact is often used in "polyfilling", which is implementing newer
-// features of JavaScript in an older subset of JavaScript, so that they can be
-// used in older environments such as outdated browsers.
+// Esse fato é usado para criar os chamados `polyfills`, que implementam
+// uma nova característica do Javascript em uma versão mais velha, para que
+// assim funcionem em ambientes mais velhos como browsers ultrapassados.
 
-// For instance, we mentioned that Object.create isn't yet available in all
-// implementations, but we can still use it with this polyfill:
+// Havíamos mencionado que `Object.create` não estava ainda disponível em 
+// todos as implementações, mas nós podemos usá-lo com esse polyfill:
 if (Object.create === undefined){ // don't overwrite it if it exists
     Object.create = function(proto){
-        // make a temporary constructor with the right prototype
+        // faz um construtor temporário com o prototype certo
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // then use it to create a new, appropriately-prototyped object
+        // então utiliza o new para criar um objeto prototype apropriado
         return new Constructor();
     }
 }
-- 
cgit v1.2.3


From 46d509077f10fc9b04aaf69829526d4b8297798d Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Sat, 3 Oct 2015 14:03:54 -0300
Subject: [javascript pt-br] : Leitura Adicional

---
 pt-br/javascript-pt.html.markdown | 43 ++++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 21 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 097a1a8e..f4b5ed2c 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -521,30 +521,31 @@ if (Object.create === undefined){ // don't overwrite it if it exists
 }
 ```
 
-## Further Reading
-
-The [Mozilla Developer
-Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides
-excellent documentation for JavaScript as it's used in browsers. Plus, it's a
-wiki, so as you learn more you can help others out by sharing your own
-knowledge.
-
-MDN's [A re-introduction to
-JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
-covers much of the concepts covered here in more detail. This guide has quite
-deliberately only covered the JavaScript language itself; if you want to learn
-more about how to use JavaScript in web pages, start by learning about the
+## Leitura Adicional
+
+O [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) dispõe de uma
+excelente documentação sobre Javascript e seu uso nos browsers. E mais, 
+é uma wiki, portanto conforme você vai aprendendo, mais você pode ir ajudando
+os outros compartilhando do seu conhecimento.
+
+[Uma re-introdução do JavaScript pela MDN]
+(https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cobre muito dos conceitos abordados aqui em mais detalhes. Este guia fala
+somente sobre a linguagem JavaScript em si; se você quiser aprender mais
+sobre e como usar o JavaScript em páginas na web, comece aprendendo sobre
 [Document Object
 Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
 
-[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges. 
+[Aprenda Javascript por Exemplos e com Desafios](http://www.learneroo.com/modules/64/nodes/350) é uma
+variação desse guia com desafios.
 
-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
-guide of all the counter-intuitive parts of the language.
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) é um guia 
+profundo de todas as partes do JavaScript.
 
-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book. 
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) é o guia clássico
+/ livro de referência. 
 
-In addition to direct contributors to this article, some content is adapted
-from Louie Dinh's Python tutorial on this site, and the [JS
-Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
-on the Mozilla Developer Network.
+Parte desse artigo foi adaptado do tutorial de Python do Louie Dinh que está
+nesse site e do [Tutorial de JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+da Mozilla Developer Network.
-- 
cgit v1.2.3


From 0d2863186231324b14e8d3a1d25aa8e44078aa68 Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Sat, 3 Oct 2015 21:03:58 -0300
Subject: Sync pt with original js

---
 pt-br/javascript-pt.html.markdown | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index f4b5ed2c..e39c6c8e 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -492,9 +492,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // O código não vai executar, porque 0 é um valor falso.
 }
-if (Number(0)){
-    // O código *vai* executar, porque `Number(0)` é um valor verdadeiro.
-}
 
 // Entretanto, esses objetos encapsulados e as funções originais compartilham
 // um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
-- 
cgit v1.2.3


From 1194e9456f2f1302614f8086349c01f4797d34c0 Mon Sep 17 00:00:00 2001
From: willianjusten <willianjustenqui@gmail.com>
Date: Sun, 4 Oct 2015 16:13:11 -0300
Subject: Fixing some typos

---
 pt-br/javascript-pt.html.markdown | 45 +++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

(limited to 'pt-br/javascript-pt.html.markdown')

diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index e39c6c8e..406042fa 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -3,20 +3,21 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
-filename: javascript.js
+translators:
+    - ["Willian Justen", "http://willianjusten.com.br"]
+lang: pt-br
 ---
 
-JavaScript foi criada por Brendan Eich, funcionário da Netscape, em 1995. Ela
+JavaScript foi criada por Brendan Eich, funcionário da Netscape na época, em 1995. Ela
 foi originalmente criada para ser uma linguagem de script para websites,
 complementando o uso de Java para aplicações web mais complexas, mas a sua
 integração com páginas web e seu suporte nativo nos browsers fez com que
 ela se tornasse mais comum que Java no frontend web.
 
-Javascript não é somente limitado a browsers web, no entanto: existe o Node.js,
+Javascript não é somente limitada a browsers web, existindo o Node.js,
 que é um projeto que fornece um interpretador baseado no motor V8 do Google 
 Chrome e está se tornando cada vez mais famoso.
 
-
 Feedback são muito apreciados! Você me encontrar em
 [@adambrenecki](https://twitter.com/adambrenecki), ou
 [adam@brenecki.id.au](mailto:adam@brenecki.id.au).
@@ -29,23 +30,23 @@ Feedback são muito apreciados! Você me encontrar em
 // comandos podem ser terminados com  ;
 facaAlgo();
 
-// ... mas eles não precisam ser, assim como o ponto-e-vírgula é automaticamente
+// ... mas eles não precisam ser, o ponto-e-vírgula é automaticamente
 // inserido quando há uma nova linha, exceto alguns casos.
 facaAlgo()
 
-// Porque esses casos podem causar resultados inesperados, vamos continuar 
+// Como esses casos podem causar resultados inesperados, vamos continuar 
 // a usar ponto-e-vírgula neste guia.
 
 ///////////////////////////////////
 // 1. Números, Strings e Operadores
 
 // Javascript tem um tipo de número (que é o 64-bit IEEE 754 double).
-// Doublas tem uma mantissa 52-bit, que é suficiente para guardar inteiros
+// Doubles tem uma mantissa 52-bit, que é suficiente para guardar inteiros
 // acima de 9✕10¹⁵ precisamente.
 3; // = 3
 1.5; // = 1.5
 
-// A aritmética básica funciona seria de esperar.
+// A aritmética básica funciona como seria de se esperar.
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
@@ -62,7 +63,6 @@ facaAlgo()
 // A precedência é aplicada com parênteses.
 (1 + 3) * 2; // = 8
 
-// There are three special not-a-real-number values:
 // Existem três especiais valores não-é-número-real:
 Infinity; // resultado de 1/0
 -Infinity; // resultado de -1/0
@@ -76,16 +76,15 @@ false;
 'abc';
 "Olá, mundo";
 
-// Negation uses the ! symbol
 // Negação usa o símbolo !
 !true; // = false
 !false; // = true
 
-// Igualdade é ===
+// Igualdade é o sinal de ===
 1 === 1; // = true
 2 === 1; // = false
 
-// Desigualdade é !==
+// Desigualdade é o sinal de !==
 1 !== 1; // = false
 2 !== 1; // = true
 
@@ -101,7 +100,7 @@ false;
 // e comparadas com < e >
 "a" < "b"; // = true
 
-// A coerção de tipos é feita para comparações com dois iguais...
+// A comparação de tipos não é feita com o uso de ==...
 "5" == 5; // = true
 null == undefined; // = true
 
@@ -109,7 +108,7 @@ null == undefined; // = true
 "5" === 5; // = false
 null === undefined; // = false 
 
-// ...que irá resultar num comportamento estranho...
+// ...isso pode resultar em comportamentos estranhos...
 13 + !0; // 14
 "13" + !0; // '13true'
 
@@ -125,21 +124,21 @@ null === undefined; // = false
 // Existe também o `null` e o `undefined`.
 null;      // usado para indicar um valor não considerado
 undefined; // usado para indicar um valor que não é a atualmente definido
-           // (entretando `undefined` é usado como um próprio valor
+           // (entretando `undefined` é considerado de fato um valor
 
-// false, null, undefined, NaN, 0 and "" são valores falsy;
-// qualquer outro valor é truthy
-// Note que 0 é falsy e "0" é truthy, até mesmo 0 == "0".
+// false, null, undefined, NaN, 0 and "" são valores falsos;
+// qualquer outro valor é verdadeiro
+// Note que 0 é falso e "0" é verdadeiro, até mesmo 0 == "0".
 
 ///////////////////////////////////
 // 2. Variáveis, Arrays e Objetos
 
-// Variáveis são declarados com a palavra-chave `var`. O Javascript é 
+// Variáveis são declaradas com a palavra-chave `var`. O Javascript é 
 // dinâmicamente tipado, portanto você não precisa especificar o tipo.
 // Atribuições usam um simples caracter de `=`.
 var someVar = 5;
 
-// se você deixar de colocar a palavra-chave var, você não receber um erro...
+// se você deixar de colocar a palavra-chave var, você não irá receber um erro...
 someOtherVar = 10;
 
 // ...mas sua variável será criada no escopo global, não no escopo em que você
@@ -148,13 +147,13 @@ someOtherVar = 10;
 // Variáveis declaradas sem receberem um valor são definidas como `undefined`.
 var someThirdVar; // = undefined
 
-// Existe um shorthad para operações matemáticas em variáveis:
+// Existe um shorthand para operações matemáticas em variáveis:
 someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora
 someVar *= 10; // agora someVar é 100
 
 // e um para adição e subtração de 1
-someVar++; // now someVar is 101
-someVar--; // back to 100
+someVar++; // agora someVar é 101
+someVar--; // volta para 100
 
 // Arrays são listas ordenadas de valores, de qualquer tipo.
 var myArray = ["Olá", 45, true];
-- 
cgit v1.2.3