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):
Codigo | Saida |
---|---|
\0 | o caractere NULL |
\' | aspas simples |
\" | aspas duplas |
\\ | barra invertida |
\n | nova linha |
\r | carriage return |
\v | tab vertical |
\t | tab |
\b | backspace |
\f | form feed |
\uXXXX | unicode codepoint |
\xXX | the Latin-1 character |
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
StringView
– a C-like representation of strings based on typed arrays.Propriedades
String.prototype
- Permite a adição de propriedades a um objeto String.
Métodos
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
Specification | Status | Comment |
---|---|---|
ECMAScript 1st Edition. | Standard | Definições iniciais. |
ECMAScript 5.1 (ECMA-262) The definition of 'String' in that specification. |
Padrão | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String' in that specification. |
Padrão |
Compatibilidade de Browser
Característica | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Basic support | 0.2 | (Yes) | (Yes) | (Yes) | (Yes) |
Característica | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Suporte básico | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |