1. Clasificación
Tipos de datos básicos: indefinido, nulo, cadena, booleano, número
Tipo de datos complejo: objeto
El atributo del objeto se define en forma de un par de nombre y valor desordenado (nombre: valor).
2. Explicación detallada
1. Undefinado : el tipo indefinido tiene solo un valor: indefinido. Cuando una variable se declara usando VAR pero no se inicializa, el valor de esta variable está indefinido.
Las variables que contienen valores indefinidos son diferentes de las variables que no se han definido. El siguiente ejemplo puede ilustrar:
La copia del código es la siguiente:
var demo1; // declarado pero no inicializado
alerta (demo1); // indefinido
alerta (demo2); // Informar un error, Demo2 no está definido
2. NULL : Solo hay un valor para el tipo nulo: NULL. Desde un punto de vista lógico, el valor nulo representa un puntero de objeto vacío.
Si la variable definida está lista para usarse para guardar el objeto en el futuro, es mejor inicializar la variable a NULL en lugar de otros valores. De esta manera, simplemente detectando directamente el valor nulo, puede saber si la variable correspondiente ha guardado la referencia de un objeto, por ejemplo:
La copia del código es la siguiente:
if (coche! = nulo)
{
// realizar algunas operaciones en el objeto del automóvil
}
De hecho, los valores indefinidos se derivan de valores nulos, por lo que ECMA-262 especifica que sus pruebas de igualdad deberían devolver verdaderas.
alerta (indefinido == nulo); //verdadero
Aunque NULL e indefinido tienen tal relación, sus usos son completamente diferentes. En cualquier caso, no es necesario establecer explícitamente el valor de una variable a indefinido, pero la misma regla no se aplica a NULL. En otras palabras, siempre que la variable pretendida para guardar el objeto aún no haya guardado el objeto, la variable debe permitirse explícitamente para guardar el valor nulo. Hacerlo no solo refleja la convención de NULL como un puntero para objetos nulos, sino que también ayuda a distinguir aún más entre nulo y indefinido.
3. Booleano : el tipo booleano tiene dos valores: Verdadero y Falso. Estos dos valores no son lo mismo que los valores numéricos, por lo que verdadero no necesariamente es igual a 1, y False no necesariamente es igual a 0.
Cabe señalar que los valores literal del tipo booleano son sensibles a los casos, es decir, ni verdaderos ni falsos (y otras formas de mezcla de casos) son valores booleanos, pero son solo identificadores.
Aunque solo hay dos valores literales para los tipos booleanos, todos los tipos de valores en JavaScript tienen valores equivalentes a los de estos dos valores booleanos. Para convertir un valor a su valor booleano correspondiente, puede llamar a la función de conversión de tipo boolean (), por ejemplo:
La copia del código es la siguiente:
Var Message = 'Hello World';
var MessageAsBoolean = boolean (mensaje);
En este ejemplo, el mensaje de cadena se convierte en un valor booleano, que se almacena en la variable MessageAsboolean. La función boolean () se puede llamar a los valores de cualquier tipo de datos y siempre se devolverá un valor booleano. En cuanto a si el valor devuelto es verdadero o falso, depende del tipo de datos para convertir el valor y su valor real. La siguiente tabla muestra las reglas de conversión para varios tipos de datos y sus objetos.
Estas reglas de conversión son muy importantes para comprender la ejecución automática de las transformaciones booleanas correspondientes en las declaraciones de control de flujo (como las declaraciones), por ejemplo:
La copia del código es la siguiente:
Var Message = 'Hello World';
if (mensaje) // equivalente a if (boolean (mensaje) == true)
{
alerta ("el valor es verdadero"); // El valor es verdadero
}
Debido a esta transformación booleana automática, es crucial saber exactamente qué variables se utilizan en la declaración de control de flujo.
4. Número: entero y punto flotante
4.1 Integer: Al realizar cálculos, todos los números octales y hexadecimales se convertirán en decimal
4.2 Punto flotante: La mayor precisión de un valor de punto flotante es de 17 bits, por lo que su precisión es mucho menor que la de un entero al calcular la aritmética. Por ejemplo: el resultado de 0.1+0.2 no es 0.3, sino 0.300000000000000000000004. Por ejemplo:
La copia del código es la siguiente:
a = 0.2;
b = 0.1;
if (a+b == 0.3) {
alerta ("hola");
}
demás{
alerta ("hola");
}
El resultado aparecerá "Hola", así que no pruebe un valor de punto flotante específico.
4.3 NAN: no numérico no es un número, este valor se usa para representar un caso en el que un operando que originalmente quería devolver un valor no devolvió un valor (esto no arrojará un error).
Nan en sí tiene dos características extraordinarias. Primero, cualquier operación que involucre NAN (por ejemplo, NAN/10) devolverá NAN, una característica que puede causar problemas en los cálculos de múltiples pasos. En segundo lugar, Nan no es igual a ningún valor, incluida la propia Nan. Por ejemplo:
La copia del código es la siguiente:
alerta (nan == nan); //FALSO
Hay una función ISNAN () en JavaScript. Esta función acepta un parámetro, que puede ser de cualquier tipo, y la función nos ayudará a determinar si este parámetro "no es un valor numérico". Después de recibir un valor, ISNAN () intenta convertir este valor a un valor numérico. Algunos valores que no son valores numéricos se convierten directamente en valores numéricos, como la cadena "10" o los valores booleanos. Cualquier valor que no pueda convertirse a un valor numérico hará que esta función devuelva verdadera. Por ejemplo:
La copia del código es la siguiente:
alerta (isnan (nan)); //verdadero
alerta (isnan (10)); // falso (10 es un valor numérico)
alerta (isnan ("10")); // falso (puede convertirse en valor numérico 10)
alerta (isnan ("azul")); // Verdadero (no se puede convertir en valor numérico)
alerta (isnan ("bule123")); // ture (no se puede convertir en valor numérico)
alerta (isnan (verdadero)); // falso (puede convertirse en un valor de 1)
Hay 3 funciones que pueden convertir los valores no numéricos en valores numéricos: número (), parseInt () y parsefloat (). La primera función, a saber, el número de función de transformación (), puede usarse para cualquier tipo de datos, mientras que las otras dos funciones se usan específicamente para convertir las cadenas en valores numéricos. Estas 3 funciones devolverán diferentes resultados para la misma entrada.
Las reglas de conversión de la función Número () son las siguientes:
● Si se trata de un valor booleano, verdadero y falso será reemplazado por 1 y 0 respectivamente.
● Si es un valor numérico, es solo un simple pase y retorno.
● Si es un valor nulo, devuelva 0
● Si no se define, devuelve nan
● Si es una cadena, siga las siguientes reglas:
○ Si la cadena contiene solo números, conviértelo a un valor decimal, es decir, "1" se convertirá en 1, "123" se convertirá en 123 y "011" se convertirá en 11 (el 0 líder se ignora)
○ Si la cadena contiene un formato de punto flotante válido, como "1.1", se convierte en el número de punto flotante correspondiente (también, 0 liderazgo será ignorado)
○ Si la cadena contiene un formato hexadecimal válido, como "0xf", se convierte en un valor entero decimal del mismo tamaño
○ Si la cadena está vacía, conviértala a 0
○ Si la cadena contiene caracteres distintos del formato anterior, conviértalos en NAN
● Si se trata de un objeto, llame al método ValueOf () del objeto y luego convierta el valor devuelto de acuerdo con las reglas anteriores. Si el resultado de la conversión es NAN, se llama al método toString () del objeto, y luego el valor de cadena devuelto se convierte a su vez de acuerdo con las reglas anteriores.
La copia del código es la siguiente:
var num1 = número ("hola mundo"); //Yaya
var num2 = número (""); // 0
var num3 = número ("000011"); // 11
var num4 = número (verdadero); // 1
Dado que la función número () es más complicada e irracional al convertir cadenas, la función parseInt () se usa más comúnmente cuando se procesa enteros, y la función parsefloat () a menudo se usa al procesar números de puntos flotantes. Para más detalles, consulte: http://www.cnblogs.com/yxfield/p/4167954.html
5. Cadena
El tipo de cadena se usa para representar una secuencia de caracteres compuestos por cero o más caracteres Unicode de 16 bits, es decir, una cadena. Una cadena puede representarse mediante cotizaciones individuales (') o cotizaciones dobles (").
La copia del código es la siguiente:
var str1 = "hola";
var str2 = 'hola';
La longitud de cualquier cadena se puede obtener accediendo a su propiedad de longitud.
La copia del código es la siguiente:
alerta (str1.length); // Salida 5
Hay dos formas de convertir un valor en una cadena. El primero es usar el método ToString () que tiene casi todos los valores.
La copia del código es la siguiente:
VAR Age = 11;
var ageASString = Age.ToString (); // cadena "11"
var encontrado = verdadero;
var FoundasString = Found.ToString (); // cadena "verdadero"
Todos los valores numéricos, booleanos, de objeto y de cadena tienen métodos toString (). Pero los valores nulos e indefinidos no tienen este método.
En la mayoría de los casos, llamar al método ToString () no tiene que pasar los parámetros. Sin embargo, al llamar al método toString () del valor numérico, puede pasar un parámetro: la cardinalidad del valor de salida.
La copia del código es la siguiente:
var num = 10;
alerta (num.ToString ()); // "10"
alerta (num.ToString (2)); // "1010"
alerta (num.ToString (8)); // "12"
alerta (num.ToString (10)); // "10"
alerta (num.ToString (16)); //"a"
A partir de este ejemplo, podemos ver que al especificar la cardinalidad, el método ToString () cambiará el valor de salida. El valor 10 se puede convertir a diferentes formatos numéricos al emitir de acuerdo con la cardinalidad diferente.
Sin saber si el valor a convertir es nulo o indefinido, también puede usar la función de transformación String (), que puede convertir cualquier tipo de valor en una cadena. La función String () sigue las siguientes reglas de conversión:
● Si el valor tiene un método toString (), se llama el método (sin parámetros) y se devuelve el resultado correspondiente.
● Si el valor es nulo, devuelva "nulo"
● Si el valor está indefinido, devuelva "indefinido"
6. Objeto
Los objetos son en realidad una recopilación de datos y funciones. Los objetos se pueden crear ejecutando el nuevo operador seguido del nombre del tipo de objeto que se creará. Al crear una instancia de objeto tipo y agregar propiedades y (o) métodos, puede crear un objeto personalizado.
var o = nuevo objeto ();
Cualquier propiedad y método del tipo de objeto también existen en objetos más específicos. Cada instancia del objeto tiene las siguientes propiedades y métodos:
● Constructor (constructor): guarda la función utilizada para crear el objeto actual
● UsownProperty (Propertyname): se usa para verificar si la propiedad dada existe en la instancia de objeto actual (no en el prototipo de la instancia). Donde, el nombre de la propiedad (PropertyName) como el parámetro debe especificarse en un formulario de cadena (por ejemplo: O.HasownProperty ("Nombre"))
● ISPrototypeOF (Object) - Se utiliza para verificar si el objeto entrante es un prototipo de otro objeto
● PropertyIsEnumerable (Propertyname): se utiliza para verificar si una propiedad determinada puede enumerarse utilizando la instrucción FOR -In.
● toString () - Devuelve la representación de cadena del objeto
● ValueOf () - Devuelve la cadena del objeto, la representación numérica o booleana. Por lo general, el valor de retorno del método toString () es el mismo.
3. Prueba pequeña
La copia del código es la siguiente:
Typeof (nan)
typeof (infinito)
Typeof (nulo)
typeof (indefinido)
Muchas entrevistas harán las preguntas anteriores ~~
Lo anterior es una introducción a estos 6 tipos de datos de JavaScript. ¿Lo has entendido claramente? Espero que puedas mejorar después de leer este artículo.