Tipos de Referência ECMAScript

Os tipos de referência são geralmente chamados de classes (class).

Este tutorial discutirá uma grande quantidade de tipos de referência pré-definidos do ECMAScript.

Tipos de referência

Os tipos de referência são geralmente chamados de classes (class), o que significa que, ao encontrar valores de referência, o que se trata é de objetos.

Este tutorial discutirá uma grande quantidade de tipos de referência pré-definidos do ECMAScript.

A partir de agora, o foco será discutido sobre os tipos de referência que estão estreitamente relacionados aos tipos primitivos já discutidos.

Atenção:Em termos tradicionais, o ECMAScript não possui realmente classes. De fato, além de indicar a ausência de classes, a palavra 'classe' não aparece de forma alguma no ECMA-262. O ECMAScript define 'definição de objeto', que é logicamente equivalente a classes em outros linguagens de programação.

Dica:Este tutorial usará o termo "objeto".

Os objetos são criados usando o operador new seguido do nome do objeto a ser instanciado. Por exemplo, o código a seguir cria uma instância do objeto Object:

var o = new Object();

Esta sintaxe é semelhante ao linguagem Java, mas quando há mais de um parâmetro, o ECMAScript requer a utilização de parênteses. Se não houver parâmetros, como no código a seguir, os parênteses podem ser omitidos:

var o = new Object;

Atenção:Embora os parênteses não sejam obrigatórios, é melhor usá-los para evitar confusão.

Dica:Vamos explorar mais profundamente objetos e seu comportamento no capítulo sobre fundamentos de objetos.

Este capítulo enfatiza os tipos de referência que têm tipos originais equivalentes.

Object

O objeto Object não é muito útil por si mesmo, mas antes de entender outras classes, é importante conhecê-lo. Porque o objeto Object no ECMAScript é semelhante ao java.lang.Object no Java, todos os objetos no ECMAScript são herdados deste objeto, todas as propriedades e métodos do objeto Object aparecem em outros objetos, então entender o objeto Object ajuda a entender melhor outros objetos.

O objeto Object possui as seguintes propriedades:

constructor
Referência (ponteiro) para a função que criou o objeto. Para o objeto Object, este ponteiro aponta para a função original Object().
Prototype
Referência ao objeto prototype do objeto. Para todos os objetos, ele retorna por padrão uma instância do objeto Object.

O objeto Object também possui vários métodos:

hasOwnProperty(property)
Determina se o objeto possui uma propriedade específica. Deve ser especificada como uma string (por exemplo, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Determina se o objeto é o原型 de outro objeto.
PropertyIsEnumerable
Determina se o atributo fornecido pode ser enumerado pela instrução for...in.
ToString()
Retorna a representação de string original do objeto. Para o objeto Object, o ECMA-262 não define este valor, então diferentes implementações do ECMAScript podem ter valores diferentes.
ValueOf()
Retorna o valor original mais adequado para o objeto. Para muitos objetos, o valor retornado por este método é o mesmo que o retornado por ToString().

Comentário:Cada atributo e método listados acima serão sobrescritos por outros objetos.

Objeto Boolean

O objeto Boolean é um tipo de referência do tipo original Boolean.

Para criar um objeto Boolean, basta passar o valor Boolean como parâmetro:

var oBooleanObject = new Boolean(true);

O objeto Boolean sobrescreve o método ValueOf() do objeto Object, retornando o valor original, ou seja, true e false. O método ToString() também é sobrescrito, retornando a string "true" ou "false".

Infelizmente, os objetos Boolean são pouco usados no ECMAScript, e mesmo quando usados, são difíceis de entender.

Problemas geralmente ocorrem quando se usa objetos Boolean em expressões booleanas. Por exemplo:

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true; // Output: true

Neste código, um objeto Boolean é criado com o valor false. Em seguida, este valor é operado com o valor true. No cálculo booleano, o resultado da operação AND entre false e true é false. No entanto, nesta linha de código, é calculado o oFalseObject, não seu valor false.

Como discutido anteriormente, em expressões booleanas, todos os objetos são automaticamente convertidos para true, então o valor de oFalseObject é true. Em seguida, true é operado com true, resultando em true.

Atenção:Embora você deva entender a disponibilidade do objeto Boolean, é melhor usar valores booleanos primitivos para evitar os problemas mencionados neste capítulo.

参阅

Para obter mais informações sobre o objeto Boolean, acesse Manual de Referência do Objeto Boolean em JavaScript。

Objeto Number

Como você pode imaginar, o objeto Number é um tipo de referência do tipo original Number. Para criar um objeto Number, use o seguinte código:

var oNumberObject = new Number(68);

Você deve ter reconhecido o objeto Number mencionado no capítulo anterior, ao discutir valores especiais (como Number.MAX_VALUE). Todos os valores especiais são atributos estáticos do objeto Number.

Para obter o valor original do objeto Number, basta usar o método valueOf():

var iNumber = oNumberObject.valueOf();

Claro, a classe Number também possui o método toString(), que foi discutido em detalhes na seção sobre conversão de tipos.

Além dos métodos padrão herdados do objeto Object, o objeto Number também possui alguns métodos específicos para o tratamento de números.

Método toFixed()

O método toFixed() retorna a representação em string de um número com um número específico de dígitos decimais. Por exemplo:

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  //Saída "68.00"

Aqui, o parâmetro do método toFixed() é 2, o que significa que devem ser exibidos dois dígitos decimais. Este método retorna "68.00", e os dígitos em branco são preenchidos com 0. Para aplicações de tratamento de moeda, este método é muito útil. O método toFixed() pode representar números com de 0 a 20 dígitos decimais, valores além deste escopo causarão erro.

Método toExponential()

Outro método relacionado à formatação de números é o toExponential(), que retorna a representação de um número em formato de contagem científica.

Da mesma forma que o método toFixed(), o método toExponential() também tem um parâmetro que especifica o número de dígitos decimais a serem exibidos. Por exemplo:

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  //Saída "6.8e+1"

O resultado deste código é "6.8e+1", como explicado anteriormente, representando 6.8x101A questão é, o que fazer se não se sabe qual forma (forma pré-definida ou exponencial) usar para representar um número? Pode-se usar o método toPrecision().

Método toPrecision()

O método toPrecision() retorna a forma pré-definida ou exponencial de um número com base na forma mais significativa. Ele tem um parâmetro, que é o número total de dígitos usados para representar o número (não incluindo o expoente). Por exemplo:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  //Saída "7e+1"

A tarefa deste código é representar o número 68 com um único dígito, resultando em "7e+1", ou de outra forma, 70. De fato, o método toPrecision() arredonda números.

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  //Saída "68"

Claro, o resultado é "68", pois isso é a representação exata do número. Mas e se o número de dígitos especificado for maior do que o necessário?

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  //输出 "68.0"

在这种情况下，toPrecision(3) 等价于 toFixed(1)，输出的是 "68.0"。

toFixed()、toExponential() 和 toPrecision() 方法都会进行舍入操作，以便用正确的小数位数正确地表示一个数。

Dica:与 Boolean 对象相似，Number 对象也很重要，不过应该少用这种对象，以避免潜在的问题。只要可能，都使用数字的原始表示法。

参阅

如需更多有关 Number 对象的信息，请访问 Manual de Referência do Objeto Number em JavaScript。

String 对象

String 对象是 String 原始类型的对象表示法，它是以下方式创建的：

var oStringObject = new String("hello world");

String 对象的 valueOf() 方法和 toString() 方法都会返回 String 类型的原始值：

alert(oStringObject.valueOf() == oStringObject.toString());	//输出 "true"

如果运行这段代码，输出是 "true"，说明这些值真的相等。

Comentário:String 对象是 ECMAScript 中比较复杂的引用类型之一。同样，本节的重点只是 String 类的基本功能。更多的高级功能请阅读本教程相关的章节，或参阅 Manual de Referência do Objeto String em JavaScript。

length 属性

String 对象具有属性 length，它是字符串中的字符个数：

var oStringObject = new String("hello world");
alert(oStringObject.length);	//输出 "11"

这个例子输出的是 "11"，即 "hello world" 中的字符个数。注意，即使字符串包含双字节的字符（与 ASCII 字符相对，ASCII 字符只占用一个字节），每个字符也只算一个字符。

charAt() 和 charCodeAt() 方法

String 对象还拥有大量的方法。

首先，两个方法 charAt() 和 charCodeAt() 访问的是字符串中的单个字符。这两个方法都有一个参数，即要操作的字符的位置。

charAt() 方法返回的是包含指定位置处的字符的字符串：

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	//输出 "e"

No texto "hello world", o caractere na posição 1 é "e".. Na seção "Tipos Primitivos ECMAScript", falamos sobre o fato de que a posição do primeiro caractere é 0, a posição do segundo caractere é 1, e assim por diante. Portanto, ao chamar charAt(1), retornamos "e".

Se você quiser obter o código do caractere em vez do caractere itself, pode chamar o método charCodeAt():

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1)); // Saída "101"

Este exemplo imprime "101", que é o código do caractere minúsculo "e".

O método concat()

Vamos falar sobre o método concat(), que é usado para concatenar uma ou mais strings ao valor original do objeto String. Esse método retorna o valor original do String, mantendo o objeto String original inalterado:

var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);        // Saída "hello world"
alert(oStringObject); // Saída "hello "

Neste trecho de código, o método concat() retorna "hello world", enquanto o objeto String armazena ainda "hello ". Por essa razão, é mais comum usar o sinal de mais (+) para concatenar strings, pois essa forma logicamente indica o comportamento real:

var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);        // Saída "hello world"
alert(oStringObject); // Saída "hello "

Os métodos indexOf() e lastIndexOf()

Até agora, já discutimos os métodos de concatenação de strings e os métodos de acesso a caracteres individuais dentro de uma string. No entanto, se você não puder determinar se um caractere realmente existe em uma string, qual método deve ser chamado? Neste caso, você pode chamar os métodos indexOf() e lastIndexOf().

Os métodos indexOf() e lastIndexOf() retornam a posição da substring especificada dentro de outra string. Se a substring não for encontrada, retorna -1.

A diferença entre esses métodos é que o indexOf() começa a procurar a substring a partir do início da string (posição 0), enquanto o lastIndexOf() começa a procurar a substring a partir do final da string. Por exemplo:

var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o")); // Saída "4"
alert(oStringObject.lastIndexOf("o")); // Saída "7"

Aqui, a primeira string "o" aparece na posição 4, ou seja, no "o" do "hello"; a última string "o" aparece na posição 7, ou seja, no "o" do "world". Se a string tiver apenas uma ocorrência da string "o", então os métodos indexOf() e lastIndexOf() retornam a mesma posição.

Método localeCompare()

O próximo método é localeCompare(), para ordenar strings. Este método tem um parâmetro - a string a ser comparada, e retorna um dos três valores a seguir:

  • Se o objeto String estiver na ordem alfabética antes da string passada como parâmetro, retorna um número negativo.
  • Se o objeto String for igual à string passada como parâmetro, retorna 0
  • Se o objeto String estiver na ordem alfabética após a string passada como parâmetro, retorna um número positivo.

Comentário:Se o retorno for negativo, o mais comum é -1, mas o valor real retornado é determinado pela implementação. Se o retorno for positivo, da mesma forma, o mais comum é 1, mas o valor real retornado é determinado pela implementação.

Exemplo a seguir:

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick")); // Saída "1"
alert(oStringObject.localeCompare("yellow")); // Saída "0"
alert(oStringObject.localeCompare("zoo")); // Saída "-1"

Neste código, a string "yellow" é comparada com 3 valores, ou seja, "brick", "yellow" e "zoo". Devido à ordenação alfabética, "yellow" está após "brick", então localeCompare() retorna 1; "yellow" é igual a "yellow", então localeCompare() retorna 0; "zoo" está após "yellow", localeCompare() retorna -1. Repito mais uma vez, devido ao valor retornado ser determinado pela implementação, é melhor chamar o método localeCompare() da seguinte forma:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " vem antes " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " vem após " + oStringObject2);
} else {
  alert("As duas strings são iguais");
}

Com essa estrutura, pode-se garantir que esse código funcione corretamente em todas as implementações.

A peculiaridade do método localeCompare() está na precisão do local (locale, que também se refere a país/região e idioma) que especifica como esse método opera. Nos Estados Unidos, o inglês é o idioma padrão da implementação ECMAScript, e localeCompare() é case-sensitive, com letras maiúsculas vindo após as minúsculas na ordem alfabética. No entanto, em outras regiões, a situação pode não ser a mesma.

slice() e substring()

ECMAScript oferece dois métodos para criar valores de string a partir de substrings, ou seja, slice() e substring(). Ambos esses métodos retornam substrings do string a ser tratado e aceitam um ou dois parâmetros. O primeiro parâmetro é a posição de início do substring a ser obtido, e o segundo parâmetro (se usado) é a posição antes da qual o substring deve ser obtido (isto é, o caractere na posição de terminação não é incluído no valor retornado). Se o segundo parâmetro for omitido, a posição de terminação é definida como o comprimento da string.

Como o método concat(), os métodos slice() e substring() não alteram o valor do objeto String. Eles apenas retornam o valor original do String, mantendo o objeto String inalterado.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); // Saída "lo world"
alert(oStringObject.substring("3")); // Saída "lo world"
alert(oStringObject.slice("3", "7")); // Saída "lo w"
alert(oStringObject.substring("3", "7")); // Saída "lo w"

Neste exemplo, o uso dos métodos slice() e substring() é idêntico e os valores de retorno também são os mesmos. Quando há apenas o parâmetro 3, ambos os métodos retornam "lo world", pois o segundo "l" em "hello" está na posição 3. Quando há dois parâmetros "3" e "7", ambos os métodos retornam "lo w" (o caractere "o" na palavra "world" está na posição 7, então ele não está incluído no resultado).

Por que existem dois métodos com funcionalidades completamente iguais? Na verdade, esses métodos não são completamente iguais, mas apenas quando os parâmetros são negativos, eles tratam os parâmetros de maneira ligeiramente diferente.

Para parâmetros negativos, o método slice() adiciona o comprimento da string ao parâmetro, enquanto o método substring() trata-o como 0 (ou seja, ignora-o). Por exemplo:

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3")); // Saída "rld"
alert(oStringObject.substring("-3")); // Saída "hello world"
alert(oStringObject.slice("3, -4")); // Saída "lo w"
alert(oStringObject.substring("3, -4")); // Saída "hel"

Desta forma, podemos ver a principal diferença entre os métodos slice() e substring().

Quando apenas o parâmetro -3 é especificado, slice() retorna "rld", substring() retorna "hello world". Isso ocorre porque para a string "hello world", slice("-3") é convertido em slice("8"), enquanto substring("-3") é convertido em substring("0").

Da mesma forma, ao usar os parâmetros 3 e -4, a diferença é clara. slice() será convertido para slice(3, 7), como no exemplo anterior, retornando "lo w". Enquanto isso, o método substring() interpretará os dois parâmetros como substring(3, 0), que é substring(0, 3), porque substring() sempre usa o número menor como posição de início e o número maior como posição de fim. Portanto, substring("3, -4") retorna "hel". A última linha de código é usada para explicar como usar esses métodos.

toLowerCase(), toLocaleLowerCase(), toUpperCase() e toLocaleUpperCase()

O último conjunto de métodos a ser discutido envolve conversão de maiúsculas e minúsculas. Existem 4 métodos para executar conversões de maiúsculas e minúsculas, ou seja

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

Como o nome sugere, os primeiros dois métodos são usados para converter strings para minúsculas, enquanto os outros dois métodos são usados para converter strings para maiúsculas.

Os métodos toLowerCase() e toUpperCase() são originais e são implementados com base no mesmo protótipo de método em java.lang.String.

O método toLocaleLowerCase() e toLocaleUpperCase() são implementados com base em uma região específica (igual ao método localeCompare()). Em muitos casos, os métodos específicos da região são idênticos aos métodos gerais. No entanto, alguns idiomas aplicam regras específicas de conversão de maiúsculas e minúsculas para Unicode (por exemplo, o turco), portanto, é necessário usar métodos específicos da região para realizar conversões corretas.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());	//输出 "HELLO WORLD"
alert(oStringObject.toUpperCase());		//输出 "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());	//输出 "hello world"
alert(oStringObject.toLowerCase()); // Saída "hello world"

Neste código, toUpperCase() e toLocaleUpperCase() saem todos "HELLO WORLD", e toLowerCase() e toLocaleLowerCase() saem todos "hello world". Geralmente, se não souber em qual codificação um idioma está sendo executado, é mais seguro usar métodos específicos da região.

Dica:Lembre-se, todas as propriedades e métodos do objeto String podem ser aplicados ao valor original String, porque eles são pseudo-objetos.

Operador instanceof

Ao usar o operador typeof com armazenamento de tipos de referência, há um problema, pois, independentemente do tipo do objeto que está sendo referenciado, ele sempre retorna "object". O ECMAScript introduziu outro operador Java, instanceof, para resolver este problema.

O operador instanceof é semelhante ao operador typeof, usado para identificar o tipo do objeto que está sendo tratado. Diferente do método typeof, o método instanceof requer que o desenvolvedor confirme explicitamente que o objeto é de um tipo específico. Por exemplo:

var oStringObject = new String("hello world");
alert(oStringObject instanceof String); // Saída "true"

Este código pergunta se "o oStringObject é uma instância do objeto String?" O oStringObject é realmente uma instância do objeto String, portanto o resultado é "true". Embora não seja tão flexível quanto o método typeof, o método instanceof ainda é muito útil quando o método typeof retorna "object".