Resolve conficts / Update files

Author: odsantos

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -2,15 +2,9 @@
 
 Antes de escrevermos código mais complexo, vamos falar de debugging (depuração de erros).
 
-<<<<<<< HEAD
-[Depuração](https://pt.wikipedia.org/wiki/Depura%C3%A7%C3%A3o) é o processo de procura e correção de erros num programa. Todos os navegadores (*browsers*) modernos e muitas outras plataformas (*environments*) suportam ferramentas de *debugging* -- uma UI (Interface de Utilizador) disponível nas ferramentas do desenvolvedor (*developer tools*) que torna a depuração de erros muito mais fácil. Ela também permite rastrear o código passo-a-passo para ver exactamente o que está a ser executado.
-
-Aqui, vamos utilizar o Chrome porque tem bastantes funcionalidades, mas a maioria dos outros navegadores possuem um processo similar.
-=======
-[Debugging](https://en.wikipedia.org/wiki/Debugging) is the process of finding and fixing errors within a script. All modern browsers and most other environments support debugging tools -- a special UI in developer tools that makes debugging much easier. It also allows to trace the code step by step to see what exactly is going on.
+[Depuração](https://pt.wikipedia.org/wiki/Depura%C3%A7%C3%A3o) é o processo de procura e correção de erros num programa. Todos os navegadores (*browsers*) modernos e muitas outras plataformas (*environments*) suportam ferramentas de *debugging* -- uma UI (Interface de Utilizador) especial disponível nas ferramentas do desenvolvedor (*developer tools*) que torna a depuração de erros muito mais fácil. Ela também permite rastrear o código passo-a-passo para ver exatamente o que está a ser executado.
 
-We'll be using Chrome here, because it has enough features, most other browsers have a similar process.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+Aqui, vamos utilizar o Chrome porque tem muitas funcionalidades, mas a maioria dos outros navegadores possuem um processo similar.
 
 ## O painel "*Sources*"
 
@@ -24,33 +18,19 @@ Aqui está o que poderá ver, se o estiver a fazer pela primeira vez:
 
 ![](chrome-open-sources.svg)
 
-<<<<<<< HEAD
 O botão de alternador <span class="devtools" style="background-position:-172px -98px"></span> abre o separador com os ficheiros.
-=======
-The toggler button <span class="devtools" style="background-position:-172px -98px"></span> opens the tab with files.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 Vamos clicar nele, e selecionar `hello.js`  na vista de árvore de recursos apresentada. Aqui está o que deveria ser mostrado:
 
 ![](chrome-tabs.svg)
 
-<<<<<<< HEAD
 O painel *Sources* possui 3 partes:
 
 1. O painel **File Navigator**, lista ficheiros de HTML, JavaScript, CSS e outros, incluindo imagens anexadas à página. Extensões ao Chrome (*Chrome extensions*) também podem aparecer aqui.
 2. O painel **Code Editor**, mostra o código-fonte.
 3. O painel **JavaScript Debugging**, é para a depuração de erros; iremos explorá-lo em breve.
 
 Agora, poderia clicar novamente no mesmo botão de alternador <span class="devtools" style="background-position:-172px -122px"></span> para ocultar a lista de recursos e dar ao código algum espaço.
-=======
-The Sources panel has 3 parts:
-
-1. The **File Navigator** pane lists HTML, JavaScript, CSS and other files, including images that are attached to the page. Chrome extensions may appear here too.
-2. The **Code Editor** pane shows the source code.
-3. The **JavaScript Debugging** pane is for debugging, we'll explore it soon.
-
-Now you could click the same toggler <span class="devtools" style="background-position:-172px -122px"></span> again to hide the resources list and give the code some space.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 ## Console
 

1-js/03-code-quality/02-coding-style/1-style-errors/solution.md

@@ -10,21 +10,12 @@ function pow(x,n)  // <- nenhum espaço entre argumentos
   return result;
 }
 
-<<<<<<< HEAD
 let x=prompt("x?",''), n=prompt("n?",'') // <-- tecnicamente possível,
-// mas o melhor é torná-la em 2 linhas, também não existem espaços, e falta o ;
+// mas o melhor é a tornar em 2 linhas, também não existem espaços, e falta o ;
 if (n<0)  // <- nenhum espaço dentro (n < 0), e deveria existir uma linha extra sobre a condição
 {   // <- chaveta de abertura numa linha em separado
   // abaixo - linhas longas podem ser repartidas por múltiplas linhas para melhorar a legíbilidade
   alert(`A potência de ${n} não é suportada, por favor insira um número inteiro maior do que zero`);
-=======
-let x=prompt("x?",''), n=prompt("n?",'') // <-- technically possible,
-// but better make it 2 lines, also there's no spaces and missing ;
-if (n<=0)  // <- no spaces inside (n <= 0), and should be extra line above it
-{   // <- figure bracket on a separate line
-  // below - long lines can be split into multiple lines for improved readability
-  alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 }
 else // <- poderia ser escrito numa única linha, como "} else {"
 {
@@ -48,14 +39,8 @@ function pow(x, n) {
 let x = prompt("x?", "");
 let n = prompt("n?", "");
 
-<<<<<<< HEAD
 if (n < 0) {
   alert(`A potência de ${n} não é suportada, por favor insira um número inteiro maior do que zero`);
-=======
-if (n <= 0) {
-  alert(`Power ${n} is not supported,
-    please enter an integer number greater than zero`);
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 } else {
   alert( pow(x, n) );
 }

1-js/03-code-quality/02-coding-style/article.md

@@ -25,13 +25,8 @@ let x = prompt("x?", "");
 let n = prompt("n?", "");
 
 if (n < 0) {
-<<<<<<< HEAD
   alert(`A potência de ${n} não é suportada,
     por favor insira um número inteiro positivo`);
-=======
-  alert(`Power ${n} is not supported,
-    please enter a non-negative integer number`);
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 } else {
   alert( pow(x, n) );
 }
@@ -92,14 +87,7 @@ Por exemplo:
 ```js
 // o acento grave (*backtick*) ` permite repartir uma *string* por múltiplas linhas
 let str = `
-<<<<<<< HEAD
-  O TC39 da ECMA International, é um grupo de desenvolvedores e implementadores de  JavaScript, académicos, e outros, colaborando com a comunidade para manter e
-  evoluir a definição de JavaScript.
-=======
-  ECMA International's TC39 is a group of JavaScript developers,
-  implementers, academics, and more, collaborating with the community
-  to maintain and evolve the definition of JavaScript.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+  O TC39 da ECMA International, é um grupo de desenvolvedores e implementadores de JavaScript, académicos, e outros, colaborando com a comunidade para manter e evoluir a definição de JavaScript.
 `;
 ```
 

1-js/03-code-quality/03-comments/article.md

@@ -124,7 +124,6 @@ Descreva a arquitetura
 Documente os parâmetros e o uso da função
 : Existe uma sintaxe especial, [JSDoc](http://en.wikipedia.org/wiki/JSDoc), para documentar uma função: o seu uso, parâmetros, e valor retornado.
 
-<<<<<<< HEAD
 Por exemplo:
 
 ```js
@@ -134,35 +133,17 @@ Por exemplo:
  * @param {number} x O número a elevar.
  * @param {number} n A potência, deve ser um número natural.
  * @return {number} x elevado à n-ésima potência.
-=======
-For instance:
-```js
-/**
- * Returns x raised to the n-th power.
- *
- * @param {number} x The number to raise.
- * @param {number} n The power, must be a natural number.
- * @return {number} x raised to the n-th power.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
  */
 function pow(x, n) {
   ...
 }
 ```
 
-<<<<<<< HEAD
 Tais comentários, nos permitem compreender o propósito da função e a usar de forma correta, sem olhar para o seu código.
 
 A propósito, muitos editores, como o [WebStorm](https://www.jetbrains.com/webstorm/, podem também os perceber e os usar para fornecer completação automática de palavras (*autocomplete*), e algumas verificações de código (*code-checking*) automáticas.
 
 Também, existem ferramentas como o [JSDoc 3](https://github.com/jsdoc3/jsdoc), que podem gerar documentação HTML a partir de comentários. Pode ler mais informação sobre o JSDoc em <http://usejsdoc.org/>.
-=======
-Such comments allow us to understand the purpose of the function and use it the right way without looking in its code.
-
-By the way, many editors like [WebStorm](https://www.jetbrains.com/webstorm/) can understand them as well and use them to provide autocomplete and some automatic code-checking.
-
-Also, there are tools like [JSDoc 3](https://github.com/jsdoc3/jsdoc) that can generate HTML-documentation from the comments. You can read more information about JSDoc at <http://usejsdoc.org/>.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 Porque é a tarefa solucionada dessa forma?
 : O que está escrito é importante. Mas, o que *não* está escrito pode ser ainda mais importante, para se compreender o que se passa. Porque é a tarefa solucionada exatamente dessa forma? O código não dá resposta alguma.
@@ -193,12 +174,7 @@ Bons comentários, nos permitem manter o código saudável, voltar a ele após u
 
 **Evite comentários:**
 
-<<<<<<< HEAD
 - Que digam "como o código funciona" e "o que faz".
 - Coloque-os apenas se for impossível tornar o código tão simples e auto-descritivo que não precise deles.
-=======
-- That tell "how code works" and "what it does".
-- Put them in only if it's impossible to make the code so simple and self-descriptive that it doesn't require them.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 Comentários também são utilizados por ferramentas de auto-documentação, como o JSDoc3: elas os lêm e geram documentos em HTML (ou documentos num outro formato).

1-js/03-code-quality/05-testing-mocha/article.md

@@ -1,8 +1,4 @@
-<<<<<<< HEAD
 # Teste automatizado com mocha
-=======
-# Automated testing with Mocha
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 Teste automatizado será utilizado nos exercícios seguintes, e também é amplamente usado em projetos reais.
 
@@ -85,11 +81,7 @@ Assim, o desenvolvimento é *iterativo*. Nós escrevemos a *spec*, a implementam
 
 Vejamos este fluxo de desenvolvimento no nosso caso prático.
 
-<<<<<<< HEAD
 O primeiro passo já está completo: nós temos uma *spec* inicial para `pow`. Agora, antes de fazer a implementação, vamos utilizar umas poucas bibliotecas (*libraries*) de JavaScript para executar os testes, apenas para ver se eles estão a funcionar (todos irão falhar).
-=======
-The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 ## A *spec* em ação
 
@@ -171,13 +163,8 @@ Aqui, nós podemos selecionar uma das duas formas para organizar o teste:
         assert.equal(pow(2, 3), 8);
       });
 
-<<<<<<< HEAD
-      it("3 elevado a 3 é 27", function() {
-        assert.equal(pow(3, 3), 27);
-=======
-      it("3 raised to power 4 is 81", function() {
+      it("3 elevado a 4 é 81", function() {
         assert.equal(pow(3, 4), 81);
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
       });
 
     });
@@ -199,11 +186,7 @@ O resultado:
 
 [iframe height=250 src="pow-2" edit border="1"]
 
-<<<<<<< HEAD
-Como nós esperávamos, o segundo teste falhou. Seguramente, a nossa função retorna sempre `8`, enquanto o `assert` espera `27`.
-=======
-As we could expect, the second test failed. Sure, our function always returns `8`, while the `assert` expects `81`.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+Como nós esperávamos, o segundo teste falhou. Seguramente, a nossa função retorna sempre `8`, enquanto o `assert` espera `81`.
 
 ## Melhorando a implementação
 

1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js

@@ -1,20 +1,12 @@
-<<<<<<< HEAD
 describe("teste", function() {
+  // Mocha, geralmente espera pelos testes por 2 segundos antes de os considerar errados
 
-  before(() => alert("Testes iniciados – antes de todos os testes"));
-  after(() => alert("Testes terminados – depois de todos os testes"));
-=======
-describe("test", function() {
-  
-   // Mocha usually waits for the tests for 2 seconds before considering them wrong
+  this.timeout(200000); // Com este código nós aumentamos esse tempo - neste caso, para 200,000 
 
-  this.timeout(200000); // With this code we increase this - in this case to 200,000 milliseconds
+  // Isto, por causa da função "alert", porque se você se demorar a pressionar o botão "OK" oos testes não irão passar!
 
-  // This is because of the "alert" function, because if you delay pressing the "OK" button the tests will not pass!
-  
-  before(() => alert("Testing started – before all tests"));
-  after(() => alert("Testing finished – after all tests"));
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+  before(() => alert("Testes iniciados – antes de todos os testes"));
+  after(() => alert("Testes terminados – depois de todos os testes"));
 
   beforeEach(() => alert("antes de um teste – entrando para um teste"));
   afterEach(() => alert("depois de um teste – saindo de um teste"));

1-js/03-code-quality/05-testing-mocha/pow-2.view/test.js

@@ -4,13 +4,8 @@ describe("pow", function() {
     assert.equal(pow(2, 3), 8);
   });
 
-<<<<<<< HEAD
-  it("3 elevado à potência 3 é 27", function() {
-    assert.equal(pow(3, 3), 27);
-=======
-  it("3 raised to power 4 is 81", function() {
+  it("3 elevado à potência 4 é 81", function() {
     assert.equal(pow(3, 4), 81);
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
   });
 
 });

1-js/05-data-types/01-primitives-methods/article.md

@@ -6,15 +6,10 @@ Eles também fornecem métodos para chamar como se fossem objetos. Estudaremos i
 
 Vejamos as principais diferenças entre primitivos e objetos.
 
-<<<<<<< HEAD
 Um primitivo
-=======
-- Is a value of a primitive type.
-- There are 7 primitive types: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` and `undefined`.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 - É um valor de um tipo primitivo.
-- Existem 6 tipos primitivos: `string`, `number`, `boolean`, `symbol`, `null` e `undefined`.
+- Existem 7 tipos primitivos: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` e `undefined`.
 
 Um objeto
 
@@ -57,11 +52,7 @@ A solução parece um pouco estranha, mas aqui está:
 
 Os "invólucros de objeto" são diferentes para cada tipo primitivo e são chamados: `String`, `Number`, `Boolean` e `Symbol`. Assim, eles fornecem diferentes conjuntos de métodos.
 
-<<<<<<< HEAD
-Por exemplo, existe um método [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) que retorna uma string em letras maiúsculas.
-=======
-For instance, there exists a string method [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) that returns a capitalized `str`.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+Por exemplo, existe um método para *strings* [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) que retorna `str` em letras maiúsculas.
 
 Veja como isso funciona:
 

1-js/06-advanced-functions/05-global-object/article.md

@@ -5,11 +5,7 @@ O objeto global fornece variáveis e funções que estão disponíveis em qualqu
 
 No navegador ele é chamado de `window`, no Node.js é `global`, em outros ambientes pode ter outro nome.
 
-<<<<<<< HEAD
-Recentemente, `globalThis` foi adicionado a linguagem como um nome padrão para o objeto global, que deve ser suportado em todos os ambientes. Em alguns navegadores, como o "non-Chromium Edge", `globalThis` ainda não é suportado, mas pode ser facilmente utilizado através de um polyfill.
-=======
-Recently, `globalThis` was added to the language, as a standardized name for a global object, that should be supported across all environments. It's supported in all major  browsers.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+Recentemente, `globalThis` foi adicionado à linguagem como um nome padrão para o objeto global, e que deve ser suportado em todos os ambientes. Ele é suportado em todos os principais navegadores.
 
 Usamos `window` aqui, assumindo que nosso ambiente seja um navegador. Se o seu script puder ser executado em outros ambientes, é melhor utilizar o `globalThis`.
 
@@ -85,14 +81,7 @@ if (!window.Promise) {
     Isso inclui objetos nativos Javascript, como `Array` e valores específicos do ambiente, como `window.innerHeight` -- a altura da janela no navegador.
 - O objeto global tem o nome universal `globalThis`.
 
-<<<<<<< HEAD
-    ...Porém é mais frequentemente referido pelos seu nomes específicos de ambientes "old-school", como `window` (navegador) e `global` (Node.js). Como `globalThis` é uma proposta recente, não é suportado pelo "non-Chromium Edge" (mas pode ser usado com um polyfill).
-- Devemos salvar valores no objeto global apenas se eles forem realmente globais em nosso projeto. E manter sua quantidade no mínimo.
-- No navegador, ao menos que estejamos usando [modules](info:modules), funções e variáveis globais declaradas com `var` tornam-se uma propriedade do objeto global.
+    ...Porém é mais frequentemente referido pelos seu nomes específicos de ambientes "old-school", como `window` (navegador) e `global` (Node.js).
+- Devemos salvar valores no objeto global apenas se eles forem realmente globais em nosso projeto. E manter a sua quantidade no mínimo.
+- No navegador, a menos que estejamos usando [modules](info:modules), funções e variáveis globais declaradas com `var` se tornam numa propriedade do objeto global.
 - Para tornar nosso código à prova de mudanças no futuro e mais fácil de entender, devemos acessar as propriedades do objeto global diretamente, como `window.x`.
-=======
-    ...But more often is referred by "old-school" environment-specific names, such as `window` (browser) and `global` (Node.js).
-- We should store values in the global object only if they're truly global for our project. And keep their number at minimum.
-- In-browser, unless we're using [modules](info:modules), global functions and variables declared with `var` become a property of the global object.
-- To make our code future-proof and easier to understand, we should access properties of the global object directly, as `window.x`.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3

1-js/06-advanced-functions/12-arrow-functions/article.md

@@ -4,11 +4,7 @@ Vamos revisitar as *arrow functions*.
 
 As *arrow functions* não são somente uma "abreviação" para escrevermos menos código.
 
-<<<<<<< HEAD
 O *JavaScript* está cheio de situações onde precisamos escrever uma pequena função que será executada em um outro lugar.
-=======
-JavaScript is full of situations where we need to write a small function that's executed somewhere else.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 Por exemplo:
 
@@ -122,18 +118,8 @@ Aqui precisamos criar as variáveis adicionais `args` e `ctx` para que a funçã
 
 *Arrow functions* (funções seta):
 
-<<<<<<< HEAD
-- Não possuem `this`.
 - Não possuem `arguments`.
 - Não podem ser chamadas com `new`.
 - (Elas também não possuem `super`, mas ainda não a estudamos. Veremos no capítulo <info:class-inheritance>).
 
 Isso porque elas são feitas para pequenos trechos de código que não possuem seus próprios "contextos", mas sim utilizam o contexto em que estão inseridas. E elas realmente brilham nesses casos.
-=======
-- Do not have `this`
-- Do not have `arguments`
-- Can't be called with `new`
-- They also don't have `super`, but we didn't study it yet. We will on the chapter <info:class-inheritance>
-
-That's because they are meant for short pieces of code that do not have their own "context", but rather work in the current one. And they really shine in that use case.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3