From 54d1b87e66367aeae81c56bfe21a01fa906294db Mon Sep 17 00:00:00 2001
From: "diken.dev" <diken.dev@gmail.com>
Date: Wed, 1 Feb 2023 01:31:47 -0300
Subject: [PATCH] Portuguese translation Day 2

---
 .../02_Day_Data_types/02_day_data_types.md    | 344 +++++++++---------
 1 file changed, 172 insertions(+), 172 deletions(-)

diff --git a/Portuguese/02_Day_Data_types/02_day_data_types.md b/Portuguese/02_Day_Data_types/02_day_data_types.md
index bb6828e0..e9362a52 100644
--- a/Portuguese/02_Day_Data_types/02_day_data_types.md
+++ b/Portuguese/02_Day_Data_types/02_day_data_types.md
@@ -29,15 +29,15 @@
 	- [Strings](#strings)
 		- [String Concatenação](#string-concatenação)
 			- [Concatenando Usando o Operador de Adição](#concatenando-usando-o-operador-de-adição)
-			- [Escape Sequences in Strings](#escape-sequences-in-strings)
-			- [Template Literals (Template Strings)](#template-literals-template-strings)
+			- [Escape Sequences em Strings](#escape-sequences-em-strings)
+			- [Strings Literais (Template Strings)](#Strings-Literais-template-strings)
 		- [String Methods](#string-methods)
-	- [Checking Data Types and Casting](#checking-data-types-and-casting)
-		- [Checking Data Types](#checking-data-types)
-		- [Changing Data Type (Casting)](#changing-data-type-casting)
-			- [String to Int](#string-to-int)
-			- [String to Float](#string-to-float)
-			- [Float to Int](#float-to-int)
+	- [Verificando Tipos de Dados e Casting](#verificando-tipos-de-dados-e-casting)
+		- [Verificando Tipos de Dados](#verificando-tipos-de-dados)
+		- [Mudando Tipo de Dado (Casting)](#mudando-tipo-de-dado-casting)
+			- [String para Int](#string-para-int)
+			- [String para Float](#string-para-float)
+			- [Float para Int](#float-para-int)
 	- [💻 Dia 2: Exercícios](#-dia-2-exercícios)
 		- [Exercícios: Level 1](#exercícios-level-1)
 		- [Exercícios: Level 2](#exercícios-level-2)
@@ -47,29 +47,29 @@
 
 ## Tipos de Dados
 
-Na sessão anterior, nós mencionamos um pouco sobre tipos de dados. Tipos de dados decrevem as caracteristicas do dado, e podem ser divididos em duas categorias:
+Na sessão anterior, nós mencionamos um pouco sobre tipos de dados. Tipos de dados decrevem as caracteristicas dos dados, e podem ser divididos em duas categorias:
 
-1. Tipos de dados primitivos
-2. Tipos de dados não primitivos(de referência do objeto.)
+  1. Tipos de dados primitivos
+  2. Tipos de dados não primitivos (de referência do objeto.)
 
 ### Tipos de Dados Primitivos
 
 Tipos de dados primitivos em JavaScript inclui:
 
- 1. Numbers - Inteiros, floats
- 2. Strings - Qualquer dado entre aspas simples, aspas duplas e crase
- 3. Booleans - valores verdadeiros e falsos
- 4. Null - valor vazio ou sem valor
- 5. Undefined - variável declarada sem um valor
- 6. Symbol - Um valor único que pode ser gerado por um construtor de símbolo
+  1. Numbers - Inteiros, floats
+  2. Strings - Qualquer dado entre aspas simples, aspas duplas e crase
+  3. Booleans - valores verdadeiros e falsos
+  4. Null - valor vazio ou sem valor
+  5. Undefined - variável declarada sem um valor
+  6. Symbol - Um valor único que pode ser gerado por um construtor de símbolo
 
 Tipos de dados não primitivos em JavaScriot inclui:
 
- 1. Objetos
- 2. Arrays
+  1. Objetos
+  2. Arrays
 
 Agora, vamos ver exatamente oque significa tipos de dados primitivos e não primitivos.
-*Primitivo* são tipos de dados imutáveis(nao-modificável). Uma vez criado um tipo de dado primitivo nós não podemos mais modifica-lo.
+*Primitivo* são tipos de dados imutáveis(não-modificável). Uma vez criado um tipo de dado primitivo nós não podemos mais modificá-lo.
 
 **Exemplo:**
 
@@ -77,7 +77,7 @@ Agora, vamos ver exatamente oque significa tipos de dados primitivos e não prim
 let word = 'JavaScript'
 ```
 
-Se nós tentarmos modificar uma string armazenada na variável *word, JavaScrip irá mostar um error. Qualquer dados entre aspas simples, aspas duplas, ou crase é um string do tipo dado.
+Se nós tentarmos modificar uma string armazenada na variável *word*, o JavaScript irá mostar um error. Qualquer dado entre aspas simples, aspas duplas, ou crase é um string.
 
 ```js
 word[0] = 'Y'
@@ -87,41 +87,41 @@ Esta expressão não muda a string armazenada na variável *word*. Então, podem
 Tipos de dados primitivos são comparados pelo seu valor. Vamos comparar valores de dados diferentes. Veja o exemplo abaixo:
 
 ```js
-let numOne = 3
-let numTwo = 3
+let numeroUm = 3
+let numeroDois = 3
 
-console.log(numOne == numTwo)      // true
+console.log(numeroUm == numeroDois)      // verdadeiro
 
 let js = 'JavaScript'
 let py = 'Python'
 
-console.log(js == py)             //false 
+console.log(js == py)             // falso 
 
-let lightOn = true
-let lightOff = false
+let LuzLigar = true
+let lightApagar = false
 
-console.log(lightOn == lightOff) // false
+console.log(LuzLigar == lightApagar) // falso
 ```
 
 ### Tipos de Dados Não Primitivos
 
 *não primitivos* são tipos de dados modificáveis ou mutáveis. Nós podemos modificar o valor de um dado tipo não primitivo depois de criado.
-Vamos ver isso criando um array. Um array é uma lista de valores de dados entre colchetes. Arrays que contém o mesmo ou diferente tipos de dados. Valores de Arrays são referenciados pelo seu index. Em JavaScript o index do array começa em zero. em outras palavras, o primeiro elemento de um array é encontrado no index zero, o segundo elemento no index um, e no terceiro elemento no index dois, etc.
+Vamos ver isso criando um array, um array é uma lista de valores de dados entre colchetes. Arrays que contém o mesmo ou diferentes tipos de dados. Valores de Arrays são referenciados pelo seu index. Em JavaScript o index do array começa em zero, em outras palavras o primeiro elemento de um array é encontrado no index zero, o segundo elemento no index um, e o terceiro elemento no index dois, etc.
 
 ```js
-let nums = [1, 2, 3]
-nums[0] = 1
+let numeros = [1, 2, 3]
+numeros[0] = 1
 
-console.log(nums)  // [1, 2, 3]
+console.log(numeros)  // [1, 2, 3]
 ```
 
-Como você pode ver, um array, que é um tipo de dado não primitivo é mutável. Tipos de dados não primitivos não podem ser comparador pelos seus valores. Mesmo se dois tipos de dados não primitivos tem as mesmas propriedades e valores, eles não podem ser estritamentes iguais.
+Como você pode ver, um array é um tipo de dado não primitivo e mutável. Tipos de dados não primitivos não podem ser comparador pelos seus valores. Mesmo se dois tipos de dados não primitivos tem as mesmas propriedades e valores, eles não podem ser estritamentes iguais.
 
 ```js
 let nums = [1, 2, 3]
 let numbers = [1, 2, 3]
 
-console.log(nums == numbers)  // false
+console.log(nums == numbers)  // falso
 
 let userOne = {
 name:'Asabeneh',
@@ -135,7 +135,7 @@ role:'teaching',
 country:'Finland'
 }
 
-console.log(userOne == userTwo) // false
+console.log(userOne == userTwo) // falso
 ```
 
 Regra de ouro, nós não comparamos tipos de dados não primitivos. Não se compara arrays, funções, ou objetos. Porque eles são comparados pela sua referência ao invez do valor. Dois objetos só são estritamentes iguais se a sua referência for o mesmo objeto subjacente.
@@ -144,7 +144,7 @@ Regra de ouro, nós não comparamos tipos de dados não primitivos. Não se comp
 let nums = [1, 2, 3]
 let numbers = nums
 
-console.log(nums == numbers)  // true
+console.log(nums == numbers)  // verdadeiro
 
 let userOne = {
 name:'Asabeneh',
@@ -154,10 +154,10 @@ country:'Finland'
 
 let userTwo = userOne
 
-console.log(userOne == userTwo)  // true
+console.log(userOne == userTwo)  // verdadeiro
 ```
 
-Com dificuldade de entender a diferença entre tipos de dados primitivos e  tipos de dados não primitivos, você não é o único. Calma e apenas vá para a próxima sessão e tente voltar aqui depois de algum tempo. Agora vamos começar com tipos de dados do tipo número.
+Com dificuldade de entender a diferença entre tipos de dados primitivos e tipos de dados não primitivos, você não é o único. Calma e apenas vá para a próxima sessão e tente voltar aqui depois de algum tempo. Agora vamos começar com tipos de dados do tipo número.
 
 ## Números
 
@@ -167,19 +167,19 @@ Vamos ver alguns exemplos de Números.
 ### Declarando Tipos de Dados Numéricos
 
 ```js
-let age = 35
-const gravity = 9.81  // nós usamos const para valores que não mudam, constante gravitacional em m/s2
-let mass = 72         // massa em Kilogramas
+let idade = 35
+const gravidade = 9.81  // nós usamos const para valores que não mudam, constante gravitacional em m/s2
+let massa = 72         // massa em Kilogramas
 const PI = 3.14       // pi constante geométrica
 
 // Mais exemplos
-const boilingPoint = 100 // temperatura em oC, ponto de ebulução da água que é uma constante
-const bodyTemp = 37      // oC média da temperatura corporal humana, que é uma constante
+const pontoEbulição = 100 // temperatura em oC, ponto de ebulução da água que é uma constante
+const temperaturaCorpo = 37      // oC média da temperatura corporal humana, que é uma constante
 
-console.log(age, gravity, mass, PI, boilingPoint, bodyTemp)
+console.log(idade, gravidade, massa, PI, pontoEbulição, temperaturaCorpo)
 ```
 
-### Math Objeto
+### Math Object
 
 Em JavaScript o Math Object promove muitos métodos para trabalhar com números.
 
@@ -241,7 +241,7 @@ Math.cos(0)
 Math.cos(60)
 ```
 
-#### Gerador de Número Aleatório
+#### Gerador de Números Aleatórios
 
 O objeto Math do JavaScript tem o método random() que gera números de 0 ate 0.999999999...
 
@@ -263,19 +263,19 @@ console.log(randomNumRoundToFloor)    // este retorna entre 0 e 10
 
 ## Strings
 
-Strings são textos, que estão entre **_single_**, **_double_**, **_back-tick_**. Para declarar uma string, nós precisamos de um nome de variável, operador de atribuição, um valor entre aspas simples, aspas duplas, ou crase.
+Strings são textos, que estão entre **_simples_**, **_duplas_**, **_crase_**. Para declarar uma string, nós precisamos de um nome de variável, operador de atribuição, um valor entre aspas simples, aspas duplas, ou crase.
 Vamos ver alguns exemplos de string:
 
 ```js
-let space = ' '           // um valor de string vazia
-let firstName = 'Asabeneh'
-let lastName = 'Yetayeh'
-let country = 'Finland'
-let city = 'Helsinki'
-let language = 'JavaScript'
-let job = 'teacher'
-let quote = "The saying,'Seeing is Believing' is not correct in 2020."
-let quotWithBackTick = `The saying,'Seeing is Believing' is not correct in 2020.`
+let espaço = ' '           // um valor de string vazia
+let primeiroNone = 'Asabeneh'
+let ultimoNome = 'Yetayeh'
+let país = 'Finland'
+let cidade = 'Helsinki'
+let linguagem = 'JavaScript'
+let profissão = 'teacher'
+let citação = "The saying,'Seeing is Believing' is not correct in 2020."
+let citaçãoUsandoCrase = `The saying,'Seeing is Believing' is not correct in 2020.`
 ```
 
 ### String Concatenação
@@ -284,8 +284,8 @@ Conectando duas ou mais strings juntas é chamado de concatenação.
 Usando as strings declaradas na sessão anterior de strings: 
 
 ```js
-let fullName = firstName + space + lastName; // concatenação, combinar duas ou mais strings juntas.
-console.log(fullName);
+let nomeCompleto = primeiroNone + espaço + ultimoNome; // concatenação, combinar duas ou mais strings juntas.
+console.log(nomeCompleto);
 ```
 
 ```sh
@@ -296,35 +296,35 @@ Nós podemos concatenar strings de jeitos diferentes.
 
 #### Concatenando Usando o Operador de Adição
 
-Concatenando usando o operador de adição é o modo antigo. Este tipo de concatenação é tedioso e propenso a erros. E é muito bom sabe como concatenar deste modo, mas eu sugiro fortemente que use o template ES6 de strings (explicado mais adiante). 
+Concatenando usando o operador de adição é o modo antigo de fazer. Este tipo de concatenação é tedioso e propenso a erros. E é muito bom sabe como concatenar deste modo, mas eu sugiro fortemente que use o template ES6 de strings (explicado mais adiante). 
 
 ```js
 // Declarando diferentes variáveis de diferentes tipos de dados
-let space = ' '
-let firstName = 'Asabeneh'
-let lastName = 'Yetayeh'
-let country = 'Finland'
-let city = 'Helsinki'
-let language = 'JavaScript'
-let job = 'teacher'
-let age = 250
+let espaço = ' '
+let primeiroNome = 'Asabeneh'
+let ultimoNome = 'Yetayeh'
+let país = 'Finland'
+let cidade = 'Helsinki'
+let linguagem = 'JavaScript'
+let profissão = 'teacher'
+let idade = 250
 
-let fullName = firstName + space + lastName
-let personInfoOne = fullName + '. I am ' + age + '. I live in ' + country; // ES5 adição de string
+let nomeCompleto = primeiroNome + espaço + ultimoNome
+let pessoaUmInfo = nomeCompleto + '. I am ' + idade + '. I live in ' + país; // ES5 adição de string
 
-console.log(personInfoOne)
+console.log(pessoaUmInfo)
 ```
 
 ```sh
 Asabeneh Yetayeh. I am 250. I live in Finland
 ```
-### Long Literal Strings
+### Strings Literais Longas
 
-Uma string pode ser apenas um caractere, paragrafo ou uma página. Se o tamanho da string é muito que a linha. Nós podemos usar o caractere barras invertidas (\\) no final de cada linha para indicar que aquela string irá continuar na próxima linha. 
+Uma string pode ser apenas um caractere, paragrafo ou uma página. Se o tamanho da string é maior que a linha. Nós podemos usar o caractere barras invertidas (\\) no final de cada linha para indicar que aquela string irá continuar na próxima linha. 
 **Exemplo**
 
 ```js
-const paragraph = "My name is Asabeneh Yetayeh. I live in Finland, Helsinki.\
+const paragrafo = "My name is Asabeneh Yetayeh. I live in Finland, Helsinki.\
 I am a teacher and I love teaching. I teach HTML, CSS, JavaScript, React, Redux, \
 Node.js, Python, Data Analysis and D3.js for anyone who is interested to learn. \
 In the end of 2019, I was thinking to expand my teaching and to reach \
@@ -333,12 +333,12 @@ It was one of the most rewarding and inspiring experience.\
 Now, we are in 2020. I am enjoying preparing the 30DaysOfJavaScript challenge and \
 I hope you are enjoying too."
 
-console.log(paragraph)
+console.log(paragrafo)
 ```
 
-#### Escape Sequences in Strings
+#### Escape Sequences em Strings
 
-Em JavaScript e outras linguagens de programação \ seguido de alguns caracteres é um escape sequence. Vamos ver os mais usados:
+Em JavaScript e outras linguagens de programação \ seguido de alguns caracteres, é um escape sequence. Vamos ver os mais usados:
 
 - \n: Nova linha
 - \t: Tab, significa 8 espaços
@@ -375,20 +375,20 @@ In every programming language it starts with 'Hello, World!'
 The saying 'Seeing is Believing' isn't correct in 2020
 ```
 
-#### Template Literals (Template Strings)
+#### Strings Literais (Template Strings)
 
 Para criar Strings Literais , nós usamos crases. Nós podemos injetar dados como expressões para criar String Literais, usando na expressão parentesis ({}) precedido de um sinal de dollar $. Veja a sintaxe abaixo.
 
 ```js
 //Sintaxe
 `String literal text`
-`String literal text ${expression}`
+`String literal text ${expressão}`
 ```
 
 **Exemplo: 1**
 
 ```js
-console.log(`The sum of 2 and 3 is 5`) // escrevendo dados estaticos
+console.log(`The sum of 2 and 3 is 5`) // escrevendo dados estáticos
 let a = 2
 let b = 3
 console.log(`The sum of ${a} and ${b} is ${a + b}`) // injetando dados dinamicamente
@@ -397,19 +397,19 @@ console.log(`The sum of ${a} and ${b} is ${a + b}`) // injetando dados dinamicam
 **Exemplo:2**
 
 ```js
-let firstName = 'Asabeneh'
-let lastName = 'Yetayeh'
-let country = 'Finland'
-let city = 'Helsinki'
-let language = 'JavaScript'
-let job = 'teacher'
-let age = 250
-let fullName = firstName + ' ' + lastName
+let primeiroNome = 'Asabeneh'
+let ultimoNome = 'Yetayeh'
+let país = 'Finland'
+let cidade = 'Helsinki'
+let linguagem = 'JavaScript'
+let profissão = 'teacher'
+let idade = 250
+let nomeCompleto = primeiroNome + ' ' + ultimoNome
 
-let personInfoTwo = `I am ${fullName}. I am ${age}. I live in ${country}.` //ES6 - Método de interpolação de String
-let personInfoThree = `I am ${fullName}. I live in ${city}, ${country}. I am a ${job}. I teach ${language}.`
-console.log(personInfoTwo)
-console.log(personInfoThree)
+let pessoaInfoUm = `I am ${nomeCompleto}. I am ${idade}. I live in ${país}.` //ES6 - Método de interpolação de String
+let pesoaInfoDois = `I am ${nomeCompleto}. I live in ${cidade}, ${país}. I am a ${profissão}. I teach ${linguagem}.`
+console.log(pessoaInfoUm)
+console.log(pesoaInfoDois)
 ```
 
 ```sh
@@ -429,9 +429,9 @@ console.log(`${a} é maior que ${b}: ${a > b}`)
 2 é maior que 3: false
 ```
 
-### String Methods
+### String Métodos
 
-Tudo em JavaScript é um objeto. String é um tipo de dado primitivo, que significa que não podemos modificar-la uma vez criada. Um objeto String pode ter vários métodos. Existe diferentes métodos para strings que pode nos ajudar. 
+Tudo em JavaScript é um objeto. String é um tipo de dado primitivo, que significa que não podemos modificá-la uma vez criada. Um objeto String pode ter vários métodos. Existe diferentes métodos para strings que pode nos ajudar. 
 
 1. *length*: O  método *length* retorna o número de caracteres em uma string incluindo espaços vázios.
 
@@ -440,32 +440,32 @@ Tudo em JavaScript é um objeto. String é um tipo de dado primitivo, que signif
 ```js
 let js = 'JavaScript'
 console.log(js.length)         // 10
-let firstName = 'Asabeneh'
-console.log(firstName.length)  // 8
+let primeiroNome = 'Asabeneh'
+console.log(primeiroNome.length)  // 8
 ```
 
-2. *Accessing characters in a string*: Nós podemos acessar cada caractere em uma string usando seu index. Em programação, contagem começa em 0. O primeiro index de uma string é zero, e o último index é o length de uma string - 1.
+2. *Acessando caracteres em uma string*: Nós podemos acessar cada caractere em uma string usando seu index. Em programação, a contagem começa em 0. O primeiro index de uma string é zero, e o último index é o length de uma string - 1.
   
-  ![Accessing sting by index](../images/string_indexes.png)
+  ![Accessing string by index](../images/string_indexes.png)
 
-Vamos cessar diferentes caracteres em 'JavaScript' string.
+Vamos acessar diferentes caracteres em 'JavaScript' string.
 
 ```js
 let string = 'JavaScript'
-let firstLetter = string[0]
+let primeiraLetra = string[0]
 
-console.log(firstLetter)           // J
+console.log(primeiraLetra)           // J
 
-let secondLetter = string[1]       // a
-let thirdLetter = string[2]
-let lastLetter = string[9]
+let segundaLetra = string[1]       // a
+let terceiraLetra = string[2]
+let ultimaLetra = string[9]
 
-console.log(lastLetter)            // t
+console.log(ultimaLetra)            // t
 
-let lastIndex = string.length - 1
+let ultimoIndex = string.length - 1
 
-console.log(lastIndex)  // 9
-console.log(string[lastIndex])    // t
+console.log(ultimoIndex)  // 9
+console.log(string[ultimoIndex])    // t
 ```
 
 3. *toUpperCase()*: Este método muda a string para letras maiúsculas.
@@ -475,13 +475,13 @@ let string = 'JavaScript'
 
 console.log(string.toUpperCase())     // JAVASCRIPT
 
-let firstName = 'Asabeneh'
+let primeiroNome = 'Asabeneh'
 
-console.log(firstName.toUpperCase())  // ASABENEH
+console.log(primeiroNome.toUpperCase())  // ASABENEH
 
-let country = 'Finland'
+let país = 'Finland'
 
-console.log(country.toUpperCase())    // FINLAND
+console.log(país.toUpperCase())    // FINLAND
 ```
 
 4. *toLowerCase()*: Este método muda a string para letras minúsculas.
@@ -491,13 +491,13 @@ let string = 'JavasCript'
 
 console.log(string.toLowerCase())     // javascript
 
-let firstName = 'Asabeneh'
+let primeiroNome = 'Asabeneh'
 
-console.log(firstName.toLowerCase())  // asabeneh
+console.log(primeiroNome.toLowerCase())  // asabeneh
 
-let country = 'Finland'
+let pais = 'Finland'
 
-console.log(country.toLowerCase())   // finland
+console.log(pais.toLowerCase())   // finland
 ```
 
 5. *substr()*: usando dois argumentos, o index de onde irá começar e o número de caracteres para retirar da string.
@@ -506,8 +506,8 @@ console.log(country.toLowerCase())   // finland
 let string = 'JavaScript'
 console.log(string.substr(4,6))    // Script
 
-let country = 'Finland'
-console.log(country.substr(3, 4))   // land
+let país = 'Finland'
+console.log(país.substr(3, 4))   // land
 ```
 
 6. *substring()*: Usando dois argumentos, o index de onde irá começar e o index para parar, mas esse não inclui o caractere no index de parada.
@@ -519,11 +519,11 @@ console.log(string.substring(0,4))     // Java
 console.log(string.substring(4,10))    // Script
 console.log(string.substring(4))       // Script
 
-let country = 'Finland'
+let país = 'Finland'
 
-console.log(country.substring(0, 3))   // Fin
-console.log(country.substring(3, 7))   // land
-console.log(country.substring(3))      // land
+console.log(país.substring(0, 3))   // Fin
+console.log(país.substring(3, 7))   // land
+console.log(país.substring(3))      // land
 ```
 
 7. *split()*: O método split divide uma string em um lugar especifico e converte em um array.
@@ -534,15 +534,15 @@ let string = '30 Days Of JavaScript'
 console.log(string.split())     // muda para um array -> ["30 Days Of JavaScript"]
 console.log(string.split(' '))  // separa em um array com espaço -> ["30", "Days", "Of", "JavaScript"]
 
-let firstName = 'Asabeneh'
+let primeiroNome = 'Asabeneh'
 
-console.log(firstName.split())    // muda para um array - > ["Asabeneh"]
-console.log(firstName.split(''))  // separa em um array cada letra ->  ["A", "s", "a", "b", "e", "n", "e", "h"]
+console.log(primeiroNome.split())    // muda para um array - > ["Asabeneh"]
+console.log(primeiroNome.split(''))  // separa em um array cada letra ->  ["A", "s", "a", "b", "e", "n", "e", "h"]
 
-let countries = 'Finland, Sweden, Norway, Denmark, and Iceland'
+let país = 'Finland, Sweden, Norway, Denmark, and Iceland'
 
-console.log(countries.split(','))  // separa para um array com vírgula -> ["Finland", " Sweden", " Norway", " Denmark", " and Iceland"]
-console.log(countries.split(', ')) //  ["Finland", "Sweden", "Norway", "Denmark", "and Iceland"]
+console.log(país.split(','))  // separa para um array com vírgula -> ["Finland", " Sweden", " Norway", " Denmark", " and Iceland"]
+console.log(país.split(', ')) //  ["Finland", "Sweden", "Norway", "Denmark", "and Iceland"]
 ```
 
 8. *trim()*: Remove espaços adicionais no início ou no final de uma string.
@@ -553,10 +553,10 @@ let string = '   30 Days Of JavaScript   '
 console.log(string)
 console.log(string.trim(' '))
 
-let firstName = ' Asabeneh '
+let primeiroNome = ' Asabeneh '
 
-console.log(firstName)
-console.log(firstName.trim())  // ainda remove espaços no início e no fim da string
+console.log(primeiroNome)
+console.log(primeiroNome.trim())  // ainda remove espaços no início e no fim da string
 ```
 
 ```sh
@@ -578,12 +578,12 @@ console.log(string.includes('script'))   // false
 console.log(string.includes('java'))     // false
 console.log(string.includes('Java'))     // true
 
-let country = 'Finland'
+let país = 'Finland'
 
-console.log(country.includes('fin'))     // false
-console.log(country.includes('Fin'))     // true
-console.log(country.includes('land'))    // true
-console.log(country.includes('Land'))    // false
+console.log(país.includes('fin'))     // false
+console.log(país.includes('Fin'))     // true
+console.log(país.includes('land'))    // true
+console.log(país.includes('Land'))    // false
 ```
 
 10. *replace()*: Usando como parâmetro a antiga substring para uma nova substring.
@@ -596,8 +596,8 @@ string.replace(antigaSubstring, novaSubstring)
 let string = '30 Days Of JavaScript'
 console.log(string.replace('JavaScript', 'Python')) // 30 Days Of Python
 
-let country = 'Finland'
-console.log(country.replace('Fin', 'Noman'))       // Nomanland
+let país = 'Finland'
+console.log(país.replace('Fin', 'Noman'))       // Nomanland
 ```
 11. *charAt()*: Usando um index e retorna o valor no index selecionado;
 
@@ -609,8 +609,8 @@ string.charAt(index)
 let string = '30 Days Of JavaScript'
 console.log(string.charAt(0))        // 3
 
-let lastIndex = string.length - 1
-console.log(string.charAt(lastIndex)) // t
+let ultimoIndex = string.length - 1
+console.log(string.charAt(ultimoIndex)) // t
 ```
 
 12. *charCodeAt()*: Usando um index e retorna o código de caractere (número ASCII) do valor nesse index.
@@ -623,8 +623,8 @@ string.charCodeAt(index)
 let string = '30 Days Of JavaScript'
 console.log(string.charCodeAt(3))        // D ASCII número é 68
 
-let lastIndex = string.length - 1
-console.log(string.charCodeAt(lastIndex)) // t ASCII é 116
+let ultimoIndex = string.length - 1
+console.log(string.charCodeAt(ultimoIndex)) // t ASCII é 116
 
 ```
 13.  *indexOf()*: Usando uma substring e o mesmo existe em uma string retorna a primeira posição da substring, se não existe retornará -1
@@ -708,11 +708,11 @@ console.log(string.endsWith('world'))         // true
 console.log(string.endsWith('love'))          // false
 console.log(string.endsWith('in the world')) // true
 
-let country = 'Finland'
+let país = 'Finland'
 
-console.log(country.endsWith('land'))         // true
-console.log(country.endsWith('fin'))          // false
-console.log(country.endsWith('Fin'))          //  false
+console.log(país.endsWith('land'))         // true
+console.log(país.endsWith('fin'))          // false
+console.log(país.endsWith('Fin'))          //  false
 ```
 
 18. *search*: Usando uma substring como um argumento e retorna o index do primeiro resultado. O valor da pesquisa pode ser uma string ou uma expressão regular.
@@ -770,7 +770,7 @@ console.log(txt.match(regEx))  // ["2", "0", "1", "9", "3", "0", "2", "0", "2",
 console.log(txt.match(/\d+/g)) // ["2019", "30", "2020"]
 ```
 
-20. *repeat()*: it takes a number as argument and it returns the repeated version of the string.
+20. *repeat()*: Um número como argumento e retorna uma versão repetida de uma string.
 
 ```js
 string.repeat(n)
@@ -781,43 +781,43 @@ let string = 'love'
 console.log(string.repeat(10)) // lovelovelovelovelovelovelovelovelovelove
 ```
 
-## Checking Data Types and Casting
+## Verificando Tipos de Dados e Casting
 
-### Checking Data Types
+### Verificando Tipos de Dados
 
-Para verificar o tipo de uma variável nós usamos o método _typeof_.
+Para verificar o tipo de uma variável nós usamos o método _typeOf_.
 
 **Exemplo:**
 
 ```js
-// Different javascript data types
-// Let's declare different data types
+// Diferente tipos de dados javascript
+// vamos declarar diferentes tipos de dados
 
-let firstName = 'Asabeneh'      // string
-let lastName = 'Yetayeh'        // string
-let country = 'Finland'         // string
-let city = 'Helsinki'           // string
-let age = 250                   // número, não é minha idade real, não se preocupe com isso
-let job                         // undefined, porque o valor não foi definido.
+let primeiroNome = 'Asabeneh'     // string
+let ultimoNome = 'Yetayeh'        // string
+let país = 'Finland'              // string
+let cidade = 'Helsinki'           // string
+let idade = 250                   // número, não é minha idade real, não se preocupe com isso
+let profissão                     // undefined, porque o valor não foi definido.
 
-console.log(typeof 'Asabeneh')  // string
-console.log(typeof firstName)   // string
-console.log(typeof 10)          // number
-console.log(typeof 3.14)        // number
-console.log(typeof true)        // boolean
-console.log(typeof false)       // boolean
-console.log(typeof NaN)         // number
-console.log(typeof job)         // undefined
-console.log(typeof undefined)   // undefined
-console.log(typeof null)        // object
+console.log(typeof 'Asabeneh')    // string
+console.log(typeof primeiroNome)  // string
+console.log(typeof 10)            // number
+console.log(typeof 3.14)          // number
+console.log(typeof true)          // boolean
+console.log(typeof false)         // boolean
+console.log(typeof NaN)           // number
+console.log(typeof profissão)     // undefined
+console.log(typeof undefined)     // undefined
+console.log(typeof null)          // object
 ```
 
-### Changing Data Type (Casting)
+### Mudando Tipo de Dado (Casting)
 
 - Casting: Convertendo um tipo de dados para outro. Usamos _parseInt()_, _parseFloat()_, _Number()_, _+ sign_ +, _str()_
   Quando fazemos operações aritméticas, os números em forma de string devem ser primeiro convertidos em inteiros ou floats, caso contrário, ocorre um erro.
 
-#### String to Int
+#### String para Int
 
 Podemos converter números em forma de string para um número. Qualquer número dentro de aspas é um número em forma de string. Um exemplo de número em forma de string: '10', '5', etc.
 Podemos converter uma string para um número usando os seguintes métodos:
@@ -846,7 +846,7 @@ let numInt = +num
 console.log(numInt) // 10
 ```
 
-#### String to Float
+#### String para Float
 
 Nós podemos converter uma string float número para um número float. Qualquer número float entre aspas é uma string float número. Exemplo:
 '9.81', '3.14', '1.44', etc.
@@ -877,7 +877,7 @@ let numFloat = +num
 console.log(numFloat) // 9.81
 ```
 
-#### Float to Int
+#### Float para Int
 
 Podemos converter float números para inteiro.
 Vamos usar o seguinte método para converter float para int.
@@ -960,7 +960,7 @@ console.log(numInt) // 9
 
 2. Use __match()__ para contar os números de todos os __because__ na seguinte frase: __'You cannot end a sentence with because because because is a conjunction'__.  
 
-3. Limpar o seguinte texto e encontrar a palavra mais repetida(dica, use replace e expressões regulares)
+3. Limpar o seguinte texto e encontrar a palavra mais repetida (dica, use replace e expressões regulares)
   ```js
     const sentence = " %I $am@% a %tea@cher%, &and& I lo%#ve %te@a@ching%;. The@re $is no@th@ing; &as& mo@re rewarding as educa@ting &and& @emp%o@weri@ng peo@ple. ;I found tea@ching m%o@re interesting tha@n any ot#her %jo@bs. %Do@es thi%s mo@tiv#ate yo@u to be a tea@cher!? %Th#is 30#Days&OfJavaScript &is al@so $the $resu@lt of &love& of tea&ching "
   ```