¡Trucos que los ingenieros de front-end web deberían conocer para mejorar sus habilidades en JavaScript!
¡Habilidades y consejos! Los amigos que están familiarizados con el trabajo de front-end web saben que JavaScript es una habilidad esencial para los ingenieros de front-end. El lenguaje Java Script
es un lenguaje complejo. Si eres un desarrollador web senior o junior, es muy importante comprender sus conceptos básicos. En este artículo, el editor presenta varias formas de mejorar JavaScript.
¡Veamos los consejos y trucos!
01, Asignación de variables (valor y valor de referencia)
Comprender cómo JavaScript asigna valores a las variables puede ayudarnos a reducir algunos errores innecesarios. Sin comprender esto, puede resultar fácil escribir código cuyos valores se cambien sin darse cuenta.
JavaScript siempre asigna un valor a una variable en función de su valor. Esta parte es muy importante: cuando el valor especificado es uno de los cinco tipos básicos de JavaScript (es decir, booleano, nulo, indefinido, cadena y número), se asignará el valor real. Sin embargo, cuando el valor especificado es una matriz, función u objeto, se asigna a la variable una referencia al objeto en la memoria.
En el siguiente fragmento de código, var2 se asigna a var1. Dado que var1 es un tipo primitivo (cadena), el valor de var2 es igual a la cadena de var1.
Valor, y puede considerarse completamente diferente de var1 en este momento. Por lo tanto, reasignar var2 no tiene ningún efecto en var1.
let var 1 = 'Mystring ';
let var 2 = var 1;
var2 = 'Mynewstring
registro de consola. (var 1);
//'Mi cadena'
console .log(var 2);
//'Minuevacadena'
Luego, compare con la asignación de objetos.
letvar1={nombre: 'Jim'}
let var 2 = var 1;
var 2. nombre = 'John';
consola . log(var 1);
//{Nombre: 'John'}
consola . /{Name: 'John'}
Si espera que se comporte como la asignación de tipo original, ¡probablemente saldrá mal! Si crea una función que cambia el objeto sin darse cuenta, se producirá algún comportamiento inesperado.
02, Cierre
Los cierres son un patrón importante de JavaScript que permite el acceso privado a las variables. En este caso, createGreeter devuelve una función anónima con acceso a los parámetros.
Saludos (aquí "hola").
¡En llamadas posteriores, sayHello podrá utilizar este saludo!
funcióncreateGreeter(saludo){
returnfunction(nombre){
console.log(saludo',' nombre);
}
}
constsayHello = crear greeter('Hola ');
decir hola('Qiao');
// Hola , Joe
En un escenario más realista, puedes imaginar una función inicial apiConnect(apiKey) que devuelve algunos métodos para usar apiKey. En este caso, solo es necesario proporcionar apiKey
una vez.
functionapiConnect(apiKey){
functionget(ruta){
returnfetch(`${ruta}?key = $ { clave API } `);
}
functionpost(ruta, parámetros){
returnfetch(ruta, {
Método: ' POST ',
cuerpo: JSON.stringify(params),
Título: {
Autorización': `Portador${apiKey}'
}
})
}
Devolver {get, post}
}
constapi = API connect(' mi- clave secreta ');
//no es necesario incluir la clave más
API get(' #/get-endpoint ');
api.post(' #/. post-endpoint ', { name: ' Joe ' });
03. Deestructuración
La desestructuración de parámetros de JavaScript es una forma común de extraer lo que necesita de las propiedades de un objeto.
constobj={
nombre: "Joe",
comida: "pastel"
}
const{nombre, comida} = obj
console.log(nombre, comida);
//'Joe' 'pastel'
Si quieres elija diferentes Para los atributos de nombre, puede utilizar los siguientes métodos:
constobj={
nombre: "Joe",
comida: "pastel"
}
const{nombre: miNombre, comida: mi comida} = obj;
console.log(mi nombre, mi comida);
//'Joe' 'Cake'
La desestructuración también se usa a menudo directamente para extraer argumentos pasados a una función.
Si estás familiarizado con React, es posible que hayas visto esto:
constperson={
Amy: Eddie,
Edad: 24 años
}
Introducción a la función ({nombre, edad}){
console.log(`¡Tengo $ { nombre } años, tengo $ { edad } años! ` );
}
console.log(introduction(person));
//"¡Soy doctor en medicina y tengo 24 años! "
04. Operación de expansión
Una característica común de ES6 es el operador de expansión (...). En el siguiente ejemplo, Math.max no se puede aplicar a arr.
Matriz, porque no toma una matriz como parámetro, pero puede pasar un solo elemento como parámetro. El operador de extensión... se puede utilizar para extraer elementos individuales de una matriz.
constarr =;
constmax=Math.max(...arr)
console.log(máximo); //10
05. Parámetros residuales
La sintaxis de los parámetros restantes es la misma que la sintaxis extendida, excepto que la sintaxis extendida se usa para construir matrices y objetos; Los parámetros son lo opuesto a los operadores extendidos, el parámetro residual recopila múltiples elementos en una matriz.
functionmyFunc(...args){
console . log(args;
const mapped = arr . map(El = gt; El 20);
console.log(mapped);
//
Filtro: Devuelve una matriz solo cuando la función especificada devuelve verdadero y se incluirá en esta matriz <. /p>
constarr =;
const filtrado = arr . filter(El = gt; El = = = 2 | | El = = = 4); log(filtered);
//
Reducir: el valor especificado en la función de acumulación
constarr =;
constreduced = arr .reduce((total, actual) = gt total actual);
console.log(reducido);
//21
Buscar, Buscar índice, Índice de
Buscar: devuelve la primera instancia que coincide con la condición especificada. Si se encuentra, no continuará buscando otras instancias coincidentes
constarr =; p>const empujado = arr . push(5);
console .
//
console.log(push);
//5
Pop: Esto eliminará el último elemento de la matriz, de manera similar modifica la matriz en su lugar, la función en sí devuelve el elemento eliminado de la matriz
.let arr =;
const popd = arr . pop();
consola .
console.log(pop-up);
//4
Shift: Elimina el primer elemento del array Asimismo, modifica el array en su lugar y la función. sí mismo devuelve el elemento eliminado de la matriz.
let arr =;
const shift = arr .shift();
consola .
console.log(shift);
//1
Unshift: agrega uno o más elementos al comienzo de la matriz. Nuevamente, modifica la matriz en su lugar. A diferencia de muchos otros métodos, la función en sí devuelve la nueva longitud de la matriz.
let arr =;
constunshifted=arr.unshift(5, 6, 7);
log(arr); p>//
console.log (sin desplazamiento);
//7
Empalme, corte
Empalme: cambio aprobado el contenido de una matriz eliminando o reemplazando elementos existentes y/o agregando nuevos elementos. Este método modificará la matriz misma.
El siguiente ejemplo de código significa: eliminar 0 elementos en la posición 1 de la matriz e insertar b.
let arr =;
constsorter=(firstEl, secondEl)= gt; primer El-segundoEl;
arr.sort(sorter);
p>
console . log(arr);
//
07. Generator (generador)
El generador es especial Comportamiento, en realidad es un patrón de diseño. Llamamos al método next() para iterar a través de un conjunto ordenado de valores. Por ejemplo, imagine usar un iterador para iterar sobre una matriz. La primera llamada al método next() devuelve 1, la segunda llamada al método next() devuelve 2, y así sucesivamente. Cuando se devuelven todos los valores de la matriz, llamar al método next() devolverá valores nulos o falsos u otros valores posibles para indicar que todos los elementos de la matriz se han iterado.
function*greeter(){
Cede a "Hola"
Cede a "¿Cómo estás?"; a "Adiós" ";
}
const greet = greeter();
console.log(greet.next(). value);
>'Hola'
console.log(greet.next().value);
//'¿Cómo estás? '
console.log(greet.next().value);
//'Adiós'
console.log(greet.next().value);
//Indefinido
Utiliza un generador para generar un número ilimitado de valores:
function*idCreator(){
leti = 0;
while(true)
Ildi;
}
constitds = id creador();
consola. log(ids .next().value);
//0
console.log(ids.next().value);
// 1
p>console.log(ids.next().
value);
//2
//Y así sucesivamente...
08. Operador de identidad (= =) y operador de igualdad ( = =)
¡Todos deben conocer la diferencia entre el operador de signo igual (= = =) y el operador de signo igual (==) en JavaScript!
El operador = realiza una conversión de tipo antes de comparar los valores, mientras que el operador == no realiza ninguna conversión de tipo antes de comparar los valores.
consola . log(0 = = ' 0 ');
//Verdadero
log(0 = = = ' 0 ');
//Falso
09. Comparación de objetos
El error que veo que cometen los principiantes en JavaScript es comparar objetos directamente. ¡Las variables apuntan a referencias a objetos en la memoria, no a los objetos mismos! Una forma de compararlos es convertir los objetos a JSON.
Cadena. Esto tiene una desventaja: ¡el orden de los atributos de los objetos no está garantizado! Una forma más segura de comparar objetos es introducir una biblioteca dedicada a la comparación profunda de objetos (como isEqual de lodash).
Los siguientes objetos parecen iguales, pero en realidad apuntan a referencias diferentes.
const Joe 1 = { nombre: ' Joe ' };
const Joe 2 = { nombre: ' Joe ' }; log(Joe . 1 = = = Joe 2);
//False
Por el contrario, lo siguiente se evalúa como verdadero porque un objeto se establece igual a otro objeto, por lo que apunta a la misma referencia. (solo un objeto en memoria).
const Joe 1 = { nombre: ' Joe ' };
const Joe 2 = Joe 1;
log(Joe 1 = = = Joe . 2);
//True
Por el contrario, el cálculo siguiente es correcto porque un objeto se establece igual al otro objeto y por lo tanto apunta a la misma referencia (solo hay una en el objeto de memoria).
const Joe 1 = { nombre: ' Joe ' };
const Joe 2 = Joe 1;
log(Joe 1 = = = Joe . 2);
//Verdadero
10, función de devolución de llamada
¡Muchas personas se sienten intimidadas por las funciones de devolución de llamada de JavaScript! Por ejemplo, son simples. La función console.log se pasa a myFunc como devolución de llamada.
Se ejecuta cuando se completa setTimeout.
funciónmyFunc(texto, devolución de llamada){
setTimeout(función(){
devolución de llamada(texto);
}, 2000) ;
}
myFunc('¡Hola mundo!', consola . log);
//'¡Hola mundo! '
11. Compromiso
Una vez que comprendas las devoluciones de llamadas de JavaScript, rápidamente te encontrarás en el infierno de las devoluciones de llamadas. En este momento, puede utilizar promesas para envolver la lógica asincrónica en promesas.
Analizar en caso de éxito o rechazar en caso de error para manejar el éxito, capturar para manejar excepciones.
promesa constmy = nueva promesa(función(RES, rej){
setTimeout(función(){
if(Math.random()
returnres('¡Viva!');
}
returnrej('¡Oh no!');
}, 1000);
p>});
Mi promesa
then(function(data){
console . log(' Éxito: '. data) ;
})
.catch(function(error){
console . log(' Error:' err);
});
//si math . random() devuelve menos de 0,9, lo siguiente se registra:
//"Éxito: ¡Larga vida!"
// Si Math.random () devuelve 0.9 o mayor, se registra lo siguiente:
//"Error: Onno!"
Asincrónico/en espera
Después de dominar el uso de promesas. , es posible que también te guste asyncawait, que es solo un enfoque basado en promesas
"Syntactic sugar" En el siguiente ejemplo, creamos una función asíncrona con awaitgreeterpromise
constgreeter=. ((res, rej)= gt; {
setTimeout(()= gt; res('¡Hola mundo!'), 2000);
})
Función asíncrona