Hola a todos, ¿les gustaría compartir con ustedes cuáles son las reglas de nomenclatura para los identificadores js? Intente resumirlo, mucha gente aún no lo sabe. Te lo explicamos detalladamente a continuación. ¡Ahora echemos un vistazo!
Comentario
// 单行注释 快捷键：ctrl+/
/**
* 多行注释
* 快捷键：shift+alt+A
*/identificador
Los identificadores se refieren a nombres de variables, matrices, funciones, etc. Definir un identificador es el proceso de tomar un nombre . Deepl reduce el peso .
Reglas de nomenclatura para identificadores:
Requisitos estrictos:
- Números, letras, guiones bajos, $
- No se puede comenzar con un número o dígito puro
- Estrictamente entre mayúsculas y minúsculas
Requisitos blandos: conozca el significado viendo el nombre, no se pueden utilizar palabras clave, palabras reservadas, etc.
Cómo nombrar identificadores:
Nomenclatura de serpientes, conectada por guiones bajos: por ejemplo - login_id
Nomenclatura del caso Camel: 1. Joroba pequeña: por ejemplo - loginId 2. Joroba grande: LoginId
variable
Una variable es un contenedor que almacena datos y los datos que contiene pueden cambiar en cualquier momento.
donde (ES5)
1. Sin alcance a nivel de bloque
2. Las declaraciones se pueden omitir
3. Las variables se pueden mejorar.
Se puede utilizar antes de la declaración, pero se imprime como indefinido.
dejar (ES6)
Declarar variables ordinarias: si la variable se declara sin asignar un valor, no está definida;
Let no puede declarar variables repetidamente, pero se pueden reasignar y no se pueden usar antes de la declaración.
let tiene alcance a nivel de bloque: {let a = 10}, en este momento a solo se puede usar entre llaves
Se pueden declarar varias variables a la vez, separadas por comas, similar al selector de unión en CSS.
constante
constante (ES6)
característica:
- Para valores simples, no se pueden cambiar;
- Para valores complejos, se pueden modificar sin cambiar la referencia;
- A las variables declaradas como constantes se les debe asignar un valor.
tipo de datos
Cada valor en JS debe pertenecer a un determinado tipo de datos. Utilice typeof ----- para verificar el tipo de datos.
Tipos de datos básicos
Los tipos de datos básicos también se denominan: tipos de datos primitivos || valores simples
| Tipos de datos básicos | ilustrar | valor por defecto |
|---|---|---|
| indefinido | indefinido | indefinido |
| nulo | nulo | nulo |
| número | número | 0 |
| booleano | Booleano | FALSO |
| cadena | cadena | " " |
| símbolo (ES6) | símbolo |
número de tipo numérico
1. Entero
let a = 10;2. Números de coma flotante
let b = 1.2;
let c = 1.3;
let d = b + c;3. Valor máximo y valor mínimo
console.log(Number.MAX_VALUE);
console.log(Number.MAX_VALUE);4, Mugidai
console.log(Number.MAX_VALUE*2);// 会得到 Infinity 无穷大5. NaN = no es un número
Características:
- Un no número no es igual a ningún valor, incluido él mismo;
- Su tipo de datos es número;
- Los cálculos que involucran NaN solo producirán NaN.
Tipo de cadena
Comillas simples'' (recomendado)
Doble comillas""
``Las nuevas características de la plantilla de cadena de ES6: 1. Admite texto de varias líneas; 2. Realiza análisis de variables
1. Preste atención al anidamiento de las comillas, puede utilizar diferentes comillas para distinguirlas.
let str = '他说：“好好学习天天向上！”';
console.log(str);2. El carácter de escape \ se escribe delante del símbolo.
let str2 = '他说：\'好好学习天天向上！\'';
console.log(str2);3. Salto de línea\n = nueva línea
let str3 = '好好学习，\n天天向上';
console.log(str3);4. Comprueba la longitud de la cuerda.
let str4 = '好好学习 天天向上'; // 长度为9，一个空格字符也算一个长度
console.log(str4.length);5. Empalme de cadenas +, las cadenas y cualquier empalme de valores se convertirán en cadenas
console.log('好好学习'+'天天向上');
console.log('学习'+666); 6. Nueva plantilla de cadena de ES6 ``: puede ingresar texto en ella y las variables de entrada deben estar empaquetadas con ${}
Características:
1. Admite texto de varias líneas;
2. Realizar análisis de variables;
let str5 = `0糖
0卡
0脂肪`;
console.log(str5);
let age = 18;
console.log(`我今年${age-2}岁`);// 打印 我今年16岁，可以直接在{}里面进行运算tipo booleano booleano
Booleano verdadero (verdadero) y falso (falso), cualquier tipo de datos se puede convertir a tipo booleano.
Devolverá falso en booleano:
-
Cadena vacía, que incluye '', "", plantilla de cadena``
-
0
-
Yaya
-
FALSO
-
nulo
-
indefinido
indefinido indefinido
Indefinido: indefinido ocurre cuando no se asigna ningún valor cuando se declara.
Volverá indefinido:
-
Acceder a variables no asignadas ----- Ejemplo: let a;
-
Cualquier variable que tenga un valor indefinido ----- Ejemplo: let a = indefinido;
-
Una función sin una expresión de retorno implícitamente devolverá undefinido ----- Ejemplo: función foo(){}
-
La expresión de retorno no devuelve nada explícitamente ----- Ejemplo: función foo(){ return;}
-
Acceder a atributos inexistentes ----- Ejemplo: zhangsan.girlfriend
valor nulo nulo
let space = null;
console.log(null == undefined);// true
console.log(typeof space);// 查看null的数据类型时得到的是 object
let a1 = '10',a2 = 10;
console.log(a1==a2);//返回true ,不精确比较：只比较值，不比较数据类型
console.log(a1===a2);//返回false, 精确比较：值和数据类型都一样才返回true
console.log(null+'aaa');// 返回nullaaa
console.log(null+1);// 返回1La diferencia entre indefinido y nulo:
indefinido significa valor faltante;
null generalmente se usa para liberar memoria y se trata como 0 durante los cálculos.
Tipo de datos de referencia
Los tipos de datos de referencia también se denominan tipos de datos sintéticos || valores complejos
- objeto Objeto
Conversión de tipo de datos
La conversión de tipos se divide en: conversión implícita y conversión explícita.
1. Conversión implícita:
Es una conversión que ocurre automáticamente dentro del sistema, generalmente cuando se realizan operaciones sobre diferentes tipos de datos:
-
Compara diferentes tipos de datos
-
Realizar operaciones en diferentes tipos de datos.
-
Evaluar valores booleanos para valores no booleanos
2. Conversión forzada:
Si no desea que un número cambie, puede dejarlo participar en los cálculos, -0, *1, etc., o puede agregar ~~ al frente para convertirlo en un número.
Las conversiones forzadas se dividen en tres categorías principales: el código de muestra es el siguiente:
// 一：转换成字符串
// 1、转换成字符串型 变量.toString()
let num = 10;
let str6 = num.toString();
console.log(typeof str6);
// 2、强制转换 String()
console.log(String(num));
// 3、利用 + 做字符串拼接转换，和字符串拼接的结果都是字符串
console.log(111+'');// 转换成功，打印为111字符串
// 二：转换成数字型
// 1、parseInt() 转换成整数 遇到了第一个非数字时就返回NaN，遇到了一个其他字符就返回前面的整数
let age1 = '18';
console.log(parseInt(age1)); // 打印18
console.log(parseInt(3.14));// 打印3
console.log(parseInt('314abc'))// 打印314
console.log(parseInt('abc314')); // 打印 NaN
//2、parseFloat() 转换成浮点数 遇到了第一个非数字时就返回NaN，遇到了一个其他字符就返回前面的小数
console.log(parseFloat('3.14'));// 打印3.14
console.log(parseFloat('3.a4'));// 打印3
console.log(parseFloat('3.14abc'));// 打印3.14
console.log(parseFloat('abc3.14'));// 打印NaN
console.log(parseFloat('3.14.256a'));// 打印3.14
console.log(parseFloat('3.1a4.256'));// 打印3.1
//3、Number() 这个方法做整体转换，只要有其他字符则返回 NaN
let str7 = '123';
console.log(Number(str7));
console.log(Number(123.4));// 打印123.4
console.log(Number('123.4'));// 打印123.4
console.log(Number('123.4a'));// 打印NaN
console.log(Number('abc123.4a'));// 打印NaN
//4、利用算数运算转换 - * / 注意：没有+运算，因为+是字符串拼接
console.log('2' * 5);// 打印10
console.log('2' * '5');// 打印10
console.log('10' / 5);// 打印2
console.log('2' - 5);// 打印-3
// 三：转换成布尔型
console.log(Boolean(0));// 打印false
console.log(Boolean(' '));// 打印true
console.log(Boolean('0'));// 打印true
console.log(Boolean(null));// 打印false
console.log(!!null);// 打印false
console.log(Boolean(undefined));// 打印false
console.log(Boolean(NaN));// 打印falseMétodo .toFixed()
Escribe los decimales entre paréntesis:
Característica 1: el recuento de resultados es de tipo cadena.
Característica 2: Se pueden conservar los siguientes dígitos.
operador
1. Clasificación por número de operaciones
-
Operador unario ----- Ejemplo: tipo de
-
Operador binario-----Ejemplo: */
-
Operador ternario-----Ejemplo: operador ternario
2. Clasificación por uso
operadores aritméticos
| operador | describir | Ejemplo |
|---|---|---|
| + | operador de suma | x + y significa calcular la suma de x más y |
| - | operador de resta | x - y significa calcular la diferencia de x menos y |
| * | operador de multiplicación | x * y significa calcular el producto de x por y |
| / | operador de división | x/y significa calcular el cociente de x dividido por y |
| % | Operador de módulo (resto) | x % y significa calcular el resto de x dividido por y |
| ** | símbolo de poder | x ** 3 = x elevado a la 3ª potencia, x ** 4 es igual a x elevado a la 4ª potencia |
Operadores de incremento y decremento
La diferencia entre antes y después :
++ está al frente, se incrementa primero y luego participa en la operación; ++ está atrás, participa en la operación y luego se incrementa
-- En el frente, disminuya primero y luego participe en la operación; -- En la parte de atrás, participe primero en la operación y luego disminuya
| operador | nombre | |
|---|---|---|
| ++yo | operador incremental | Suma 1 a i y devuelve el valor de i |
| yo ++ | operador incremental | Devuelve el valor de i, luego incrementa i en 1 |
| --i | Operador de decremento | Disminuye i en 1 y devuelve el valor de i |
| i-- | Operador de decremento | Devuelve el valor de i, luego disminuye i en 1 |
operador de asignación
| operador | describir | Ejemplo |
|---|---|---|
| = | Asigne el valor en el lado derecho del operador a la variable en el lado izquierdo del operador | x = 10 significa asignar la variable x a 10 |
| += | Primero realice la operación de suma y luego asigne el resultado a la variable en el lado izquierdo del operador | x += y es equivalente a x = x + y |
| -= | Primero realice la operación de resta y luego asigne el resultado a la variable en el lado izquierdo del operador | x -= y es equivalente a x = x - y |
| *= | Primero realice la operación de multiplicación y luego asigne el resultado a la variable en el lado izquierdo del operador | x *= y es equivalente a x = x * y |
| /= | Primero realice la operación de división y luego asigne el resultado a la variable en el lado izquierdo del operador. | x /= y es equivalente a x = x / y |
| %= | Primero realice la operación de módulo y luego asigne el resultado a la variable en el lado izquierdo del operador. | x %= y es equivalente a x = x % y |
Operadores de cadena
Además de realizar operaciones de atributos, los operadores + y += en JS también se pueden utilizar para unir cadenas:
-
+El operador significa empalmar las cuerdas en los lados izquierdo y derecho del operador; -
+=El operador significa concatenar cadenas primero y luego asignar el resultado a la variable en el lado izquierdo del operador.
Operadores relacionales (comparación)
Aviso:
1. Al comparar caracteres con caracteres, compare según el código ASCll.
2. Cuando hay números presentes, se da prioridad a convertirlos en números al comparar.
3. Dado que las cadenas no se pueden convertir en números, se devolverá NaN, por lo que el resultado de la comparación siempre será falso.
| operador | nombre | Ejemplo |
|---|---|---|
| > | más que el | x > y significa verdadero si x es mayor que y |
| < | menos que | x < y significa verdadero si x es menor que y |
| >= | mayor o igual a | x >= y significa verdadero si x es mayor o igual que y |
| <= | Menos que o igual a | x <= y significa verdadero si x es menor o igual que y |
| == | igual | x == y significa verdadero si x es igual a y |
| === | Todos iguales (comparación exacta) | x === y significa verdadero si x es igual a y y xey también son del mismo tipo |
| != | no igual a | x != y significa verdadero si x no es igual a y |
| !== | Insuficiencia etc | x !== y significa verdadero si x no es igual a y, o si xey son de diferentes tipos |
Operadores logicos
| operador | nombre | Ejemplo |
|---|---|---|
| && | Y lógico (y) | x && y significa verdadero si tanto x como y son verdaderos |
| || | O lógico (o) | x || y significa que si x o y son verdaderos, entonces son verdaderos |
| ! | negación lógica (no) | !x significa verdadero si x no es verdadero |
&& cortocircuito: devuelve el primer valor falso si es falso, si no hay ningún valor falso, devuelve el último valor verdadero :
Ejemplo de código:
console.log(4 && '4');// 打印'4'：为真，返回的第二个
console.log(4 && '');// 打印''：
console.log(0 && true);// 打印0：为假，短路，返回第一个
console.log(0 && NaN && 1);// 打印0：为假，短路，返回第一个
console.log(false && NaN && null);// 打印false：第一个为假，则返回假
console.log('abc' && true && 1);// 打印1：都为真，则返回最后一个值|| Cortocircuito: Devuelve el primer valor verdadero si es verdadero, si no hay ningún valor verdadero, devuelve el último valor falso :
Ejemplo de código:
console.log(4 || '4');// 打印4,遇真则返回真值
console.log(4 || 'abc');// 打印4，其中有一个为真，则返回真的值
console.log('' || 'abc');// 打印'abc',
console.log(undefined || '');// 打印''
console.log(undefined || null || '');// 打印''
console.log(1 || null || '');// 打印1
console.log(4 > 5 || 2 < 3);// 打印true! Not (negación): Devuelve un valor booleano: verdadero o falso, o falso o verdadero:
Ejemplo de código:
console.log(!(200 > 201));// 打印true
console.log(!1);// 打印false
console.log(!!1);// 打印true
console.log(!!null);// 打印false
console.log(Boolean(null));// 打印falseoperador ternario
Formato de sintaxis:
条件表达式1 ? 表达式2 : 表达式3;
// 执行思路：如果表达式1的结果为真，则执行表达式2，如果表达式1的结果为假，则执行表达式3