Recentemente, fiz um projeto que envolva o processamento de JS para determinar os tipos de dados, pesquisar informações relevantes on -line e testei pessoalmente o julgamento de vários tipos de dados, o que é absolutamente seguro. Abaixo, o editor compartilhará o conteúdo específico com você para sua referência!
1. Tipos de dados em JS
1. Tipo numérico (número): inclui números inteiros e pontos flutuantes.
2. Booleano
3. Tipo de string
4. Objeto
5.Array
6. Valor NULL (NULL)
7. indefinido
2. Determine o tipo de dados de uma variável
1. Tipo de número (número)
Os métodos de julgamento mais usados são:
função isNumber (val) {return typeof val === 'número';}Mas algumas situações não funcionam, como:
var a; alerta (isNumber (parseint (a)));
O que aparece aqui é verdade, como mostrado na figura abaixo:
Mas, de fato, a variável A é NAN, que não pode ser usada para operações numéricas.
Portanto, a função acima pode ser modificada para:
função isNumber (val) {return typeof val === 'número' && isfinite (val);}Após a modificação, False aparece, conforme mostrado na figura abaixo:
A propósito, a função JavaScript isfinite () é usada para verificar se seus parâmetros são infinitos. Se o número for um número finito (ou pode ser convertido em um número finito), retornará true. Caso contrário, se o número for NAN (não-número) ou um número de infinito positivo ou negativo, False for retornado.
2. Booleano
O julgamento do tipo booleano é relativamente simples e você pode usar o seguinte método para fazer julgamentos:
/*Julgue se a variável val é um tipo booleano*/função isBooleAntype (val) {return typeof val === "boolean";}Código de teste:
<script type = "text/javascript">/*julgue se a variável val é um tipo booleano*/função isBooleArtype (val) {return typeof val === "boolean";} var a; var b = false; alert ("o resultado da variável a é um tipo boolean é:"+isoLtyPePe (a) é um tipo de alerta (a), o tipo de alerta (a) é um tipo de alerta (a), o tipo de alerta é um tipo de alerta; "+isBooleAntype (b)); </sCript>Resultados em execução:
3. String
O julgamento do tipo de string é relativamente simples e você pode usar o seguinte método para fazer julgamentos:
/*Julgue se a variável é um tipo de string*/função ISSTRINGTYPE (VAL) {return typeof val === "String";}Código de teste:
<script type = "text/javascript">/*julga se a variável é um tipo de string*/função isstringType (val) {return typeof val == "string";} var a; var s = "strtype"; alert ("o resultado da variável a é um tipo de string é:"+IsStringType (a); "+ISSTRINGTYPE (S)); </script>Resultados em execução:
4. Indefinido
Os julgamentos indefinidos são relativamente simples e podem ser julgados pelo seguinte método:
/*Julgue se a variável é indefinida*/função isundefined (val) {return typeof val === "indefinido";}Código de teste:
<script type = "text/javascript"> var a; // a é indefinido s = "strtype";/*julga se a variável é indefinida*/função isundefined (val) {retorno tipo de val === "indefinido";} alert ("o resultado da variável a é definido:" IsuNDEFFINIFINEFINIFINENTE "; "+isundefined (s)); </sCript>Resultados em execução:
5. Objeto
Como quando a variável é nula, o TypeOf também retornará objeto, o objeto não pode ser julgado diretamente com o tipo de.
Deve ser assim:
função isobj (str) {if (str === null || typeof str === 'indefinido') {return false;} return typeof str === 'objeto';}Código de teste:
<script type = "text/javascript">/*julgue se a variável é o tipo de objeto*/função isobj (str) {if (str === null || typeof str === 'undefined') {return false;} typeof str == 'objeto';} var a; var b = null; var c = "str"; nulo, tipo de B === 'objeto' '' O resultado do julgamento é: "+(tipo de b === 'objeto')); alerta (" o resultado do julgamento da variável a é o tipo de objeto: "+isobj (a)); // falsEalert (" o resultado do julgamento da variável b é o tipo de objeto: "+isobj (b)); // "+isobj (c)); // falsEalert (" O resultado do julgamento da variável d é o tipo de objeto: "+isobj (d)); // truealert (" o resultado do julgamento da variável e é o tipo de objeto: "+isobj (e)); // true </sCript>Resultados em execução:
6. Valor NULL (NULL)
Basta usar Val === NULL para determinar o valor nulo
função isnull (val) {return val === null;}Código de teste:
/*Julgue se a variável é nula*/função isNull (val) {return val === null;}/*teste variável*/var a; var b = null; var c = "str"; // apareça o resultado do resultado do julgamento: "o julgamento do julgamento da variável a é nulo:"+isnull (a); "+isnull (b)); // truealert (" O resultado do julgamento da variável c é o tipo nulo é: "+isnull (c)); // falseResultados em execução:
7.Array
O tipo de matriz não pode ser julgado pelo tipoof. Porque quando a variável é um tipo de matriz, o tipo de retornará objeto.
Aqui estão duas maneiras de determinar o tipo de matriz:
/*Julgue se a variável arr é um método de matriz 1*/função isarray (arr) {return object.prototype.tostring.apply (arr) === '[matriz de objeto]';}/*julga se a variável retraf é um método de matriz 2*/function isarray (arr) {if (arr === null | === Array;}Código de teste:
<script type = "text/javascript">/*julgue se a variável arr é um método de matriz 1*/função isarray (arr) {return object.prototype.toString.Apply (ARR) ==== '[Array de objeto]';}/*julga se a variável ARR é um método de Array 2*/function isarray (ARR) {{{ 'Undefinido') {return false;} return arr.Constructor === Array;} // Variável de teste var a = null; var b = ""; var c; var arr = [,,]; var arr = new Array (); // imprima o resultado do resultado. 'objeto')); document.write ("<br/>"); document.write ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- t.Write ("<br/>"); document.Write ("O resultado do julgamento de que a variável A é um tipo de matriz é:"+isarray (a)); document.write ("<br/>"); document.write ("o resultado do julgamento que a variável b é um tipo de matriz é:"+isarray (b)); Classe O resultado do julgamento do tipo é: "+isarray (c)); document.write (" <br/> "); document.write (" o resultado do julgamento de variável ser um tipo de matriz é: "+isarray (arr)); document.write (" <br/> "); document. item ("<br/>"); document.write ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Ent.Write ("O resultado do julgamento da variável A é um tipo de matriz é:"+isarray (a)); document.write ("<br/>"); document.write ("O resultado do julgamento da variável b é um tipo de matriz é:"+isarray (b)); document ("<br/>"); "+isarray (c)); document.write (" <br/> "); document.write (" o resultado do julgamento de que a variável arr é um tipo de matriz é: "+isarray (arr)); document.write (" <br/> "); "+isarray (arr)); document.write (" <br/> "); </script>Resultados em execução:
O conteúdo acima é o resumo dos pontos de conhecimento JavaScript (VI) dos tipos de dados variáveis de julgamento de JavaScript. Espero que seja útil para todos. Se você quiser saber mais, preste atenção no site do Wulin.com!