Introdução
Saber qual é o tipo de um dado costuma ser muito importante para que o código rode bem e sem erros.
O JavaScript tem várias formas de verificar o tipo de um valor ou objeto.
Os mecanismos de verificação de tipo do JavaScript podem ser um tanto pouco confiáveis.
Para uma segurança de tipos melhor e tipos mais fortes, você provavelmente deveria usar TypeScript, uma linguagem que se baseia no JavaScript, mas com a sintaxe de tipos de uma linguagem de tipagem estática.
O operador typeof
O operador typeof retorna o tipo do seu operando.
A saída é uma string que corresponde ao nome de um dos tipos de dados primitivos, exceto por "null".
Ela também pode ser "function" ou "object".
typeof undefined;
// => "undefined"
typeof true;
// => "boolean"
typeof 42;
// => "number"
typeof 'Hello, World!';
// => "string"
typeof function () {
return 'Hello, World';
};
// => "function"
typeof [1, 2, 3, 4];
// => "object"
typeof { city: 'Stockholm', country: 'Sweden' };
// => "object"
Por [razões históricas][typeof null is "object"].
O operador instanceof
Para verificar o tipo de um objeto, você pode usar o operador instanceof.
Ele é avaliado como um boolean dependendo de o segundo operando estar incluído na cadeia de protótipos do primeiro operando.
Para esclarecer, instanceof retorna se o primeiro operando é uma instância do segundo operando ou de uma das suas classes filhas.
instanceof só funciona com objetos.
class Beverage {
// ...
}
// The Coffee class is a child of the Beverage class.
class Coffee extends Beverage {
// ...
}
const java = new Coffee();
java instanceof Coffee;
// => true
java instanceof Beverage;
// => true
A classe Array tem um método chamado Array.isArray() que verifica se o seu argumento é um array.
Enquanto instanceof Array não funciona com um array criado em um realm diferente, como um iframe em uma página web, Array.isArray() funciona.
Isso acontece porque a classe Array tem um construtor diferente em cada realm, e cada iframe tem o seu próprio realm, o que significa que a função na cadeia de protótipos será diferente, fazendo instanceof Array falhar.
Array.isArray() consegue ignorar isso e deve sempre ser usado quando possível.
Ele também resiste a falsos positivos, em que um objeto não é de fato um Array e apenas tem Array na sua cadeia de protótipos.
({ __proto__: Array.prototype }) instanceof Array
// => true
Array.isArray({ __proto__: Array.prototype })
// => false
O operador in
O operador in retorna se o primeiro operando é uma propriedade do segundo operando.
Ele não verifica se a propriedade tem um valor definido.
Uma propriedade definida como undefined ainda será detectada pelo in.
class Coffee {
constructor() {
this.temperature = 'hot';
this.isDarkMatter = undefined;
}
coolDown() {
this.temperature = 'warm';
}
}
const espresso = new Coffee();
'temperature' in espresso;
// => true
'color' in espresso;
// => false
'isDarkMatter' in espresso;
// => true
O in retornará true para propriedades e métodos herdados.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Para evitar isso, use Object.hasOwn() em vez disso
A função Object.hasOwn()
O método Object.hasOwn() retorna se o objeto especificado possui a propriedade em questão (ela não é herdada nem é um método).
class Coffee {
constructor() {
this.temperature = 'hot';
}
coolDown() {
this.temperature = 'warm';
}
}
const cappuccino = new Coffee();
Object.hasOwn(cappucino, 'temperature');
// => true
Object.hasOwn(cappucino, 'constructor');
// => false
Object.hasOwn(cappucino, 'coolDown');
// => false
Instruções
Instruções
Você foi contratado por um centro de reciclagem.
Por falta de espaço, todos os produtos são colocados na mesma esteira transportadora, mas isso fez com que materiais diferentes se misturassem, o que os torna inutilizáveis.
Para resolver isso, sua tarefa é criar funções que identifiquem o tipo de um produto.
1. Verifique se um valor é um Boolean
Implemente a função isBoolean, que verifica se um valor é um Boolean.
isBoolean(true);
// => true
isBoolean(null);
// => false
2. Verifique se um valor é um número.
Implemente a função isNumber, que verifica se um valor é um number ou bigint finito, ou seja, que não é NaN nem Infinity.
Às vezes, o dispositivo de leitura de IDs falha e lê um valor não numérico como NaN (não é um número) ou Infinity.
Sua função também deve conseguir lidar com isso corretamente.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Verifique se um valor é um objeto
Implemente a função isObject, que deve verificar se o valor é um objeto.
Na esteira, null é nada e não é considerado um objeto.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Verifique se uma string é numérica
Implemente a função isNumericString, que deve verificar se o valor é uma string composta apenas de dígitos, ou de um sinal de menos seguido de dígitos, indicando um número negativo.
Apenas números inteiros devem ser considerados; decimais não são considerados numéricos para essa verificação do robô de reciclagem.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Verifique se um objeto é eletrônico
Implemente a função isElectronic, que verifica se um objeto é uma instância da classe ElectronicDevice fornecida ou de uma de suas classes filhas.
class Duck {
//...
}
class WashingMachine extends ElectronicDevice {
//...
}
isElectronic(new Duck());
// => false
isElectronic(new WashingMachine());
// => true
6. Verifique se um valor é um array não vazio
Implemente a função isNonEmptyArray, que verifica se um valor é um array não vazio.
isNonEmptyArray([1, 2, 3]);
// => true
isNonEmptyArray([]);
// => false
7. Verifique se um valor é um array vazio
Implemente a função isEmptyArray, que verifica se um valor é um array vazio.
isEmptyArray([1, 2, 3]);
// => false
isEmptyArray([]);
// => true
8. Verifique se um objeto tem uma propriedade ou método type
Implemente a função hasType, que verifica se um objeto tem uma propriedade ou método type.
class Keyboard(){
type(){
// ...
}
}
hasType({ type:"car", color:"red" })
// => true
hasType({ color:"green" })
// => false
hasType(new Keyboard())
// => true
9. Lance um erro se um objeto não tiver uma propriedade ou método id
Implemente a função assertHasId, que lançará um Error se um objeto não tiver a propriedade id.
Se um objeto tiver a propriedade id, a função não deve retornar nada.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Verifique se um objeto tem uma propriedade id
Implemente a função hasIdProperty, que verifica se um objeto tem uma propriedade id.
class SimpleData {
constructor() {
this.number = '42';
this.id = 'BC269327FE1D9B95';
}
}
class StealingData extends SimpleData {}
class MethodData {
constructor() {
this.number = '42';
this._id = 'BC269327FE1D9B95';
}
get id() {
return this._id;
}
}
hasIdProperty(new SimpleData());
// => true
hasIdProperty(new MethodData());
// => false
hasIdProperty(new StealingData());
// => false
11. Verifique se um objeto tem uma propriedade type definida
Implemente a função hasDefinedType, que verifica se um objeto tem uma propriedade type que não é undefined.
hasDefinedType({ type: undefined, color: 'red' });
// => false
hasDefinedType({ type: 'car', color: 'green' });
// => true
Exercício de aprendizagem
