En la computadora, el espacio de almacenamiento ocupado por diferentes datos es diferente.Para facilitar la división de los datos en datos con diferentes tamaños de memoria requeridos y aprovechar al máximo el espacio de almacenamiento, se definen diferentes tipos de datos.
En pocas palabras, un tipo de datos es un modelo de categoría de datos. Por ejemplo, el nombre es "Zhang San" y la edad es 18. Los tipos de estos datos son diferentes.
1.2 Tipos de datos de variables
Las variables son donde se almacenan los valores, tienen nombres y tipos de datos. El tipo de datos de una variable determina cómo se almacenan los bits que representan esos valores en la memoria de la computadora. JavaScript es un lenguaje débilmente tipado o dinámico. Esto significa que no es necesario declarar el tipo de la variable por adelantado, y el tipo se determinará automáticamente durante la ejecución del programa.
var age = 10; // 这是一个数字型
var areYouOk = '是的'; // 这是一个字符串
Cuando el código se está ejecutando, el motor JS juzga el tipo de datos de la variable de acuerdo con el tipo de datos del valor de la variable en el lado derecho de = Después de la ejecución, se determina el tipo de datos de la variable.
JavaScript tiene escritura dinámica, lo que también significa que la misma variable se puede usar como tipos diferentes:
JS tiene escritura dinámica, lo que también significa que la misma variable se puede usar como tipos diferentes La
misma variable se puede usar como tipos diferentes
var x = 6; // x 为数字
var x = "Bill"; // x 为字符串
JS divide los tipos de datos en dos categorías:
tipos de datos simples (Número, Cadena, Booleano, Indefinido, Nulo)
Tipos de datos complejos (objeto)
Número, S escucha, Booleano, Indefinido, Nulo
2.1 Tipos de datos simples (tipos de datos básicos)
Declaración indefinida El a la variable a no se le asigna un valor, en este momento a=indefinido
2.2 Número de tipo de número El tipo de número
de JavaScript se puede usar para almacenar tanto valores enteros como decimales (números de punto flotante).
var edad = 21; // Entero
var Edad = 21.3747; // Decimal
2.2 Número Número
- Bases numéricas
Las bases más comunes son binarias, octales, decimales y hexadecimales.
// 1.八进制数字序列范围：0~7
var num1 = 07; // 对应十进制的7
var num2 = 019; // 对应十进制的19
var num3 = 08; // 对应十进制的8
// 2.十六进制数字序列范围：0~9以及A~F
var num = 0xA;
var num=0xA; En esta etapa, solo necesitamos recordar que en JS, agregue 0 delante de octal y 0x delante de hexadecimal. En JS, agregue 0 delante de octal y 0x
delante de hexadecimal
. 2. Numérico range
in JavaScript Valor máximo y mínimo
alert(Number.MAX_VALUE); // 1.7976931348623157e+308
alert(Number.MIN_VALUE); // 5e-324
MAX_VALUE,
MIN_VALUE
valor máximo: Number.MAX_VALUE, este valor es: 1.7976931348623157e+308
Valor mínimo: Number.MIN_VALUE, este valor es: 5e-32
3. Tres valores especiales de tipo digital
alert(Infinity); // Infinity
alert(-Infinity); // -Infinity
alert(NaN); // NaN
alerta(Infinito)
alerta(-Infinito)Infinito
Infinito, que representa infinito, mayor que cualquier valor
-Infinito, que representa infinitamente pequeño, menor que cualquier valor
NaN, No es un número, representa un
NaN no numérico, No es un número que representa un no- numérico
4. isNaN( ) se
usa para determinar si una variable es de tipo no numérico, devuelve verdadero o falso
, inserta aquí la descripción de la imagen
var usrAge = 21;
var isOk = isNaN(userAge);
console.log(isNum); // false ，21 不是一个非数字
var usrName = "andy";
console.log(isNaN(userName)); // true ，"andy"是一个非数字
isNaN()
2.3 Tipo de cadena El tipo de cadena
puede ser cualquier texto entre comillas, su sintaxis es comillas dobles "" y comillas simples ''
var strMsg = "我爱北京天安门~"; // 使用双引号表示字符串
var strMsg2 = '我爱吃猪蹄~'; // 使用单引号表示字符串
// 常见错误
var strMsg3 = 我爱大肘子; // 报错，没使用引号，会被认为是js代码，但js没有这些语法
''Las comillas simples identifican cadenas
Debido a que los atributos en las etiquetas HTML usan comillas dobles, JS aquí recomendamos usar comillas simples.
- Cadena de comillas anidadas
JS Puede usar comillas simples para anidar comillas dobles, o usar comillas dobles para anidar comillas simples (externa doble interna simple, externa simple interna doble)
var strMsg = '我是"高帅富"程序猿'; // 可以用''包含""
var strMsg2 = "我是'高帅富'程序猿"; // 也可以用"" 包含''
// 常见错误
var badQuotes = 'What on earth?"; // 报错，不能 单双引号搭配
- Caracteres de escape de cadenas
Similares a los caracteres especiales en HTML, también hay caracteres especiales en las cadenas, que llamamos caracteres de escape.
Todos los caracteres de escape comienzan con \. Los caracteres de escape comúnmente utilizados y sus descripciones son las siguientes:
\b espacio\b espacio, ]t sangría,
mayúsculas y minúsculas: el cuadro de advertencia emergente de la página web
hace un calor insoportable, bajo el sol abrasador, me paro erguido y recta Se ha convertido en el paisaje más singular. Miro a mi alrededor, aquí está mi escenario, soy el rey del cielo y de la tierra. En este momento, fui tan arrogante que finalmente grité: "Consigue la basura~"
3. Longitud de la cuerda
Una cadena se compone de varios caracteres y el número de estos caracteres es la longitud de la cadena. La longitud de toda la cadena se puede obtener a través de la propiedad de longitud de la cadena.
var strMsg = "我是帅气多金的程序猿！";
alert(strMsg.length); // 显示 11
- Empalme
de cadenas Se pueden empalmar varias cadenas con +. El método de empalme es cadena + cualquier tipo = nueva cadena después
del empalme. Antes del empalme, cualquier tipo agregado a la cadena se convertirá en una cadena y luego se empalmará. Convierta cualquier tipo agregado por la antorcha a la cuerda antes de empalmarla en una nueva
cuerda y luego empalmarla en una nueva cuerda
//1.1 字符串 "相加"
alert('hello' + ' ' + 'world'); // hello world
//1.2 数值字符串 "相加"
alert('100' + '100'); // 100100
//1.3 数值字符串 + 数值
alert('11' + 12); // 1112
- Fórmula de resumen de números: agregar números, conectar caracteres
- Mejora de la concatenación de cadenas
console.log('pink老师' + 18); // 只要有字符就会相连
var age = 18;
// console.log('pink老师age岁啦'); // 这样不行哦
console.log('pink老师' + age); // pink老师18
console.log('pink老师' + age + '岁啦'); // pink老师18岁啦
A menudo concatenamos cadenas y variables, porque las variables pueden modificar fácilmente el valor que contienen.
Las variables no se pueden citar, porque las variables entrecomilladas se convertirán en cadenas.
Si hay cadenas en ambos lados de la variable, la fórmula " "Cita más más", elimine el y agregue la variable en el medio.
Si hay concatenaciones de cadenas en ambos lados de la variable, la fórmula es citar más más, eliminar el número y agregar la variable en el medio
. Este es un programa de efectos interactivos muy simple escrito en JS. Estudio de caso Tres elementos esenciales de la programación interactiva: ¿Te gusto? → Esta es la entrada del usuario La chica lo piensa → Este es el procesamiento interno del programa y finalmente te dio una bofetada → Este es el resultado de salida Entonces, ¿cómo implementarlo en el programa? Abra un cuadro de entrada (mensaje), deje que el usuario ingrese la edad (entrada del usuario) , guarde el valor ingresado por el usuario en una variable, empalmando la edad recién ingresada con la cadena que se va a generar (procesamiento interno del programa) Uso la declaración de alerta para mostrar un cuadro de alerta (resultado de salida)
// Aparece un cuadro de entrada (solicitud), que permite al usuario ingresar la edad (entrada del usuario)
// Guarda el valor ingresado por el usuario en una variable, y empalma la edad recién ingresada con la cadena que se generará (procesamiento interno en el programa)
// Usar La declaración de alerta muestra un cuadro de alerta (resultado de salida)
var edad = aviso('Ingrese su edad');
var str = 'Eres este año' + edad + 'Eres viejo';
alert(str);
2.5 Boolean Boolean
El tipo booleano tiene dos valores: verdadero y falso, donde verdadero significa verdadero (verdadero) y falso significa falso (falso).
Al agregar un valor booleano y un número, el valor de verdadero es 1 y el valor de falso es 0.
console.log(true + 1); // 2
console.log(false + 1); // 1
2.6 Indefinido y nulo
Una variable a la que no se le asigna un valor después de la declaración tendrá un valor predeterminado de indefinido (si está conectada o agregada, preste atención al resultado)
.Una variable a la que no se le asigna un valor después de la declaración tendrá un valor predeterminado de indefinido si esta conectado o agregado, presta atención a los resultados
var variable;
console.log(variable); // undefined
console.log('你好' + variable); // 你好undefined
console.log(11 + variable); // NaN
console.log(true + variable); // NaN
Se declara una variable para valor nulo y el valor almacenado en ella está vacío (al aprender objetos, continuamos estudiando nulo)
Se declara una variable para valor nulo y el valor almacenado en ella está vacío
var vari = null;
console.log('你好' + vari); // 你好null
console.log(11 + vari); // 11
console.log(true + vari); // 1
A una variable declarada se le da un valor nulo, y el valor almacenado en ella está vacío. Cuando aprendemos objetos, continuamos estudiando nulo
3.1 Obtener el tipo de datos de la variable detectada
typeof se puede utilizar para obtener el tipo de datos de la
variable detectada typeof se puede utilizar para obtener el tipo de datos de la variable detectada
var num = 18;
console.log(typeof num) // 结果 number
var num=18
console.log(typedef num)
valores devueltos de diferentes tipos
Number typedef 18
Boolea typedef true
typedef null object
typedef null object
3.2 Literal
Un literal es una representación de un valor fijo en el código fuente Cantidad significa cómo expresar este valor
Literal significa cómo expresar este valor
La cantidad literal es la notación de un valor fijo en el código fuente.
Literales numéricos: 8, 9, 10 Literales de
cadena: 'Dark Horse Programmer', "big front end"
Literales booleanos: verdadero, falso
4.1 ¿Qué es la conversión de tipos de datos?
Los datos obtenidos mediante el formulario y el indicador son de tipo cadena por defecto. En este momento, la operación de adición no se puede realizar de forma directa y sencilla, y es necesario convertir el tipo de datos de la variable. En términos sencillos, es convertir una variable de un tipo de datos a otro tipo de datos.
Por lo general, implementamos tres tipos de conversión:
conversión a tipo de cadena
, conversión a tipo numérico,
conversión a tipo booleano,
utilizando el formulario, los datos obtenidos por solicitud son de tipo cadena de forma predeterminada y
convertidos a tipo de cadena, tipo numérico y tipo booleano
4.2 Convertir a cadena
toString(), String(num); Signo más empalme de cadenas y cadenas criticar los resultados de su hermana son cadenas, var num=1;alert(num+"Soy una cadena");
toString() A diferencia del uso de String() .
Tres métodos de conversión, preferimos usar el tercer método de conversión de cadenas concatenadas con signo más, que también se denomina conversión implícita.
4.3 Convertir a tipo numérico (énfasis)
js conversión implícita-*/
Use la operación aritmética para convertir implícitamente a tipo numérico,
preste atención a las mayúsculas de las palabras parseInt y parseFloat, estas dos son la clave.
La conversión implícita es cuando realizamos operaciones aritméticas , JS convierte automáticamente el tipo de datos
La conversión implícita es cuando realizamos operaciones aritméticas, JS lo convierte automáticamente en un tipo de datos
Caso 1: Calcular edad
Este caso requiere que aparezca un cuadro de entrada en la página. Después de ingresar el año de nacimiento, podemos calcular a partir de nuestra edad.
Estudio de caso Aparece
un cuadro de entrada (mensaje) que permite al usuario ingresar el año de nacimiento (entrada del usuario)
Guarde el valor ingresado por el usuario en una variable, y luego reste el valor de la variable del año de este año. El resultado es la edad actual (procesamiento interno del programa).
Aparecerá un cuadro de alerta (alerta), y el se emitirá el resultado del cálculo (resultado de salida)
// 1. 弹出输入框，输入出生年份，并存储在变量中
var year = prompt('请输入您的出生年份：'); // 用户输入
// 2. 用今年减去刚才输入的年份
var result = 2019 - year; // 程序内部处理
// 3. 弹出提示框
alert('您的年龄是:' + result + '岁'); // 输出结果
Caso 2: sumador simple
Calcule el valor de dos números, después de que el usuario ingrese el primer valor, continúe abriendo el segundo cuadro de entrada e ingrese el segundo valor, y finalmente muestre el resultado de sumar los dos valores de entrada a través de la ventana emergente.
Primero, aparece el primer cuadro de entrada, que le pide al usuario que ingrese el primer valor y lo guarde,
y luego aparece el segundo cuadro, que le pide al usuario que ingrese el segundo valor, lo guarde
, agregue los dos valores y asigne el resultado. a una nueva variable (Preste atención a la conversión del tipo de datos)
aparece un cuadro de alerta (alerta) y genera el resultado del cálculo (resultado de salida)
// 1. 先弹出第一个输入框，提示用户输入第一个值
var num1 = prompt('请输入第一个值：');
// 2. 再弹出第二个框，提示用户输入第二个值
var num2 = prompt('请输入第二个值：');
// 3. 将输入的值转换为数字型后，把这两个值相加，并将结果赋给新的变量
var result = parseFloat(num1) + parseFloat(num2);
// 4. 弹出结果
alert('结果是:' + result);
var result=parseFloat(num1)+parseFloat(num2);
4.4 Convert to Boolean
Boolean('true')
"",0,NaN,null,indefined,"",0,NaN,nunll,undefined
representa vacío, negativo El valor se convertirá en falso, como '', 0, NaN, nulo, indefinido
y el resto de los valores se convertirán en verdadero
console.log(Boolean('')); // false
console.log(Boolean(0)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean('小白')); // true
console.log(Boolean(12)); // true