String

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

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)

thing

Qualquer coisa a ser convertida para uma string.

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.

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.)

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.

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

String.prototype

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

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 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]);
    }
}());

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 apenas de leitura.

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() (en-US)

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

String.prototype.trimRight() (en-US)

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> (en-US)

String.prototype.fontcolor()

<font color="color"> (en-US)

String.prototype.fontsize()

<font size="size"> (en-US)

String.prototype.italics()

<i>

String.prototype.link()

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

String.prototype.small()

<small> (en-US)

String.prototype.strike()

<strike> (en-US)

String.prototype.sub()

<sub> (en-US)

String.prototype.sup()

<sup> (en-US)

É 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]));
}

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