String

Sumário

O objeto global String  é um construtor para strings, ou uma sequência de caracteres.

Sintaxe

As formas literais de declaração de String  são:

'string text'
"string text"
"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"

Além da forma regular, de caracteres de impressão, caracteres especiais podem ser codificados usando a escape notation (notação com barra invertida):

Ou, usando o objeto global String diretamente:

String(thing)
new String(thing)

Parâmetros

thing

Qualquer coisa a ser convertida para uma string.

Descrição

Strings são úteis para guardar dados que podem ser representados em forma de texto. Uma das operações mais usadas nas strings é checar seu tamanho, para construir e concatená-las  usando os operadores + e +=, checando pela existência ou posição de substrings com o método indexOf , ou extrair substrings com o método substring.

Acesso à caractere

Há duas maneiras de acessar um caractere individual em uma string. A primeira é o método charAt:

return 'cat'.charAt(1); // returns "a"

A outra maneira (introduzido no ECMAScript 5) consiste em tratar a string como um objeto Array-like, onde os caráteres individuais correspondem a um índice numérico:

return 'cat'[1]; // returns "a"

Para acesso de caracteres usando uma notação de colchetes, tentando deletar ou designar um valor a estas propriedades não haverá sucesso. As propriedades envolvidas não são nem escritas ou configuráveis. (Veja Object.defineProperty para mais informações.)

Comparando strings

Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScript, basta usar o operador maior que e menor que:

var a = "a";
var b = "b";
if (a < b) // verdadeiro
  print(a + " é menor que " + b);
else if (a > b)
  print(a + " é maior que " + b);
else
  print(a + " e " + b + " são iguais.");

Um resultado similar pode ser alcançado usando o método  localeCompare herdado pelas instâncias de String.

Distinção entre String primitiva e objetos String

Note que o JavaScript distingue entre objetos String e valores de string primitivas. (O mesmo é válido para Boolean e Numbers.)

Strings literais (definidas por aspas duplas ou aspas simples) e strings retornadas da chamada da função String fora do contexto de uma função construtora (sem o uso da palavra chave new) são strings primitivas. O JavaScript converte automaticamente strings primitivas para objetos do tipo String, por isso é possível utilizar os métodos do objeto String através de strings primitivas. Em contextos onde um método é invocado de uma string primitiva ou uma propriedade é procurada, o JavaScript irá criar um objeto com a string primitiva e executar o método ou acessar a propriedade procurada.

var s_prim = "foo";
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Loga "string"
console.log(typeof s_obj);  // Loga "object"

String primitivas e objetos String também dão resultados diferentes quando usado eval. Primitivas passadas para eval são tratadas como código fonte; Objetos String são tratados como todos os outros objetos são, retornando o objeto. Por exemplo:

s1 = "2 + 2";               // cria uma string primitiva
s2 = new String("2 + 2");   // cria um objeto de String
console.log(eval(s1));      // retorna o número 4
console.log(eval(s2));      // retorna a string "2 + 2"

Por estas razões, o código pode quebrar quando encontra objetos String quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção.

Um objeto String pode ser convertido sempre para sua contraparte primitiva com o método valueOf.

console.log(eval(s2.valueOf())); // retorna o número 4

Propriedades

For properties available on String instances, see Properties of String instances.

String.prototype

Permite a adição de propriedades a um objeto String.

Métodos

For methods available on String instances, see Methods of String instances.

String.fromCharCode()

Retorna uma string criada usando a sequência especificada de valores Unicode.

String.fromCodePoint()

Retorna uma string criada usando a sequência especificada de posições de código.

Métodos genéricos de Strings

Métodos de instância String também estão disponíveis no Firefox a partir de JavaScript 1.6 (embora não faça parte dos padrões ECMAScript) no objeto String para aplicar métodos String a qualquer objeto:

var num = 15;
alert(String.replace(num, /5/, '2'));

Genéricos também estão disponíveis em métodos Array.

O seguinte é uma implementação para fornecer suporte a navegadores sem suporte:

/*globals define*/
// Assume que todos os métodos de instância String fornecidos
// já presentes (podem ser usadas implementações para este se não disponível)
(function () {
    'use strict';

    var i,
        // Nós também poderíamos construir o array de métodos com os seguintes,
        // mas o método getOwnPropertyNames() não é implementável:
        // Object.getOwnPropertyNames(String).filter(function (methodName)
        //  {return typeof String[methodName] === 'function'});
        methods = [
            'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
            'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
            'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
            'toLocaleUpperCase', 'localeCompare', 'match', 'search',
            'replace', 'split', 'substr', 'concat', 'slice'
        ],
        methodCount = methods.length,
        assignStringGeneric = function (methodName) {
            var method = String.prototype[methodName];
            String[methodName] = function (arg1) {
                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
            };
        };

    for (i = 0; i < methodCount; i++) {
        assignStringGeneric(methods[i]);
    }
}());

Instâncias de String

Propriedades

String.prototype.constructor

Especifica a função que cria o protótipo de um objeto.

String.prototype.length

Reflete o comprimento da string.

N

Usado para acessar o caractere na posição N onde N é um número inteiro entre 0 e um menor que o valor da length. Estas propriedades são apensa de leitura.

Métodos

Métodos não relacionados ao HTML

String.prototype.charAt()

Retorna o caractere (exatamente uma unidade de código UTF-16) no índice especificado.

String.prototype.charCodeAt()

Retorna um número que é o valor da unidade de código UTF-16 em dado índice.

String.prototype.codePointAt()

Retorna um número inteiro não negativo Number que é o valor de posição de código da posição de código inicial em dado índice.

String.prototype.concat()

Combina o texto de duas strings e retorna uma nova string.

String.prototype.includes()

 Determina se uma string deve ser encontrada dentro de outra string.

String.prototype.endsWith()

Determina se uma string termina com os caracteres de outra string.

String.prototype.indexOf()

Retorna o índice dentro do objeto String chamado da primeira ocorrência do valor especificado, ou -1 se não encontrado.

String.prototype.lastIndexOf()

Retorna o índice dentro do objeto String chamado da última ocorrência do valor especificado, ou -1 se não encontrado.

String.prototype.localeCompare()

Retorna um número indicando se uma string de referência vem antes ou depois ou é o mesmo que uma string dada em ordem de classificação.

String.prototype.match()

Usado para combinar uma expressão regular com uma string.

String.prototype.normalize()

Retorna o Formulário de Normalização Unicode do valor string chamado.

String.prototype.padEnd()

Empacota a string atual desde o final com uma string dada para criar uma nova string de um dado comprimento.

String.prototype.padStart()

Empacota a string atual desde o início com uma string dada para criar uma nova string de um dado comprimento.

String.prototype.quote()

Envolve a cadeia entre aspas duplas ("" ").

String.prototype.repeat()

Retorna uma string consistindo elementos do objeto repetido pelas vezes definidas.

String.prototype.replace()

Usado para encontrar uma combinação entre uma expressão regular e uma string, e para substituir uma substring combinada com uma nova substring.

String.prototype.search()

Executa a procura por uma combinação entre uma expressão regular e uma string especificada.

String.prototype.slice()

Extrai uma seção de uma string e retorna uma nova string.

String.prototype.split()

Separa um objeto String em um array de strings separando a string em substrings.

String.prototype.startsWith()

Determina se uma string começa com os caracteres de outra string.

String.prototype.substr()

Retorna os caracteres em uma string começando no local especificado através do número especificado de caracteres.

String.prototype.substring()

Retorna os caracteres em uma string entre dois índices na string.

String.prototype.toLocaleLowerCase()

Os caracteres dentro de uma string são convertidos para letras minúsculas enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que toLowerCase().

String.prototype.toLocaleUpperCase()

Os caracteres dentro de uma string são convertidas para letra maiúscula enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que toUpperCase().

String.prototype.toLowerCase()

Retorna o valor da string de chamada convertido em minúsculas.

String.prototype.toSource()

Retorna um objeto literal representando o objeto especificado; Você pode usar esse valor para criar um novo objeto. Substitui o metodo:Object.prototype.toSource()

String.prototype.toString()

Retorna uma string que representa o objeto especificado. Substitui o metodo:Object.prototype.toString()

String.prototype.toUpperCase()

Retorna o valor da string de chamada convertido em maiúscula.

String.prototype.trim()

Retira o espaço em branco desde o início e o fim da string. Parte do padrão ECMAScript 5.

String.prototype.trimLeft()

Retira o espaço em branco do lado esquerdo da string.

String.prototype.trimRight()

Retira o espaço em branco do lado esquerdo da string.

String.prototype.valueOf()

Retorna o valor primitivo do objeto especificado. Substitui o metodo: Object.prototype.valueOf() 

String.prototype[@@iterator]()

Retorna um novo objeto  Iterator que repete sobre os pontos de código de um valor String, retornando cada ponto de código como um valor String.

Métodos de envoltório HTML

Esses métodos são de uso limitado, pois fornecem apenas um subconjunto das tags e atributos HTML disponíveis.

String.prototype.anchor()

<a name="name"> (alvo hipertexto)

String.prototype.big()

<big>

String.prototype.blink()

<blink>

String.prototype.bold()

<b>

String.prototype.fixed()

<tt>

String.prototype.fontcolor()

<font color="color">

String.prototype.fontsize()

<font size="size">

String.prototype.italics()

<i>

String.prototype.link()

<a href="url"> (link para URL)

String.prototype.small()

<small>

String.prototype.strike()

<strike>

String.prototype.sub()

<sub>

String.prototype.sup()

<sup>

Exemplos

Conversão de String

É possível usar String como uma alternativa "mais segura" toString, como embora normalmente ainda chama o toString subjacente, também funciona para null e undefined. Por exemplo:

var outputStrings = [];
for (let i = 0, n = inputValues.length; i < n; ++i) {
  outputStrings.push(String(inputValues[i]));
}

Especificações

Compatibilidade de Browser

We're converting our compatibility data into a machine-readable JSON format. This compatibility table still uses the old format, because we haven't yet converted the data it contains. Find out how you can help!

Veja também

• DOMString
• StringView – a C-like representation of strings based on typed arrays
• Binary strings