func`string`. The function `func` is called automatically, receives the string and embedded expressions and can process them. This feature is called "tagged templates", it's rarely seen, but you can read about it in the MDN: [Template literals](mdn:/JavaScript/Reference/Template_literals#Tagged_templates).
+Crases também nos permite especificar uma "template function" antes da primeira crase. A sintaxe é: func`string`. A função `func` é chamada automaticamente, recebe a string e as expressões incorporadas e pode as processar. Esse recurso é chamado de "tagged templates", raramente visto, mas você pode ler mais sobre em MDN: [Template literals](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals).
-## Special characters
+## Caracteres especiais
-It is still possible to create multiline strings with single and double quotes by using a so-called "newline character", written as `\n`, which denotes a line break:
+Ainda é possível criar strings em múltiplas linhas com aspas simples e duplas apenas usando o chamado "caractere de nova linha", escrito como `\n`, que representa uma quebra de linha:
```js run
let guestList = "Guests:\n * John\n * Pete\n * Mary";
-alert(guestList); // a multiline list of guests, same as above
+alert(guestList); // uma lista de convidados em múltiplas linhas, como acima
```
-As a simpler example, these two lines are equal, just written differently:
+Como um exemplo simplório, estas duas linhas são iguais, apenas escritas diferentemente:
```js run
-let str1 = "Hello\nWorld"; // two lines using a "newline symbol"
+let str1 = "Hello\nWorld"; // duas linhas usando um "caractere de nova linha"
-// two lines using a normal newline and backticks
+// duas linhas usando uma nova linha normalmente e crases
let str2 = `Hello
World`;
alert(str1 == str2); // true
```
-There are other, less common special characters:
+Existem outros, menos comuns, caracteres especiais:
-| Character | Description |
+| Caractere | Descrição |
|-----------|-------------|
-|`\n`|New line|
-|`\r`|In Windows text files a combination of two characters `\r\n` represents a new break, while on non-Windows OS it's just `\n`. That's for historical reasons, most Windows software also understands `\n`. |
-|`\'`, `\"`, \\`|Quotes|
-|`\\`|Backslash|
+|`\n`|Nova linha|
+|`\r`|Nos arquivos de texto do Windows uma combinação de dois caracteres `\r\n` representam uma nova quebra, enquanto em SOs não Windows é apenas `\n`. Isso se dá por razões históricas, a maioria dos programas no Windows também compreendem `\n`. |
+|`\'`, `\"`, \\`| Aspas |
+|`\\`|Barra invertida|
|`\t`|Tab|
-|`\b`, `\f`, `\v`| Backspace, Form Feed, Vertical Tab -- mentioned for completeness, coming from old times, not used nowadays (you can forget them right now). |
+|`\b`, `\f`, `\v`| Backspace, Quebra de página(Form Feed) e Barra vertical -- Mencionados para fins de completude, advindos de tempos antigos, não utilizadas atualmente (pode esquecê-los nesse momento) |
-As you can see, all special characters start with a backslash character `\`. It is also called an "escape character".
+Como você pode ver, todos os caracteres especiais começam com o caractere de barra invertida. Também chamado de "caractere de escape".
-Because it's so special, if we need to show an actual backslash `\` within the string, we need to double it:
+Por ser tão especial, se precisarmos mostrar uma barra invertida real `\` dentro da string, precisamos duplicá-la:
```js run
-alert( `The backslash: \\` ); // The backslash: \
+alert( `The backslash: \\` ); // A barra invertida: \
```
-So-called "escaped" quotes `\'`, `\"`, \\` are used to insert a quote into the same-quoted string.
+As chamadas aspas "escapadas" `\'`, `\"`, \\` são usadas para adicionar aspas do mesmo tipo da utilizada na delimitação da string.
-For instance:
+Por exemplo:
```js run
alert( 'I*!*\'*/!*m the Walrus!' ); // *!*I'm*/!* the Walrus!
```
-As you can see, we have to prepend the inner quote by the backslash `\'`, because otherwise it would indicate the string end.
+Como você pode ver, temos que adicionar a barra invertida `\'` antes da aspa interna, caso contrário ela indicaria o fim da string.
-Of course, only the quotes that are the same as the enclosing ones need to be escaped. So, as a more elegant solution, we could switch to double quotes or backticks instead:
+Claro, apenas as aspas do mesmo tipo utilizadas como delimitador precisam ser "escapadas". Então, como uma solução mais elegante, podemos trocar por aspas duplas ou crases
```js run
alert( "I'm the Walrus!" ); // I'm the Walrus!
```
-Besides these special characters, there's also a special notation for Unicode codes `\u…`, it's rarely used and is covered in the optional chapter about [Unicode](info:unicode).
+Apesar desses caracteres especiais, também há uma notação especial para códigos Unicode `\u…`, é raramente utilizada e é abordada no capítulo opcional sobre [Unicode](info:unicode).
-## String length
+## comprimento de string
-The `length` property has the string length:
+A propriedade `length` contém o tamanho da string:
```js run
alert( `My\n`.length ); // 3
```
-Note that `\n` is a single "special" character, so the length is indeed `3`.
+Note que `\n` é um único caractere "especial", então por isso o tamanho é na verdade `3`.
-```warn header="`length` is a property"
-People with a background in some other languages sometimes mistype by calling `str.length()` instead of just `str.length`. That doesn't work.
+```warn header="`length` é uma propriedade"
+Pessoas com alguma experiência em outras linguagens podem errar por chamar `str.length()` ao invés de apenas `str.length`. Isso não funciona.
-Please note that `str.length` is a numeric property, not a function. There is no need to add parenthesis after it. Not `.length()`, but `.length`.
+Veja, por favor, que `str.length` é uma propriedade numérica, não uma função. Não há necessidade de utilizar parênteses após a chamada. Não `.length()`, mas sim `.length`.
```
-## Accessing characters
+## Acessando Caracteres
-To get a character at position `pos`, use square brackets `[pos]` or call the method [str.at(pos)](mdn:js/String/at). The first character starts from the zero position:
+Para acessar um caractere na posição `pos`, use colchetes `[pos]` ou chame o método [str.at(pos)](mdn:js/String/at). O primeiro caractere se encontra na posição zero:
```js run
let str = `Hello`;
-// the first character
+// o primeiro caractere
alert( str[0] ); // H
alert( str.at(0) ); // H
-// the last character
+// o último caractere
alert( str[str.length - 1] ); // o
alert( str.at(-1) );
```
-As you can see, the `.at(pos)` method has a benefit of allowing negative position. If `pos` is negative, then it's counted from the end of the string.
+Como você pode ver, o método `.at(pos)` tem o benefício de permitir posições negativas. Se `pos` é negativo, então a contagem começará do fim da string.
-So `.at(-1)` means the last character, and `.at(-2)` is the one before it, etc.
+Assim `.at(-1)`remete ao último caractere, `.at(-2)` remete ao antepenúltimo, e assim por diante.
-The square brackets always return `undefined` for negative indexes, for instance:
+Os colchetes sempre retornam `undefined` para índices negativos, por exemplo:
```js run
let str = `Hello`;
@@ -156,80 +156,80 @@ alert( str[-2] ); // undefined
alert( str.at(-2) ); // l
```
-We can also iterate over characters using `for..of`:
+Também podemos iterar pelos caracteres usando `for..of`:
```js run
for (let char of "Hello") {
- alert(char); // H,e,l,l,o (char becomes "H", then "e", then "l" etc)
+ alert(char); // H,e,l,l,o (char vira "H", então "e", então "l" etc)
}
```
-## Strings are immutable
+## Strings são imutáveis
-Strings can't be changed in JavaScript. It is impossible to change a character.
+Strings não podem ser mudadas em JavaScript. É impossível mudar um caractere.
-Let's try it to show that it doesn't work:
+Vamos tentar isso para demonstrar que não funciona:
```js run
let str = 'Hi';
str[0] = 'h'; // error
-alert( str[0] ); // doesn't work
+alert( str[0] ); // não funciona
```
-The usual workaround is to create a whole new string and assign it to `str` instead of the old one.
+A maneira comum é criar toda uma nova string e atribuí-la a `str` ao invés da antiga.
-For instance:
+Por exemplo:
```js run
let str = 'Hi';
-str = 'h' + str[1]; // replace the string
+str = 'h' + str[1]; // substitui a string
alert( str ); // hi
```
-In the following sections we'll see more examples of this.
+Nas seções posteriores veremos mais exemplos disso.
-## Changing the case
+## Alterando entre maiúscula e minúscula
-Methods [toLowerCase()](mdn:js/String/toLowerCase) and [toUpperCase()](mdn:js/String/toUpperCase) change the case:
+Métodos [toLowerCase()](mdn:js/String/toLowerCase) e [toUpperCase()](mdn:js/String/toUpperCase) alteram a caixa do caractere:
```js run
alert( 'Interface'.toUpperCase() ); // INTERFACE
alert( 'Interface'.toLowerCase() ); // interface
```
-Or, if we want a single character lowercased:
+Ou, se quisermos que apenas uma letra fique minúscula:
```js run
alert( 'Interface'[0].toLowerCase() ); // 'i'
```
-## Searching for a substring
+## Procurando por uma substring
-There are multiple ways to look for a substring within a string.
+Existem muitas maneiras de procurar por uma substring dentro de uma string.
### str.indexOf
-The first method is [str.indexOf(substr, pos)](mdn:js/String/indexOf).
+O primeiro método é [str.indexOf(substr, pos)](mdn:js/String/indexOf).
-It looks for the `substr` in `str`, starting from the given position `pos`, and returns the position where the match was found or `-1` if nothing can be found.
+O método procura a `substr` na `str`, começando da posição dada em `pos`, e retorna a posição em que foi encontrada ou retorna `-1` se nada for encontrado.
-For instance:
+Por exemplo:
```js run
let str = 'Widget with id';
-alert( str.indexOf('Widget') ); // 0, because 'Widget' is found at the beginning
-alert( str.indexOf('widget') ); // -1, not found, the search is case-sensitive
+alert( str.indexOf('Widget') ); // 0, porque 'Widget' encontra-se no começo
+alert( str.indexOf('widget') ); // -1, não encontrado, a procura é sensível à forma
-alert( str.indexOf("id") ); // 1, "id" is found at the position 1 (..idget with id)
+alert( str.indexOf("id") ); // 1, "id" encontra-se na posição 1 (..idget complementa o id)
```
-The optional second parameter allows us to start searching from a given position.
+O segundo parâmetro opcional permite-nos começar procurando da posição dada.
-For instance, the first occurrence of `"id"` is at position `1`. To look for the next occurrence, let's start the search from position `2`:
+Por exemplo, a primeira ocorrência de `"id"` é na posição `1`. Para encontrar a próxima ocorrência, vamos começar a procurar da posição `2`:
```js run
let str = 'Widget with id';
@@ -237,12 +237,12 @@ let str = 'Widget with id';
alert( str.indexOf('id', 2) ) // 12
```
-If we're interested in all occurrences, we can run `indexOf` in a loop. Every new call is made with the position after the previous match:
+Se estivermos interessados por todas as ocorrências, podemos chamar `indexOf` em um loop. Toda nova chamada é feita com a posição posterior ao último encontro:
```js run
let str = 'As sly as a fox, as strong as an ox';
-let target = 'as'; // let's look for it
+let target = 'as'; // Vamos procurar por isso
let pos = 0;
while (true) {
@@ -250,11 +250,11 @@ while (true) {
if (foundPos == -1) break;
alert( `Found at ${foundPos}` );
- pos = foundPos + 1; // continue the search from the next position
+ pos = foundPos + 1; // continue a procura a partir da próxima posição
}
```
-The same algorithm can be layed out shorter:
+O mesmo algoritmo pode ser organizado de maneira mais curta:
```js run
let str = "As sly as a fox, as strong as an ox";
@@ -269,40 +269,40 @@ while ((pos = str.indexOf(target, pos + 1)) != -1) {
```
```smart header="`str.lastIndexOf(substr, position)`"
-There is also a similar method [str.lastIndexOf(substr, position)](mdn:js/String/lastIndexOf) that searches from the end of a string to its beginning.
+Também há um método similar [str.lastIndexOf(substr, position)](mdn:js/String/lastIndexOf) que procura do fim da string ao seu começo.
-It would list the occurrences in the reverse order.
+Isso listaria as ocorrências na ordem inversa.
```
-There is a slight inconvenience with `indexOf` in the `if` test. We can't put it in the `if` like this:
+Existe um pequeno inconveniente com `indexOf` em uma condicional `if`. We can't put it in the `if`. Não podemos inserí-lo assim:
```js run
let str = "Widget with id";
if (str.indexOf("Widget")) {
- alert("We found it"); // doesn't work!
+ alert("We found it"); // Não funciona!
}
```
-The `alert` in the example above doesn't show because `str.indexOf("Widget")` returns `0` (meaning that it found the match at the starting position). Right, but `if` considers `0` to be `false`.
+O `alert` no exemplo acima não é mostrado porque `str.indexOf("Widget")` retorna `0` (significando que foi encontrado na posição de início). Certo, mas `if` considera `0` como `false`.
-So, we should actually check for `-1`, like this:
+Então, devemos checar através do `-1`, dessa forma:
```js run
-let str = "Widget with id";
+let str = "Widget com id";
*!*
if (str.indexOf("Widget") != -1) {
*/!*
- alert("We found it"); // works now!
+ alert("We found it"); // agora funciona!
}
```
### includes, startsWith, endsWith
-The more modern method [str.includes(substr, pos)](mdn:js/String/includes) returns `true/false` depending on whether `str` contains `substr` within.
+O método mais moderno [str.includes(substr, pos)](mdn:js/String/includes) retorna `true/false` a depender se a `str` contém a `substr` dentro.
-It's the right choice if we need to test for the match, but don't need its position:
+É a escolha correta se precisamos checar para o encontro, mas não precisamos da sua posição:
```js run
alert( "Widget with id".includes("Widget") ); // true
@@ -314,147 +314,147 @@ The optional second argument of `str.includes` is the position to start searchin
```js run
alert( "Widget".includes("id") ); // true
-alert( "Widget".includes("id", 3) ); // false, from position 3 there is no "id"
+alert( "Widget".includes("id", 3) ); // false, a partir da posição 3 não há "id"
```
-The methods [str.startsWith](mdn:js/String/startsWith) and [str.endsWith](mdn:js/String/endsWith) do exactly what they say:
+Os métodos [str.startsWith](mdn:js/String/startsWith) e [str.endsWith](mdn:js/String/endsWith) fazem exatamente o que dizem.
```js run
-alert( "*!*Wid*/!*get".startsWith("Wid") ); // true, "Widget" starts with "Wid"
-alert( "Wid*!*get*/!*".endsWith("get") ); // true, "Widget" ends with "get"
+alert( "*!*Wid*/!*get".startsWith("Wid") ); // true, "Widget" começa com "Wid"
+alert( "Wid*!*get*/!*".endsWith("get") ); // true, "Widget" termina com "get"
```
-## Getting a substring
+## Obtendo uma string
-There are 3 methods in JavaScript to get a substring: `substring`, `substr` and `slice`.
+Existem 3 métodos em JavaScript para obter uma substring: `substring`, `substr` e `slice`.
`str.slice(start [, end])`
-: Returns the part of the string from `start` to (but not including) `end`.
+: Retorna a parte da string do começo `start` até (mas não incluindo) o `end`.
- For instance:
+ Por exemplo:
```js run
let str = "stringify";
- alert( str.slice(0, 5) ); // 'strin', the substring from 0 to 5 (not including 5)
- alert( str.slice(0, 1) ); // 's', from 0 to 1, but not including 1, so only character at 0
+ alert( str.slice(0, 5) ); // 'strin', a substring do 0 ao 5 (sem incluir o 5)
+ alert( str.slice(0, 1) ); // 's', do 0 ao 1, mas sem incluir o 1, então apenas o caractere do 0
```
- If there is no second argument, then `slice` goes till the end of the string:
+ Se não houver um segundo argumento, então slice irá até o final da string:
```js run
let str = "st*!*ringify*/!*";
- alert( str.slice(2) ); // 'ringify', from the 2nd position till the end
+ alert( str.slice(2) ); // 'ringify', da segunda posição até o final
```
- Negative values for `start/end` are also possible. They mean the position is counted from the string end:
+ Valores negativos para `start/end` também são possíveis. Valores assim significam que a posição será contada a partir do final da string:
```js run
let str = "strin*!*gif*/!*y";
- // start at the 4th position from the right, end at the 1st from the right
+ // start na quarta posição a partir da direita e end na primeira posição a partir da direita
alert( str.slice(-4, -1) ); // 'gif'
```
`str.substring(start [, end])`
-: Returns the part of the string *between* `start` and `end` (not including `end`).
+: Retorna a parte da *entre* `start` e `end` (não incluindo `end`).
- This is almost the same as `slice`, but it allows `start` to be greater than `end` (in this case it simply swaps `start` and `end` values).
+ Isso é quase a mesma coisa que `slice`, mas esse método permite que `start` seja maior que `end` (nesse caso os valores de `start` e `end` são simplesmente trocados um pelo outro).
- For instance:
+ Por exemplo:
```js run
let str = "st*!*ring*/!*ify";
- // these are same for substring
+ // estes são iguais para substring
alert( str.substring(2, 6) ); // "ring"
alert( str.substring(6, 2) ); // "ring"
- // ...but not for slice:
- alert( str.slice(2, 6) ); // "ring" (the same)
- alert( str.slice(6, 2) ); // "" (an empty string)
+ // ...mas não para slice:
+ alert( str.slice(2, 6) ); // "ring" (mesma coisa)
+ alert( str.slice(6, 2) ); // "" (uma string vazia)
```
- Negative arguments are (unlike slice) not supported, they are treated as `0`.
+ Argumentos negativos (a não ser em slice) não são suportados, sendo tratados como `0`.
`str.substr(start [, length])`
-: Returns the part of the string from `start`, with the given `length`.
+: Retorna a parte da string a partir do `start`, com o `length` (comprimento) fornecido.
- In contrast with the previous methods, this one allows us to specify the `length` instead of the ending position:
+ Ao contrário dos métodos anteriores, esse nos permite especificar o `length` no lugar da posição final:
```js run
let str = "st*!*ring*/!*ify";
- alert( str.substr(2, 4) ); // 'ring', from the 2nd position get 4 characters
+ alert( str.substr(2, 4) ); // 'ring', a partir da segunda posição com 4 caracteres
```
- The first argument may be negative, to count from the end:
+ O primeiro argumento pode ser negativo para contar a posição a partir do final:
```js run
let str = "strin*!*gi*/!*fy";
- alert( str.substr(-4, 2) ); // 'gi', from the 4th position get 2 characters
+ alert( str.substr(-4, 2) ); // 'gi', a partir da quarta posição inversa com 2 caracteres
```
- This method resides in the [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) of the language specification. It means that only browser-hosted Javascript engines should support it, and it's not recommended to use it. In practice, it's supported everywhere.
+ Esse método reside no [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) da especificação da linguagem. Isso significa que apenas engines de JavaScript hospedados em navegadores devem suportá-lo. Na prática, é suportado em todo lugar.
-Let's recap these methods to avoid any confusion:
+Vamos recapitular esses métodos para evitar qualquer confusão:
-| method | selects... | negatives |
+| método | seleciona... | negativos |
|--------|-----------|-----------|
-| `slice(start, end)` | from `start` to `end` (not including `end`) | allows negatives |
-| `substring(start, end)` | between `start` and `end` (not including `end`)| negative values mean `0` |
-| `substr(start, length)` | from `start` get `length` characters | allows negative `start` |
+| `slice(start, end)` | de `start` a `end` (sem incluir `end`) | permite negativos |
+| `substring(start, end)` | entre `start` e `end` (sem incluir `end`) | valores negativos recebem `0` |
+| `substr(start, length)` | de `start` com `length` caracteres | permite negativos em `start` |
-```smart header="Which one to choose?"
-All of them can do the job. Formally, `substr` has a minor drawback: it is described not in the core JavaScript specification, but in Annex B, which covers browser-only features that exist mainly for historical reasons. So, non-browser environments may fail to support it. But in practice it works everywhere.
+```smart header="Qual deles escolher?"
+Todos eles podem fazer o trabalho. Formalmente, `substr` tem uma pequena desvantagem: não está descrita na especificação principal do JavaScript, mas sim no Annex B, que cobre apenas funcionalidades do navegador principalmente por motivos históricos. Então, ambientes fora dos navegadores podem falhar no suporte a essa funcionalidade. Mas, na prática funciona em qualquer lugar.
-Of the other two variants, `slice` is a little bit more flexible, it allows negative arguments and shorter to write.
+Das outras duas variantes, `slice` é um pouco mais flexível, permitindo argumentos negativos e mais curto de escrever.
-So, for practical use it's enough to remember only `slice`.
+Então, para usos práticos é suficiente guardar apenas lembrar-se de `slice`.
```
-## Comparing strings
+## Comparando strings
-As we know from the chapter