Strings

Qualquer conjunto de caracteres (letras, números, símbolos, e assim por diante) entre um conjunto de aspas duplas ("), aspas simples (') ou acentos graves (`) é um primitivo de string. Você já viu alguns exemplos de strings deste curso: as instâncias de console.log no módulo anterior continham primitivas de string.

console.log( "Hello, World." );
> Hello, World.

"Hello, World." é uma string primitiva. O resultado é o mesmo com aspas ou acentos graves:

console.log( 'Hello, World.' );
> Hello, World.

console.log(`Hello, World.`);
> Hello, World.

Uma série de caracteres entre aspas é chamada de literal de string. Aspas duplas e simples se comportam da mesma maneira, e uma pode conter a outra como um caractere na própria string:

console.log( "I'm a string." );
> I'm a string.

console.log( '"A string," I said.' );
> "A string," I said.

Uma instância do mesmo caractere dentro da string "closes" as , provavelmente causando erros:

console.log( '"I'm a string," I said.' );
> Uncaught SyntaxError: missing ) after argument list

Para evitar isso, faça o escape do caractere usando uma barra invertida (/):

console.log( '"I\'m a string," I said.' );
> "I'm a string," I said.

Objeto de string

Quando chamado como uma função, o objeto String converte um valor especificado em uma literal de string.

let myString = String( 10 );

myString
> "10"

typeof myString
> string

Conforme detalhado em Herança prototípica, raramente será necessário usar o objeto String como um construtor. Ele cria um objeto de string contendo o valor especificado, além dos métodos e propriedades já fornecidos pelo objeto String, em vez de um literal de string.

let stringObj = new String( "My new string." );

typeof stringObj
> object

stringObj
> String { "My new string." }

Concatenação

Quando usado no contexto de strings em vez de números, um único sinal de adição (+) atua como um operador de concatenação, combinando vários valores de string em um único string:

console.log( "My" + " string." );
> My string.

Literais de string e de modelo

Aspas simples, aspas duplas e acentos graves podem ser usadas de modo intercambiável para criando primitivas de string. No entanto, também é possível usar acentos graves para especificar literais de modelo (às vezes chamados de "strings de modelo"). Ao contrário do literais de string criados por aspas simples ou duplas, os literais de modelo permitem para strings de várias linhas e interpolação de strings.

const myString = "This
is a string.";
> Uncaught SyntaxError: "" string literal contains an unescaped line break

const myString = `This
is a string.`;

console.log( myString );

> This
is a string.

Os literais de modelo podem conter expressões de marcador de posição marcadas por um sinal de dólar e chaves (${}). Esses marcadores são "interpolados" por padrão, o que significa que o resultado da expressão substitui o marcador na string final.

console.log( "The result is " + ( 2 + 4 ) + "." );
> The result is 6.

console.log( `The result is ${ 2 + 4 }.` );
> The result is 6.

Um literal de modelo pode ser transmitido a uma função personalizada para criar um modelo com tags, uma chamada de função que usa um único literal de modelo como um conjunto de argumentos e permite que os marcadores de posição sejam preenchidos com base na lógica definida pelo autor.

O primeiro argumento de uma função de tag contém uma matriz de valores de string, e o argumentos restantes definem os espaços reservados. Essa matriz de valores de string criado ao "dividir" literal do modelo em cada marcador de posição que ele contém. O o primeiro elemento na matriz contém caracteres até o primeiro marcador de posição, o segundo elemento contém quaisquer caracteres entre o primeiro e o segundo espaços reservados e assim por diante. Cada marcador de posição é passado para a função da tag como um valor autônomo a um marcador associado.

const myNoun = "template literal";

function myTagFunction( myStrings, myPlaceholder ) {
    const myInitialString = myStrings[ 0 ];
    console.log( `${ myInitialString }modified ${ myPlaceholder }.` );
}

myTagFunction`I'm a ${ myNoun }.`;
> "I'm a modified template literal."

Teste seu conhecimento