Transcripciones
1. INTRODUCCIÓN: Bienvenido a mi curso, JavaScript entrevista preguntas
con tareas prácticas. En este curso,
resolveremos juntos 59 preguntas de
entrevista más populares que obtuvieron o se hicieron
en los últimos diez años, y cubrirán todo el
conocimiento de JavaScript. Este curso está totalmente enfocado
en las tareas coordinadas. Es por eso que te
recomiendo encarecidamente que
intentes implementar
cada tarea por ti mismo. Primero, después de esto, lo
implementaremos juntos de diferentes maneras para diferentes
niveles de conocimiento. Al final de este curso, estarás mucho
mejor preparado para tu
entrevista de JavaScript consiga un trabajo. ¿ Quién soy yo? Mi nombre es
Alexander coherente pista, y soy desarrollador web, fue más de diez
años de experiencia. Es así como un
instructor profesional con diversos cursos sobre tecnologías
web. Hice todo lo posible para poner
todo mi conocimiento dentro este curso y
quería compartirlo contigo. Así que bienvenidos a bordo
y empecemos.
2. Tipos de entrevistas: Hay tres tipos
diferentes de entrevistas que podrías obtener. En primer lugar, es padre
teórico. Te acaban de hacer algunas
preguntas con respecto a tu trabajo y
experiencia y así sucesivamente. Este es un tipo normal
de entrevista para desarrolladores
más avanzados donde
ya tienen desarrolladores
más avanzados donde
ya tienenmuchos años de experiencia porque el
entrevistador entiende, bien, este tipo estaba trabajando
en desarrollo web, por ejemplo, con
JavaScript últimos cinco años, que en realidad significa que tiene
suficiente conocimiento y no tiene sentido
revisar sus habilidades de programación. El segundo tipo popular de entrevista es
coordinar entrevista. Y en realidad diría que este es el
tipo de entrevista más popular. Las personas a menudo se mezclan entrevista
teórica
con desafíos de codificación, lo que en realidad significa que
estás recibiendo algunas preguntas teóricas y luego debes codificar algo. Muy a menudo solo estás usando bolígrafo y papel y no computadora. En este curso,
vamos a resolver juntos 59
desafíos de JavaScript diferentes que se pueden obtener. Estos retos están cubiertos en casi todos los JavaScript
que se reunirá en las entrevistas. Y el último tipo de entrevista
es entrevista de check-in de proyecto. Normalmente el entrevistador
quería ver tu código. Entonces si tienes
algo que mostrar, es mucho más fácil
para ti porque no
debes contestar
solo preguntas aleatorias, sino que puedes
hablar de tu proyecto, tu código y así sucesivamente. que en realidad significa que te recomiendo
encarecidamente para que
la entrevista implemente algún proyecto porque
antes que nada, tendrás algo que
mostrar al entrevistador. Y en segundo lugar,
tendrás algo de que
hablar de
lo que al menos conoces.
3. Entrevista y trabajo son cosas completamente diferentes: Entonces típicamente para conseguir un trabajo, debes pasar una entrevista. Y así es como está trabajando
en casi todas las empresas. Pero el principal problema con eso, tu entrevista no siempre está
relacionada con tu trabajo, lo que en realidad significa parte de
la entrevista que te podrían hacer
preguntas difíciles, no
del mundo real, pero debes
responderlas para conseguir un trabajo, pero nunca
usarás este conocimiento más adelante en tu trabajo cotidiano. Aquí está el problema. Hay algunas similitudes
entre introducir y trabajar, pero en realidad son diferentes. Y en el mundo perfecto, tu entrevista debe ser un espejo de tu verdadero trabajo
en la empresa. Pero desafortunadamente,
no siempre es así. Es por eso que debes saber ambos. Debes saber pasar la entrevista y
debes saber trabajar. En este curso, la mayoría
de los retos son conocimiento
completamente real que debes conocer y que necesitas tanto en tu entrevista como en
la vida cotidiana. Pero también incluyó
en este curso algunas preguntas que
no están relacionadas con tu programación
cotidiana, pero necesitas conocerlas
solo para tu introducción.
4. Mapeo de usuarios para obtener nombres de usuario: La primera tarea que queremos mirar es sonar así. Es necesario escribir
un código para deshacerse de los nombres de una matriz de usuarios. Y como puedes ver aquí,
tenemos una matriz de usuarios. Y en realidad, es sólo
una matriz de objetos. Vemos este nombre y
esta propiedad activa. Y en realidad, esta es una tarea
relativamente fácil, pero es realmente agradable
comenzar la entrevista. Y
los entrevistadores experimentados
sabrán que estás bajo estrés, lo que en realidad significa que
debes recibir varios ejercicios fáciles solo para que te estés relajando
un poco y puedas ser más enfocados
y más productivos. Y en realidad incluso un ejercicio
fácil puede decir entrevista bastante qué estilo de
código estás usando, cómo nombra tus variables y cómo estás
escribiendo tu código para
que pueda entender en
qué nivel y
qué preguntas necesita hacerle? Por lo que ahora te
recomiendo encarecidamente que publiques este video e intentes
implementarlo tú mismo. Si solo quieres
seguir adelante, entonces vamos a codificar esto. Y en realidad hay
varias formas de implementarlo. Normalmente los principiantes
comenzarán con for loop porque es el
enfoque más fácil lo que saben. Por ejemplo, aquí
después de nuestro usuario tres, podemos escribir aquí para bucle. Por lo que tenemos aquí para dejar indexar de cero
a la inclinada de usuario. Entonces aquí tenemos una longitud menor que el usuario y aquí
tenemos ocho más plus. Ahora dentro de nuestro bucle for, queremos acceder a
cada nombre y empujarlo en alguna gloria. Es por eso que antes
queremos crear una matriz, vamos a nombrarlo nombres y
será una matriz vacía. Ahora dentro de un
bucle for podemos escribir nombres a salida
y aquí dentro de acceso en nuestros usuarios con
vi este es nuestro nombre de punto de usuario
actual. En este caso nos ponen un nombre online de este
usuario en este derecho. Y después de nuestro
bucle for podemos simplemente console.log nuestro en tus nombres
y verificarlo y navegar por él. Estoy relacionado en la página
y como pueden ver, nuestro resultado es Chegg. John Mike Esto es exactamente lo que
necesitamos implementar y sí, resolvimos nuestra tarea. Y si eres principiante, esta solución está totalmente bien. Pero puedes hacerlo mejor
porque cada vez que tratas de codificar
mejor una entrevista, muestras que eres un mejor
desarrollador. Es por esto que. Vengamos y le dijimos este
código e intentemos de nuevo. Entonces lo que podemos usar
aquí en lugar de for loop es para la
función rica para nuestra matriz. Aquí es donde aquí podemos
simplemente escribir usuarios dot para ricos y en su interior debemos
proporcionar una función de devolución de llamada. Lo que es más importante, obtenemos un acceso aquí
a cada uno de los usos y ahora dentro de una
puede hacer lo que queramos. Y como puedes ver aquí, no
tenemos índices y nuestro código se ve mucho mejor. Entonces lo que queremos hacer aquí es exactamente lo mismo
que hicimos anteriormente. Creamos aquí en los nombres
reales y ahora dentro de nuestro para cada bucle
queremos empujar dentro de nuestros nombres, nuestro nombre de punto de usuario. Y como se puede ver en
comparación con nuestro antiguo código, este código es mucho
más fácil de leer. Vamos algunos comunes aquí nuestro console.log y verificamos
si está funcionando. Como se puede ver, estamos obteniendo
exactamente el mismo resultado. Entonces este es tu nivel
dos de escritura en código, pero en realidad la
mejor manera de resolver esta tarea es usar la función de mapa
adicional. Y en realidad hará que
tu código sea el más simple solo porque estás usando la herramienta adecuada para
la tarea correcta. En este caso aquí, podemos escribir que queremos
recuperar nuestra
matriz de nombres y aquí queremos
recorrer nuestros usuarios con
la función map. Y si no sabes lo que está haciendo bien
el mapa, buceando por
cada elemento dentro de nuestra matriz y
devolverás algunos de tus datos por
cada elemento individual nuestras claves
en lugar
de nuestro objeto, queremos devolver un solo nombre. Aquí es donde? Aquí podemos
escribir que tenemos un usuario y queremos devolver
su nombre de punto de usuario. Comprobemos si está funcionando. Como se puede ver en el navegador, estamos obteniendo exactamente
la misma salida. Pero esta es la mejor variante para esta tarea y
muestra que ya sabes, lo que estás haciendo por solución es casi
siempre de bajo nivel, que significa que exactamente
necesitas implementar
lo que están haciendo. En este caso aquí, tenemos que
decir que estamos empujando elementos a nuestros nuevos nombres de matriz. Y también lo que puedes ver aquí, creamos la matriz de nombres
antes de usar for loop, lo que en realidad
significa que
nuestra lógica y nuestra variable adicional no
tienen nada juntos. En nuestro caso aquí estamos
escribiendo el resultado directamente a nuestros nuevos nombres de
variables. Por lo que resolviste con éxito esta tarea y ahora estás
obteniendo la siguiente. Tenemos que volver
a los usuarios activos, lo que significa que nuestro primer
punto aquí es válido, pero esto debe ser
todos los usuarios activos. Y en realidad podríamos usar cualquier método que queramos
aquí para resolver esto. Por ejemplo,
podríamos usar aquí para bucle y escritura más simple
dentro que si condición. Y podemos comprobar
aquí si nuestro usuario está activo y si esta
propiedad es cierta, entonces en el interior queremos empujar nuestro elemento a nuestro.
Y tienes razón. Y como se puede ver en el navegador, estamos llegando aquí
sólo dos usuarios porque nuestro último
usuario está inactivo. Esto está totalmente bien, pero aquí tenemos dos problemas. En primer lugar, nuestro
código es de bajo nivel. Y en segundo lugar, mezclamos
aquí la lógica junto con filtros y elementos
y mapeándolos. Y esto es malo porque cuando
tu código es más complejo, entonces es más
difícil dividirlo. Y en realidad la
solución con para cada uno será exactamente la misma. Pero veamos en la
solución de este mapa. En realidad, lo
que queremos hacer aquí. Queremos, en primer lugar, filtrar nuestra matriz y
conseguir en los usuarios activos. Y después de eso queremos aplicar nuestro mapa para que podamos aquí
mismo filtro de puntos. Y tenemos exactamente la misma
lógica que tenemos aquí acceso a nuestro usuario y debemos devolver aquí un predicado
con verdadero o falso. En nuestro caso será
el usuario dot está activo, por lo que si nuestro usuario está activo entonces
lo dejaremos dentro de nuestra matriz. En cualquier caso, lo
tiraremos y después de este trabajo llamaremos en
nuestro mapa para mapear nombres. Lo que es importante en
este código aquí al no mezclar merkin y
filtrar juntos, lo
que significa que es más
fácil apoyar dicho código. Ahora tenemos otra tarea. Estás consiguiendo
ciertos usuarios por edad descendente y por supuesto
a las primeras reglas también colocar. Lo que significa que, en primer lugar, debemos resolver a Ray
y luego necesitamos filtrar nuestra tarifa
y mapear nuestros nombres. Y como se puede ver aquí ahora, adicionalmente, estamos
consiguiendo propiedad de edad. Esta es nuestra propiedad por
la cual ordenaremos nuestra tarifa. Y en realidad, en JavaScript, si quieres buscar algo, debes usar solo una sola función
JavaScript y no es ordenar. Realmente no puedes
hacerlo de manera diferente si no sabes cómo funciona una
función de resort. Se puede saltar a los desarrolladores
mozilla orig a esta URL y aquí hay un
verdadero sitio prototipo. La idea principal es que
sean la
función de búsqueda de colin en nuestra
matriz y por dentro
pasamos un comparador de funciones
con A y B y en nuestro caso
será primer usuario y segundo usuario y luego segundo
usuario y tercer usuario, lo que significa que está comparando
elementos uno por uno. Y aquí debemos
devolver algo. Como se puede ver en su interior
podemos devolver menos uno. Si A es menor que B A, entonces vamos a auditar. Ahora debemos regresar de
uno si A es
mayor que B y estaban devolviendo
cero si son iguales. Y esto es exactamente
lo que debemos hacer aquí. Entonces en los tres casos, debemos escribir el mismo código, pero en las dos primeras variantes
será una especie de difusa
porque en realidad debemos hacer la clasificación antes de nuestro código aquí. Así que vamos a comentar
nuestro código aquí y queremos aplicar
cierto y aquí queremos escribir usuario almacenado sort y estamos llegando
aquí nuestro comparador. Por lo que tenemos aquí
el usuario uno y el usuario dos y queremos
compararlos por edad. Es por eso que podemos escribir aquí. Usuario una edad de puntos es
menor que el usuario a esa edad. Y si es cierto
entonces aquí tenemos un operador ternario dos
queremos devolver menos uno. En otro caso
queremos devolver uno. Vamos a guardar esto y
comprobar si está funcionando. Estoy saltando al navegador para cargar la página y vamos a
conseguir a John y chequear. Vamos a revisar la sal en la parte superior. John tiene 18 años y Jack es 20, lo que significa con ordenados
nuestros datos correctamente pero en orden
descendente como puedes ver aquí de must ordenados
en orden descendente, lo que significa que queremos
intercambiar aquí no menos uno, pero uno, y aquí
será menos uno. Vamos a revisar el
resultado que estamos obteniendo, primer lugar, Jack
y luego John. Y esta es la
clasificación correcta también debes recordar esa operación de ordenación en JavaScript muta y matriz. Esto es camino aquí con el ordenamiento de código regular y
no asignamos nuestro resultado a alguna propiedad
porque simplemente muta nuestra matriz de usuarios y luego estamos haciendo otras
cosas con ella. Pero como se puede ver
aquí, este código está realmente separado de nuestro bucle completo porque debemos
hacerlo antes de nuestras operaciones en el interior. Ahora comentemos
este código e
intentemos usarlo con nuestro
mapa y filtro. Y aquí es mucho más fácil de hacer porque simplemente
queremos aquí después nuestros usuarios llamar dot sort y después de esto
llamar a filtro y mapa. Como pueden ver aquí,
cuando me comentan, se ve realmente bonita. Tenemos aquí nuestros usuarios
estaban haciendo nuestra clasificación. Después de esto hacemos nuestro
filtrado y luego mapeo. Y en primer lugar, este código
es mucho más fácil de leer. Tienes aquí encadenando
y estás obteniendo tu resultado en esta propiedad
única. Además, es importante
que
no estemos mezclando diferentes operaciones. Primera palabra para insertar, luego filtrar y luego mapear. Y si necesitamos
ajustar uno de ellos, no
necesitamos cambiar
la lógica de otra. Vamos a ver si está
funcionando e inundando la página y estamos obteniendo
exactamente el mismo resultado. Para que como se puede ver, se puede resolver incluso la tarea simple
de diferentes maneras. Si quieres mostrar
en la entrevista que eres un desarrollador
avanzado, debes usar una herramienta específica
para tu tarea específica. Aquí es donde la
cadena de pensamiento, mapeo y filtro aquí es mucho mejor que usar para bucle.
5. Diferencia entre nulo y indefinido: Podrías obtener una
pregunta como esta. ¿ Qué hará logueado en el primer ejemplo y
en el segundo ejemplo? Para contestar el cizallamiento correctamente, debes entender
la diferencia entre null y undefined
dentro de JavaScript. Como se puede ver aquí,
tenemos dos ejemplos. En primer ejemplo, no asignamos
nada a nuestra variable, lo que significa que esta variable aún no
está definida. Es por ello que cuando aquí la
consola registramos esta variable, será igual, indefinida aquí
después de esto estamos consola iniciar sesión el tipo
de esta variable, el nombre del título también será indefinido aquí
tenemos nuestro segundo ejemplo. Estamos dentro de nuestra variable dos
se les asignó valor nulo. Aquí estamos consola login var2. Y esto se puede entender
aquí tenemos nuestro valor. Ahora, esto es lo que
veremos en la pantalla. Pero el tipo de variable dos será un objeto porque no
hay tal tipo como ahora, por eso el tipo de variable es un objeto. Echemos
un vistazo a esto. Estoy recargando la página y estamos llegando aquí indefinida. Esta es nuestra variable aquí. Entonces el valor de la misma es indefinido. Es el tipo de undefined
es indefinido como cadena. Ahora después de este registro de consola trabajo
y trabajar por
aquí estamos obteniendo ahora este es nuestro valor y tipo
de variable es un objeto. Realmente debes distinguir en JavaScript entre
null y undefined. Es indefinido. Significa que la
variable está declarada, pero el valor
aún no está asignado dentro de esta variable. Esto es exactamente lo que
tenemos aquí en la línea tres. Y ahora en JavaScript
es un valor de asignación, lo
que significa que es un valor que
podemos asignar dentro de la variable. En nuestro caso aquí estamos firmando
ahora dentro variable a. E incluso si usted respondió
correctamente aquí, entrevistador podría preguntarle, pero cuál es realmente
la diferencia entre ahora y después
definirlo cuando necesitamos usar ahora y cuándo necesitamos
usar lo indefinido. Y en realidad es complicado porque normalmente en lenguajes
normales, solo
tenemos una propiedad única, lo que significa que no existe lo
venerable. Por ejemplo, Nuevo
botón JavaScript. Tenemos dos cosas diferentes. Lo tenemos indefinido y
lo tenemos ahora. Y en realidad realmente
depende de tu estilo de código y tu equipo porque puedes usar ambos dentro del proyecto. Pero por ejemplo,
prefiero usar siempre online y tratar de tener menos indefinido
y así como sea posible. Pero obviamente, si
estás tratando encontrar un valor dentro de la matriz, obtendrás el
indefinido y no ahora porque
no encontramos nada. Entonces la respuesta aquí que
está bien usarlos a ambos. realidad no hay algo
mejor en uno u otro.
6. ¡Levantamiento!: Se te podría hacer en la entrevista la
pregunta como esta, ¿qué será la consola
iniciada aquí? Y como puedes ver aquí,
tenemos el log de consola lleno y luego foo es igual a uno. Y en realidad esta es
una pregunta típica con respecto al levantamiento. error de levantamiento
significa, significa que la declaración de tu variable burbujeará hasta la
parte superior del archivo. Y así es como funciona
en JavaScript cuando estás usando la palabra clave var o la palabra clave
function. Entonces la pregunta es
qué vamos a ver aquí, tenemos aquí consola log
f2 y f2 es una variable, pero como se puede ver, no
se declara. Y en la segunda línea
tenemos foo igual a uno. En realidad,
llegaremos aquí y estrechos. Echemos un vistazo
a esto. Estoy recargando la página y estamos consiguiendo foo no la define por
esto sucediendo porque sí, la primera línea que se ejecuta
es log de
consola y foo no está
definido dentro de un archivo. Es por eso que tenemos este error. Entonces la respuesta correcta aquí, vamos a obtener un error porque
foo no lo define. El principal problema es aquí que típicamente
obtendrás algunas posibilidades solo de responder en el papel sin ningún uso de computadora. Porque obviamente
los programadores
no están usando computadoras todos los días. Es por eso que
realmente no puedes probarlo en el navegador. Y hay que entender cómo todo esto está
funcionando de antemano. Después de una transferencia correcta, probablemente se
te preguntará
algo como esto. La siguiente pregunta
entonces estaremos bien, estamos consola de inicio de sesión aquí para, pero después de esto tenemos
var foo es igual a dos. Y en realidad aquí que
la enorme diferencia porque entonces la primera
pregunta que teníamos aquí, f2 es igual a una, pero no
teníamos una creación de la variable. Pero aquí tenemos var2, que en realidad es una
creación de la variable. Pero se podría pensar, vale, íbamos a pasar
después del registro de la consola, lo que significa que aún vamos a
obtener un error de que foo no lo define porque
Y2 sucede más tarde. Pero en realidad esta es una
respuesta equivocada porque la idea principal es que mientras la declaración está burbujeando a la
parte superior del archivo, lo
que significa que es exactamente el mismo código como aquí, var foo, y aquí
sólo estamos asignando f2 para sintonizar. Este es exactamente el mismo código. Así es como JavaScript
interpreta este código. Es por eso que si
vamos a abrir un navegador, se
puede ver que nos estamos
volviendo indefinido, por qué está sucediendo, porque en realidad aquí tenemos var foo y en este caso estamos f2 está indefinido porque no asignamos ningún
valor después de esto, tenemos un log de consola para, estamos obteniendo indefinido. Y sólo después de esto estamos
asignando incitar a la forma, lo
que significa que
no será un error, no será cierto, será indefinido. Es. Este proceso se llama levantamiento. Si respondiste correctamente, podrías obtener una
pregunta más con respecto al levantamiento. Como se puede ver aquí,
es la pregunta tres. Tenemos aquí completo es igual a tres, luego consola log foo, y luego var foo. Y creo que ahora
sabrás la respuesta. Sí, tenemos aquí Por lo tanto, y burbujea hasta
la parte superior del archivo, lo que significa en realidad tan lejos fu es exactamente como está escrito aquí,
lo que significa que en la primera
línea estamos definiendo completa propiedad en la siguiente diapositiva donde inicio de sesión pie o tres. Y después de este formulario de inicio de sesión de
consola de trabajo, lo
que significa que
será igual a tres. Y
realmente no importa que guerra vaya al final. Se burbujeará hasta la
cima. Echemos un vistazo a esto. Estoy recargando la página
y estamos recibiendo tres y esto es exactamente
lo que estábamos esperando. Puedes obtener exactamente
la misma pregunta, pero no con palabras, sino con la palabra clave function, si tienes algún lugar en tu función de código y luego
el nombre de tu función, y luego dentro estás
cierto, en alguna lógica, esta definición específica
burbujeará hasta la cima, lo
que en realidad significa que realmente no
importa en qué línea de
tu código seas, ¿verdad? Y función foo, será la primera línea que
se ejecutará en JavaScript, lo que en realidad significa que si aquí
antes llamaré foo, está totalmente bien. Como se puede ver en el navegador, no
estamos recibiendo ningún error
porque esta función foo está burbujeada hasta la parte superior y
funciona exactamente igual como var. Y aquí hay una cosa más
importante que dominaste
a tu respuesta. Debe mencionar que
podemos usar const y plomo, y no tenemos ningún
problema con ellos porque tanto CONST como plomo y
no burbujeando en absoluto. Lo que significa que si proporcionar
aquí const a igual a uno, no
burbujeará en ninguna parte. Si lo define
en la línea 17, entonces existirá
el vuelo 17, que significa que no tenemos ningún
problema con el LED Constante. Y la forma en que el JavaScript
interpreta nuestro código es exactamente de la misma manera
que el código que estamos viendo en la pantalla. Por lo que solo puedes decir
que estás usando CONST y lideras en
cada proyecto y no tienes
ningún problema con burbujeo de la variable
o con el levantamiento.
7. Cierres: Esta es con seguridad una
pregunta que escuchan en cada entrevista de
JavaScript. Es por eso que debes
entender los cierres de agua. Como se puede ver aquí,
tenemos una tarea, crear una función de contador que tenga incremento y obtenga una funcionalidad
válida. Y en realidad es posible que no lo
consigas de esta tarea, pero esta es una tarea respecto a cláusulas porque debemos crear una función donde dentro restaure algún valor y tengamos
dos métodos públicos. Así es como normalmente
necesitas implementarlo. Queremos crear nuestra,
por ejemplo, la función de
contador privado. Y esto es privado porque estamos empezando lado contable, que no está disponible afuera. Y en realidad esto
es sólo una función. Pero si escuchas en
entrevistas que
debes o algo
dentro función, después de llamar a esta función, entonces tienes una pregunta
con respecto al cierre. Lo que queremos hacer aquí, queremos que
creemos nuestro contador. Vamos a nombrarlo contar, y por defecto será 0. Ahora debemos devolver
nuestra API pública, estos dos métodos incrementan
y obtener bastante funcionalidad. Es por eso que estamos
haciendo aquí regresar y por dentro queremos
devolver dos cosas. En primer lugar, es una función
de incremento. Esta es sólo una propiedad donde estamos pasando dentro de nuestro valor. Y lo que queremos
hacer, queremos cambiar este recuento que
tenemos en la cima aquí. Estamos justo aquí,
contar más iguales, y aquí está nuestro valor
que queremos aumentar. Y en realidad podría
ser que queramos
aumentarlo por
defecto, solo por uno. Es por ello que tiene sentido
pasar aquí uno, en este caso, simplemente
podemos llamar incremento y funcionará fuera de la caja. Y el siguiente método
estará aquí, getValue porque
queremos recuperar nuestra cuenta. Y en realidad aquí esto es sólo una función que
devolverá nuestro recuento. Y la idea principal es que
esta es nuestra API pública. Esto es lo que está disponible dentro de esta función
después de que la
llamemos, echemos un vistazo a esto. Vamos a crear aquí nuestro contador
y estamos dos puntos aquí, nuestra función de contador privado. Y en realidad lo que
quiero hacer aquí, quiero consola
log en primer lugar, nuestro contador dot getValue. Este es un método para
conseguir nuestro contador. Y en segundo lugar, queremos
llamar contador punto, y aquí está incremento para valor R y luego contrarrestar una vez más
para comprobar el valor. Una vez más,
revisemos si está funcionando. Estoy recargando la página,
estamos recibiendo 01. Pero los más interesados
en la idea de lo
que tenemos dentro de este contador
privado, si estamos aquí mismo, contador
privado, se puede
ver que esta es una función y en realidad no tenemos ninguna acceso a este
inmueble cuenta. Este recuento de propiedades en
este caso es privado. Y dado si estoy justo aquí
en contador, se
puede ver que estamos obteniendo
un objeto con dos valores, obtener valor e incremento, y no tenemos ningún acceso a nuestra propiedad de mostrador en el interior. Este código está funcionando, pero es realmente complicado y complejo porque se
trata de un cierre. ¿ Qué significa el cierre alguna vez? Cierre significa que
hemos accedido dentro de una función al alcance exterior, lo que en realidad significa
aquí, por ejemplo, dentro del incremento
que estamos usando count y no tenemos un descuento
dentro de este función. Lo tenemos afuera aquí en la parte superior y exactamente lo
mismo con respecto a obtener valor. Tenemos este contador
aquí en la parte superior, no dentro de esta función, lo que en realidad significa collage o función tiene acceso
a todas las propiedades dentro de sí mismo y a todas las propiedades que la definieron antes. Por qué es importante porque en realidad con este único trazador de líneas, contras contador es igual a contador
privado, estamos creando un cierre porque ahora
estamos contador existen. Tenemos un cierre y tenemos esta referencia a este contador. Es por eso que
cada vez que estamos llamando a getValue e increment, está funcionando y está haciendo referencia a este
recuento en la parte superior. Y se podría decir, está bien, pero suena como magia. No entiendo cómo se
ve en JavaScript. Y aquí es donde
Directorio de consola puede
ayudarnos si escribiremos
dentro de la consola, no registro de consola sino directorio de
consola. Y por dentro quiero
pasar una función. En nuestro caso se contrarresta getValue luego
escondido aquí, ingrese. Aquí no vemos un cuerpo, sino que nuestra
función es un objeto. Y nos interesa aquí en
parte que se llama alcances. Y esto es exactamente
lo que
nos interesa después
abrió aquí alcances, tenemos aquí un cierre de propiedad, y este es exactamente nuestro cierre, como se puede ver aquí, tenemos
cierre contador privado. Aquí, contar es igual a uno, lo que significa exactamente somos
tenemos este recuento de leads es igual a 0, y ahora está dentro de cierre. Es por eso que está disponible
para nosotros dentro de JavaScript. Y las preguntas más antiguas con respecto a cláusulas I exactamente lo mismo. Por ejemplo, se te
podría hacer la pregunta, necesitas crear
una función que almacenará dentro de cadena secreta, y simplemente la devolveremos cuando volvamos a llamar a esta
función, lo hará se ven
algo como esto. Por ejemplo, vamos a crear
una función secreto privado. Aquí no pasamos
nada por dentro, pero queremos hacer por dentro es
crear nuestra cadena secreta. Así que vamos a crear un
secreto y es igual a cuatro. Entonces este secreto es
exactamente nuestro cierre. Para que esté disponible afuera, debemos devolver aquí una función. Simplemente devolvemos
aquí una función, y esta función
devolverá un secreto. Esto significa que
cuando estamos creando fuera de una función
que podemos nombrar, por
ejemplo, obtener secreto, debe llamar aquí nuestra función secreta
privada. La idea principal es que función
secreta
privada devuelva una función. En este caso, r gets
Secret es una función. Y ahora podemos consola log hour se vuelve secreto y simplemente lo llamamos. Y en realidad como lo
pueden ver consola, estamos recuperando esta pantalla
completa. Es por eso que nuestra cadena secreta es en realidad un cierre
y está disponible afuera después de restaurar
este secreto privado dentro de la propiedad adicional. En este caso, estamos comenzando divulgación después de que se ejecutara nuestra
función. Y el cierre es un
patrón súper popular dentro de JavaScript. Es por ello que debes
saber usar cierres.
8. Currying: Podrías obtener una
pregunta como esta. Escribe una función que
ayude a lograr multiplicar y b y devuelve
producto de a
y B. Y como puedes ver aquí, tenemos esta extraña notación. Multiplicarlos a y B, no como dos argumentos, pero esta es la primera
llamada de la función, y este es un segundo
color de la función. Y en realidad si estás
recibiendo tal pregunta, significa que vas
en la dirección de la corriente. Y la corriente es una posibilidad
especial en JavaScript para
llevar una función. Y entonces podemos
llamarlo así. Y en realidad aquí
podemos implementar este material con corriente
súper básica. Vamos a probar esto ahora. Lo que quiero hacer, quiero
crear función multiplicar. Y aquí estamos consiguiendo nuestra a, por lo que será el número
uno, por ejemplo. Aquí queremos devolver una función porque como
se puede ver aquí en la parte superior, estamos llamando al
resultado de multiplicar a, b, lo que significa que estamos multiplicando master
return una función. Entonces aquí podemos escribir que estamos obteniendo una función
que va a obtener B. Este es el número dos, por ejemplo. Y aquí dentro queremos
multiplicar nuestros num1 y num2. En este caso, nuestra segunda
función entregará para nosotros la multiplicación del
número uno y el número dos. Y así es como podemos usarlo. Podemos escribir aquí registro de consola. Queremos llamar aquí,
voy a multiplicar función y estamos pasando una por ejemplo dos. Y después de esto estamos llamando a b Esta es nuestra segunda función
y estamos pasando en S3. Veamos en el navegador. Estoy recargando la página
y estamos recibiendo seis, lo que significa que este
código está funcionando. Y en realidad se puede escribir esta función multiplicar
de mejor manera. Simplemente puedes omitir aquí devoluciones y luego será un
simple trazador de líneas único. Tenemos aquí multiplicar función y nos estamos poniendo entumecido uno aquí. Entonces queremos volver
aquí una función, y estamos llegando aquí num2. Y queremos multiplicar nuestro
número uno, multiplicando num2. Esta es exactamente la misma lógica, pero está razonando
la línea única. Se, ahora vendré y
le conté el código anterior. Y vamos a revisar, como se puede ver, estamos obteniendo exactamente
el mismo resultado, pero esto no es realmente actual. Si resuelves tal tarea, típicamente se te preguntará, vale, pero ¿qué
escribiste aquí? ¿ Qué significa esto? ¿ Por qué necesitamos tan
extraña notación? Y en realidad
hay que decir que estamos hablando aquí respecto a la corriente, hay una siguiente
pregunta que podría obtener es crear una
especie de función. Y esta es en realidad
una pregunta difícil. Y si no
tuviste ninguna experiencia las funciones actuales, entonces probablemente no lo harás inseguro. Es por eso que aquí
vamos a buscar cómo
podemos crear una especie de
función y por qué las
necesitamos y en realidad llevar funciones funcionan exactamente
como me multiplico aquí. Entonces podemos escribir en
navegador por ejemplo, Kyrie, y esta es nuestra función. Siempre debemos pasar dentro la función que
queremos cubrirla. En este caso,
tenemos, por ejemplo, una función con a, B, y C. Entonces tenemos
tres argumentos y
queremos simplemente sumar
un más B más C. El punto principal es que
el resultado de cardi es un función y vamos a
nombrarlo llevó algunos. Así es como estamos usando la corriente, lo que podemos hacer con el
coche en algunos más adelante, podemos escribir aquí nuestros argumentos. Tenemos tres argumentos, cómo queremos, por ejemplo, podemos escribir aquí 123, igual que tres argumentos
normales. También podemos llamarlo con 123, que significa que
no estamos obteniendo un resultado hasta que estemos obteniendo
tres argumentos. Entonces, por ejemplo, solo tenemos
un argumento aquí, uno, luego devolverá la función
parcialmente aplicada, lo que significa que estamos
recuperando una función. Y luego si llamaremos a esa función y
pasaremos dos argumentos, entonces estamos obteniendo
suficientes argumentos y devolveremos un resultado. Y por supuesto, también debería ser posible llamar a la
función así. En primer lugar, lo
llamamos con uno y luego lo
llamamos con 23. Así es como
funciona la función normalmente
llevada y la
crearemos justo ahora. Lo que queremos hacer aquí, queremos crear una función
curried. Y como dije, esto es cosas
más avanzadas y en realidad es una buena idea
escribir esta función
fue el archivo de script ECMO. Entonces esta función palabras clave, solo porque estamos escribiendo algo que
será usado como biblioteca. Aquí es donde aquí quiero
escribir una función, y aquí estamos
obteniendo una función. Y en realidad aquí en
la parte superior, intentémoslo, nuestro uso, así que entendemos de
qué estamos hablando. Dijimos aquí que
queremos que nuestros lleven algunos. Estamos llamando aquí
nuestra función actual. Y por dentro estamos pasando una
función con a, B, y C. Y aquí queremos
sumar a, B, y C.
Y en realidad ni siquiera
puedo escribirla aquí en la parte inferior
después de nuestra consulta. Entonces podemos probar si está funcionando, en realidad, como se puede ver aquí, como nuestra función actual. Y nos estamos metiendo
dentro de la función. Esta es nuestra Fn, este abc y a plus b plus
c es nuestra función aquí. Pero queremos hacer ahora queremos
saber cuántos argumentos
tenemos aquí. Aquí es donde aquí
quiero crear una propiedad que
se llama arity. Aquí solo podemos escribir longitud de
la función y
vamos a obtener la cantidad
de argumentos aquí. Echemos un vistazo a esto. Consola log arity. Y aquí está nuestra ariedad. Estoy buscando en el navegador
y estamos obteniendo tres, porque aquí tenemos tres
argumentos, a, B, y C. Ahora queremos devolver aquí
una función porque
sabemos que la función actual
es siempre una función. Esto es y aquí Vamos a
escribir función, vamos a nombrarlo por ejemplo, f1. Y aquí quiero difundir
nuestros argumentos y vamos a revisar
lo que tenemos dentro aquí, log de
consola F1 aquí
nuestros argumentos. Y en realidad cuando recargo
la página, como se puede ver, no
obtenemos nada porque no
llamamos a este auto a algunos. Lo que debemos hacer después, debemos llamar suma desalentada como una función y podemos
pasar dentro de algo. En nuestro caso podemos pasar 123. Estos son nuestros tres parámetros. Estoy recargando la página y
estamos llegando aquí f1, 123. Entonces estamos obteniendo todos los
argumentos como una matriz. Esta es nuestra idea. Y obviamente también podemos llamar a esta función
solo con una. Entonces obtendremos array
con solo un argumento. Lo que quiero hacer por dentro, quiero comprobar
cuántos argumentos
tenemos o si tenemos suficientes
argumentos o no. Aquí es donde aquí
dentro return
podemos comparar argumentos longitud, esta es la longitud de nuestra matriz
es mayor o igual arity. Esto significa que estamos obteniendo suficientes argumentos para
salir de la función. Por lo que aquí quiero consola de
registro suficientes argumentos. En este caso, solo
quiero volver aquí nuestra función y
llamarla con nuestros argumentos. Estoy difundido en nuestros
argumentos de nuevo, y sólo va a poner aquí todos los argumentos al igual
que lo eran antes. Echemos un vistazo
a esto. Estoy recargando la página y tenemos un
mensaje suficientes argumentos. Y en realidad aquí podemos consola log lo que
estamos recuperando. En este caso,
debemos conseguir nuestro resultado. Estoy recargando la página,
estamos recibiendo seis. Está funcionando correctamente, lo que en realidad significa que nuestro
código ya funciona cuando estamos pasando
tres argumentos a la vez. Pero no funcionará cuando
pasemos menos que eso. Aquí es donde debemos escribir aquí L Condición y
dentro podemos escribir, por
ejemplo, el inicio de sesión
de consola necesita más argumentos. Y ahora después de este libro
quería devolver una función, como ya dije,
si ya hemos pasado, por
ejemplo, alentar un
solo argumento. Debe devolver una función donde podamos pasar argumentos
adicionales. Es por ello que aquí debemos devolver una función y podemos
nombrarla, por ejemplo, F2. Y por dentro
pasaremos más argumentos, lo que en realidad significa que
este es nuestro primer carbón, esta es nuestra segunda cooperativa. Por ejemplo, aquí cuando
pasamos la suma actual, esta también es una función actual. Nombrémoslo parcialmente
llevado algunos. Aquí llamamos llevado algunos. Ahora aquí quiero construir suma
parcialmente correcta para que
podamos comprobar lo que hace. Como se puede ver aquí estamos
dentro no necesitamos argumentos, y aquí está nuestra función
fue más argumentos. Y en realidad aquí
queremos pasar algunos argumentos. Por ejemplo,
podemos pasar aquí 23, y será exactamente
esto más argumentos que escribimos aquí. Lo que queremos hacer ahora, queremos concatenar
nuestros argumentos con
más argumentos para poner todos nuestros argumentos dentro de
la llamada de la función. Es por ello que aquí
podemos crear una variable, nuevos argumentos, y
queremos concatenar
aquí nuestros argumentos. Y estoy llamando aquí concat y estoy pasando perspicacia
más argumentos. Ahora aquí no necesitamos llamar a nuestra función fn
igual que lo hicimos aquí, pero debemos llamar a nuestra función F1 porque queremos esta comprobación para suficientes argumentos
una y otra vez, que significa que nosotros lo están
llamando recursivamente. Es por eso
que aquí quiero devolver la función
F1 y quieren difundir todos nuestros nuevos argumentos. Aquí es donde aquí tres
puntos y nuevos argumentos. Echemos un vistazo a esto. Estoy recargando la página aquí. Estamos llegando a conocer mis
argumentos y suficientes argumentos. ¿ Qué tiene un medio? Aquí está nuestra suma actual. Pasamos aquí un argumento, nos estamos metiendo en las celdas. Este es nuestro registro de consola necesita más argumentos y aquí está
nuestra función adicional. Aquí es donde estamos
llamando a esta función y estamos pasando aquí
hay más argumentos. Esta es esta variable. Ahora aquí lo
concatenamos, nuestra. Esto es lo que
pasamos aquí y 23, y llamamos a nuestra F1. Estamos llegando aquí de nuevo, tenemos suficientes argumentos, y aquí estamos llamando a nuestra función y
estamos recibiendo seis. Ahora eliminemos todos
nuestros registros de consola y revisemos cómo está funcionando. Lo que quiero probar aquí es nuestro correcto algunos como podemos llamarlo, podemos llamarlo con 123
y estamos recibiendo seis. Está funcionando. Ahora podemos llamarlo con uno. Como se puede ver,
estamos recuperando una función y ahora podemos llamarla con 23 es que se puede
ver que estamos recibiendo seis también, lo
que significa que está funcionando. Y ahora podemos llamarlo
aquí con taburete y después de esto con tres
y estamos recibiendo seis, lo
que en realidad
significa que está funcionando correctamente con cualquier
cantidad de argumentos. Y aquí llevamos alguna función donde
tenemos diez argumentos. Entonces aquí estamos haciendo alguna
operación con argumentos de Stan. Entonces aquí
llamaremos a esta función recursivamente hasta que consigamos
todos los argumentos necesarios. Como se puede ver, escribir la
función de carrera no es la TGA. Y si nunca lo hiciste antes, es
difícil escribir esto
directamente en la entrevista, sobre todo solo en
el trozo de papel. La última pregunta que
podrías llegar aquí,
vale, pero ¿por qué
necesitamos función de curry? ¿ Y qué puede hacer tu
función actual? Es por eso
que aquí queremos ahora usar nuestra función de carrera
en nuestro proyecto real. Y lo que podemos hacer aquí, podemos llamarlo dos
funciones, obtener y mapear. Vamos a probar esto. Quiero crear una función get
y ellos quieren llevar. Es por eso que estoy llamando a
este tipo de función. Y por dentro estoy pasando una
función con dos propiedades. En primer lugar,
será propiedad, y en segundo lugar
será un objeto. Y lo que queremos volver aquí, solo
queremos tomar un objeto por llave y será propiedad. Vamos a revisar cómo funciona. Como pueden ver aquí tenemos nuestro get y aquí estamos
pasando dos argumentos. En primer lugar propiedad por
ejemplo AD, y en segundo lugar nuestro objeto, por ejemplo un D1. En este caso, estamos
recuperando uno. Lo que podemos hacer aquí, podemos ahora porque se lleva, simplemente llámalo con un
argumento, solo con AD. Esto, se puede ver
que estamos recuperando una función actual ahora podemos almacenarla en algún lugar y reutilizar. Por ejemplo, podemos crear
aquí una función adicional, obtener ID, y estamos llamando aquí
get con solo Property ID. Ahora como se puede ver
en el navegador, podemos usar la función GetID en
todas partes a través su aplicación en cualquier objeto para obtener apropiadamente ID de él. Ahora podemos hacer exactamente lo
mismo con el mapa. Por ejemplo, aquí
quiero crear mapa y ellos quieren
llevar una función de mapa. Aquí estamos obteniendo una
función que es un argumento del mapa y valores
que es una matriz. Aquí solo quiero llamar a un simple valores de JavaScript que mapean y luego pasar en
nuestra función por dentro. Pero ahora se lleva nuestro mapa, lo que significa que podemos usarlo
en todas partes como mapa de zanahoria, por ejemplo, podemos pasar
dentro de un mapa, obtener ID. Y ahora aquí como
segundo argumento, podemos pasar una matriz y solo
tener aquí id es igual a uno. Como puedes ver aquí,
tenemos directamente una matriz de IDs con
la ayuda del mapa. Y en realidad aquí boop
pasar dos argumentos, pero también podemos cubrirlo. Por ejemplo, podemos nombrar
una función aquí, const, obtener identificaciones, y aquí nacemos
para llamar a nuestro mapa en GetID. En este caso, tenemos una función aplicada
parcial, obtenemos a d's, y podemos usarla para obtener ideas de muchos array. Por ejemplo, aquí tenemos
razón y obtenemos ideas. Y estamos llamando a
esta función en la matriz con objetos dentro. Y tenemos aquí un D1. Y como se puede ver,
está funcionando. Esta es exactamente la necesidad de la corriente para escribir JavaScript
y forma funcional. Y aquí está, este es un tema
bastante avanzado. Es por eso que está
completamente bien si no
conoces este
tema como principiante, pero al menos debes tener
alguna comprensión básica qué es lo actual y por
qué lo necesitas en absoluto?
9. Añadir elementos al Array: Podrías obtener una
pregunta como esta e introducir con respecto a la adición de
elementos a la matriz. Como se puede ver aquí, debemos
tratar de funcionar que obtiene una matriz y un elemento y devuelve una matriz
con el asentamiento. Eso entonces en realidad
suena realmente fácil, pero puedes resolverlo
de diferentes maneras. Es por ello que debes
resolverlo correctamente y al menos decirle al
entrevistador la forma correcta. Así que típicamente los principiantes
usarán aquí array push, y luego estamos construyendo
algo como esto. Entonces tenemos una función, por
ejemplo, append, y nos estamos metiendo
en argumentos, array y nuestro nuevo elemento. Y lo que estamos haciendo aquí, estamos usando array push y
estamos pasando dentro de R, L. Y después de esto estamos
devolviendo esta nueva matriz. Entonces solo escribimos aquí
console log append, y aquí estamos comprobando, vale, Por ejemplo,
tenemos nuestra matriz 12, y aquí nuestro tercer
elemento tres. Ahora vamos a comprobar
si está funcionando donde recargar la página y
estamos recibiendo 123, y crees que construyes
esta función correctamente. Pero aquí está el problema. En realidad, quiero
escribir aquí nuestra matriz. Vamos a nombrarlo por ejemplo, números, y no
hemos guardado 12. Ahora aquí dentro dependen, quiero pasar solo nuestros números. Pero después de esto
quiero consola de números de registro, estaban recargando la página
y estamos recibiendo 123123. ¿ Qué significa? Tenemos esta función append y estamos devolviendo
aquí la matriz. Y la mayoría de la gente pensará que cuando estamos
usando esta función, estamos creando una nueva matriz. Aquí es donde normalmente
podrían escribir nuevos números. Aquí estamos llamando a
nuestra función append y pensamos, vale, no
modificamos nuestro rayo más antiguo, pero solo obtenemos nuevos
números porque función
append devuelve
para nosotros una matriz. Pero como se puede ver,
estas dos matrices son completamente iguales porque push de matriz
real modifica el rayo más antiguo y
no crea una nueva matriz. Y este es típicamente
un buen ejemplo de mal código en la aplicación. ¿ Por qué es eso? Solo imagina
que tienes una parte de tu aplicación y
tienes la matriz de este número, luego en algún momento tu columna disciplinada función
para obtener nuevos números. Pero luego fuera del azul, tu modificó tu matriz de números
antiguos, que no tenías la intención de hacer. Es por eso
que piensas que en tu aplicación puede
suceder
alguna magia solo porque el colon de esta función modifica algunos datos
fuera de esta función, este es un mal enfoque. Cómo podemos arreglarlo
y hacerlo mejor. No deberíamos usar
aquí array push. No es seguro. Lo que queremos
usar aquí en su lugar, por
ejemplo, operador spread, podemos escribir aquí
que queremos
devolver una nueva matriz
y queremos difundir todos los elementos de nuestra matriz que estamos
obteniendo como argumento. Y si no sabes
cuál es el spread, este es un operador de ECMO
Script seis, estos son tres puntos. Y lo que estamos haciendo aquí, estamos repartidos en todos los elementos de esta matriz dentro de nuestra nueva matriz, lo que esencialmente
significa que estamos creando una copia de esta matriz. Ahora mueve uno para agregar este
elemento en el siguiente QRA. Es por eso que acabamos de
probar elemento coma. Vamos a ver esto ahora. Estoy recargando la página y aquí estamos recibiendo otra respuesta. Estamos llegando aquí
123 y aquí 12, lo que en realidad significa que
esta sola línea que volverá para nosotros nueva función de matriz es
completamente segura porque no
estamos modificando ningún dato
fuera de esta función. Es por ello que esta
implementación es mucho mejor si se te pide incluso
algo que trivial, como empujar elementos
a la matriz también tienen ejecutivo el
mismo comportamiento con los objetos. Si estamos pasando por
dentro de una función, un objeto, y cuando se
mutan allí, entonces estamos mutando objetos
fuera de nuestra función, y esto es malo. Y también puedes usar spread con un objeto para crear
un nuevo objeto. En este caso, estamos del
lado seguro. Si no sabías que esta
función como aquí se llama pura
porque en primer lugar, esta función devolverá
el mismo resultado
cada vez cuando la
llamemos con los mismos argumentos. Y en segundo lugar, no modifica ninguna variable fuera de
la función. Esto es y, esta es función pura
segura.
10. Arrays Concatenating: Ya hemos
hablado de elementos ocultos a la matriz y por qué Bush no
siempre es el mejor enfoque. Pero también podría tener
una pregunta similar. Por ejemplo, aquí
tenemos una tarea, escribir una función que
concatenará dos matrices. Y en realidad podrías usar aquí push y
será una respuesta equivocada. Esta es la razón por la que aquí realmente se
puede escribir las matrices de combinación de funciones. Aquí estamos obteniendo dos matrices, por ejemplo array
uno y array to. Y aquí se podría
escribir matriz uno,
Bush, y aquí se
extendió de la matriz dos. Y después de esto
solo puedes devolver la matriz uno. Y en realidad no mucha gente escribirá código como este porque aquí estás usando push y luego estás
extendido en array a, pero podrías
pensar en tal enfoque. Ahora para ver el problema
debemos crear, primer lugar, nuestro resultado. Aquí dentro resultado,
necesitamos usar dos matrices. Array uno, por ejemplo, será solo
uno y nuestra matriz dos aquí será, por
ejemplo, 23. Ahora queremos llamar a nuestra carrera de
fusión y pasar y dijo en primer lugar matriz uno
y segundo array dos. Y revisemos y
bloqueemos la consola lo que estamos consiguiendo. Entonces, en primer lugar, resultado, luego matriz uno y matriz dos. Estoy recargando la página y
estamos recibiendo 12312323. Este es exactamente el problema, como si no fuera un video anterior. Arbusto muta matriz. Esto es camino aquí,
estamos cambiando array uno incluso si no
queremos cambiarlo. Es por ello que empujar en este caso no
es el mejor enfoque. Lo que podemos usar aquí en su lugar
es yo, el array concat, que tiene todo el enfoque de JavaScript o simplemente
un operador spread, al igual que lo hicimos anteriormente. Entonces en lugar de este retorno
y el empuje real, podemos escribir aquí en primer lugar, array one dot concat, y tenemos la
función concatenate en la matriz. Y aquí estamos difundidos
en nuestra matriz dos, vamos a revisar el Sur
donde recargar la página aquí está nuestro resultado 123 y aquí matriz uno
y matriz de dos a tres. Este es exactamente el enfoque
correcto porque concatenate no
muta una matriz. En este caso,
volverá para nosotros en nueva matriz. Es por eso que todo está bien. Si no quieres
usar re concat, siempre
puedes
usar un operador de spread. Aquí usaremos array
one como un spread. Aquí estamos extendiendo
nuestro tubo de rayos. Y en realidad el resultado será exactamente el mismo
donde conseguir 123. Y en realidad me gusta mucho este enfoque porque es más flexible y se puede fusionar no sólo raza, sino también objetos. Aquí puedes agregar nuevos elementos, y es más moderno. Si usted, por ejemplo, tiene una pregunta para concatenar
tres matrices o más, también
es posible, en realidad incluso array concat
puede trabajar con varias matrices, como se puede ver aquí en documentación aquí
tenemos tres matrices diferentes. Puedes escribir primero
array dot concat, y luego tienes matriz
secundaria y tercera. Y en realidad
funcionará correctamente, pero en realidad puedes
hacer exactamente lo mismo con spread aquí estás
extendido en la matriz uno, matriz dos, matriz tres. Si es necesario. Ambas variantes son posibles.
11. Compruebe si el usuario con dicho nombre existe: Podrías obtener una pregunta. Compruebe que el usuario con dicho nombre
existe en la matriz de objeto. Obviamente puede ser
no nombre o no usuario. Pero la idea es que
necesitas revisar una propiedad del
objeto dentro de una matriz. En realidad, existen diferentes
formas de implementar esto. Y la peor forma posible
es mediante el uso de for-loop. Porque como dije anteriormente, for-loop es de nivel súper
bajo y
no es una herramienta adecuada para
esta tarea específica. Veamos cómo se
ve con for loop. Entonces aquí queremos
crear una función, por ejemplo, es el nombre existe. Y aquí debemos
pasar dos argumentos. En primer lugar, es un nombre, y en segundo lugar es
matriz de nuestros usuarios. Ahora dentro de la máscara de la propiedad
creativa, que será booleana, y nos mostrará que
tenemos este usuario dentro de una matriz. Aquí podemos hacer que
exista un lead y por defecto
será falso. Ahora debemos escribir un bucle for. Por lo que aquí tenemos
nuestro lead I desde 0, yo menos que usuarios longitud. Y aquí estamos
haciendo yo plus plus. Ahora lo que queremos hacer en el interior
por cada elemento, debemos revisar su nombre. Aquí es donde aquí estamos
revisando a los usuarios. El nombre de punto es igual a nuestro nombre. Y si es igual,
entonces queremos asignar dentro existe a través. Después de nuestro bucle for, queremos devolver
nuestra propiedad existe. Sí, este código funcionará. Vamos a ver esto, pero
es nivel súper bajo, como se puede ver, tenemos, por
ejemplo, llamado John. Vamos a intentarlo aquí, Jon y escuchar coma a nuestros usuarios. Como se puede ver, estamos consiguiendo
a través porque escuchamos tal usuario con tal
nombre dentro de la matriz. Si estoy escribiendo aquí solo
lleno, nos estamos volviendo falsos. Pero el problema con este código, no mostrará que eres
un desarrollador avanzado. Es por eso que quería mostrarte otras
tres posibilidades
para escribir este código. Y en realidad, todas estas tres posibilidades
son ocasiones. Mi favorita será
una sola línea aquí, por lo que podemos crear una
función es que el nombre existe, y aquí estamos obteniendo
nombre y matriz. Y como puedes ver aquí, no
intenté a
los usuarios butter ray, porque ahora podemos usar
esta función en cualquier dato. Ahora lo que quiero llamar
aquí es array dot sum. Y si no sabes
lo que está haciendo Sam, puedes llamar a algunos en el rayo
dado set algunos predicados. Por lo que quieres revisar
algo por dentro. En nuestro caso, algunos
devolverán una pajita si tenemos al
menos un solo elemento
que cumpla con nuestra condición. Dentro de algunos podemos
conducir elemento. Y queremos revisar aquí, nombre del
elemento es igual a nuestros nombres
que se pasaron por dentro. Y este es literalmente
el mismo código que escribimos aquí,
pero mucho más pequeño. Vamos a revisar el sonido. Estoy
recargando página y solo estoy escribiendo su nombre existe como
se puede ver donde se hace realidad. Por lo que en realidad algunos es la mejor
solución a esta pregunta, pero también es posible
utilizar otras soluciones. Así que comentemos esto y
lo intentemos de nuevo. Tenemos aquí de nuevo dos
argumentos, nombre, array. Ahora en el interior podemos intentar encontrar el elemento con tal nombre. Aquí es donde aquí vamos a crear un elemento y estamos usando aquí array dot find dónde
conseguir nuestro elemento. Y aquí queremos comprobar elemento dot name es igual a
nuestro nombre desde la parte superior. Pero en este caso nuestro elemento
es en realidad un objeto. No es un booleano. Aquí es donde se
brewmaster wrapper elemento en booleano para devolver
booleano y no un objeto. En este caso,
funcionará correctamente. Estoy recargando la
página como se puede ver como trabajo en
exactamente así. Entonces las principales
diferencias que fueron dominarlo un poco más de código porque debemos
convertirlo a booleano. Y lo último que
podemos usar aquí no
está bien,
sino encontrar índice. Y si no sabes
lo que encuentra que está
haciendo el índice es exactamente la misma lógica, pero estamos encontrando el
índice de este elemento. Si podemos encontrar el objeto con tal
nombre dentro de nuestra matriz. Aquí no estamos obteniendo
nuestro índice de botones Element. Y después de esto, sabremos que si este índice es menor a 0, entonces
no se encontró este ítem. Aquí. Podemos tratar de devolver el
índice mayor que 0. En este caso, sabemos o
K Es más grande que 0. Tenemos este elemento
dentro de la matriz. Y como se puede ver, este código está funcionando exactamente igual. Mi enfoque sería suma, el siguiente enfoque estaremos bien. El index find también está bien, pero no debes usar
for-loop porque
es altamente ineficiente
para tal tarea.
12. Eliminar todos los duplicados en el Array: También podrías conseguir
una tarea como esta. Elimine todos los duplicados
en la matriz. que básicamente
significa si tienes una matriz de números
y tienes, por ejemplo, 112,
necesitas vivir en el 12. Veo aquí tres
formas diferentes de resolver nuestro problema. Vamos a intentar con la
mejor solución. Por ejemplo, podemos crear
aquí una función de matriz única. Estamos llegando aquí nuestra matriz
para eliminar duplicados. Aquí lo que queremos
hacer cupón para devolver una matriz y queremos difundir dentro de nuevo conjunto y
donde bisonte dentro de la matriz, si no sabes qué es el
conjunto en JavaScript,
es un objeto
que te permite almacenar valores únicos de cualquier tipo. Esto significa que si estamos
justo aquí y
dijiste que estamos pasando dentro de
la matriz, por ejemplo 112, donde oculto Enter,
como puedes ver, tenemos el set solo desde 12 porque dentro de nuestro conjunto
los elementos pueden ser duplicado. Es por ello que, como se puede ver, si vamos a difundir en su set y ponerlo
en la nueva matriz. Para convertir el revés en array, obtendremos nuestros elementos únicos. Y en realidad no mucha
gente sabe de esta solución, pero esta es la mejor
solución porque es, en
primer lugar, un solo trazador de líneas. En segundo lugar, rara vez es
rendimiento si se hace no, esta solución, no está mal. Siempre puedes construir
esta lógica por tu cuenta. La parte más importante
que incluso FOR loop aquí, si estás usando
forEach incursión no es tan mala. Echemos un vistazo
a esto. Por ejemplo, tenemos aquí la misma función, matriz
única, y queremos
escribir aquí un bucle. Y por supuesto necesitamos almacenar nuestro resultado en propiedad
adicional. Así que hagamos aquí resultado que
será nuestra matriz única. Ahora aquí quiero recorrer cada elemento de nuestra
matriz con la función ForEach. Aquí estamos obteniendo nuestro artículo como cada elemento de nuestra matriz. Ahora lo que queremos comprobar aquí, si ya tenemos este
ítem dentro de nuestro resultado, podemos consultar aquí
resultado dot incluye. Y si no lo sabes, incluye, comprueba si tenemos el
asentamiento dentro una matriz y queremos
pasar dentro de nuestro ítem. Por lo que esto volverá
verdadero si incluye. Pero en realidad hay que poner aquí
banco para tener una negación. Si no incluye este
elemento dentro de la matriz, entonces queremos
empujarlo a nuestro resultado. Entonces resultado Bush y
aquí con el ítem. que como se puede ver,
incluso para cada bucle aquí no es tan
malo porque está aislado dentro de una función donde más simple bucle a través cada elemento
y estamos empujando nuestro resultado directamente
en la nueva matriz. Y por supuesto al final
debemos devolver nuestros resultados. Entonces aquí devolvamos el resultado y verificemos
si está funcionando. Aquí está nuestra función matriz
única 112. Y como pueden ver,
estamos recuperando 12. Pero obviamente nuestra función no
funcionará con objetos
o matrices dentro, y esto es completamente normal. Entonces si tienes aquí un
objeto con un igual a uno, y aquí tienes un
objeto más con uno igual. Como se puede ver, estamos consiguiendo dos elementos y
esto está totalmente bien porque se trata de dos objetos
diferentes y no podemos compararlos. Y en realidad podemos derivar
esto para ricos mediante el uso de Reducir. De esta manera, escribiremos exactamente el mismo botón de código de
la forma más funcional. Así que aquí vamos a crear nuestra
función matriz única. Estamos llegando aquí
nuestra matriz y queremos directamente devolver un re, reducir. Y aquí dentro debemos pasar nuestra función con acumulador
y cada elemento. Aquí tenemos una función
y como argumento predeterminado, tenemos aquí matriz vacía, exactamente como
teníamos aquí donde
escribimos resultado es igual a matriz vacía. Ahora lo que queremos hacer por dentro, queremos revisar nuestro
acumulador incluye, así que estamos revisando nuestro resultado. Si tenemos en esta
matriz resultante nuestro elemento. Entonces si lo tenemos,
entonces simplemente devolvemos acumulador para que
no cambiemos nada. En otro caso, queremos
empujar este elemento al acumulador y
no estamos usando array push, pero estamos usando spread. Aquí. Estoy diseminado en acumulador y luego estoy
agregando nuestro elemento. De esta manera, este código es
completamente funcional. Es fácil de entender y no
tendría este
desagradable empuje aquí. Vamos a llenar la página
y comprobar si está funcionando. Como se puede ver, todavía
no funciona con materias, lo cual está totalmente bien. Y funciona con
primitivas Porque aquí uno fue eliminado
de nuestra matriz. Como puedes ver, tienes
tres variantes diferentes para implementar
singularidad en matriz. Y en realidad todas
estas reversiones están completamente bien para
mostrar en la entrevista.
13. Clasificar el array: Ya hemos tenido un
cierto ejercicio cuando
mapeamos a nuestros usuarios en uno
de los videos anteriores. Pero aquí quiero
hablar de cirujano, un
poco diferente. Como puedes ver,
puedes obtener la pregunta, ordenar la matriz de números. Lo que en realidad significa
que tenemos una matriz, por ejemplo, 351, y debemos ordenar. Para esto, estamos usando cierta
función en JavaScript. Simplemente escribimos clasificar. Aquí debemos pasar una función
y tenemos tales condiciones. Cuando a menos de b, estamos regresando aquí menos
uno si es mayor que, mayor que 10 si son iguales. Y previamente
escribimos aquí a y B, y aquí podemos escribir
un menor que b, entonces estamos devolviendo menos uno. En otro caso estamos
devolviendo uno. Además, es importante
recordar que ciertos retornos, el resultado de la cierta, que significa que podemos ponerlo en variable, por ejemplo, resultado, pero también mutará nuestra
matriz que hemos creado. Y en
realidad no tiene sentido aquí porque esto ha generado
array sobre la marcha. Pero si la gente
lo pone en la variable, entonces tiene sentido. Aquí tenemos nuestra matriz
y aquí estamos sin duda, veamos el ejemplo. Soy consola iniciar sesión aquí,
array y resultado. Y como se puede ver
en el navegador aquí, estamos obteniendo exactamente
la misma matriz ordenada. Esto está sucediendo
porque sort muta existe en una matriz y
debemos recordar al respecto. Además, hay un punto más
importante que recordar. En la función compare,
podemos devolver un número que es
mayor que 0 y menor que 0, y será exactamente el mismo. Será antes de a
y ordenar a antes de B, lo que en realidad significa que podemos
escribir nuestro código un
poco diferente y
no con menos 11, simplemente
podemos volver
aquí a menos b ¿Por qué es eso? Porque tenemos
aquí dos números, por ejemplo, tres menos cinco. En este caso
será menor a 0. Y entonces tendremos esta
condición ordenar a antes de B. Vamos a revisar esto. Estoy recargando la página. Estamos consiguiendo uno a
cinco como antes, si la gente aquí mismo, b menos a, entonces se
ordenará en otra dirección. Como se puede ver, estamos
obteniendo cinco a uno, lo que en realidad
significa para clasificar, podemos ordenarlo
devolviendo menos 11 o algo menor que
0 y más grande que 0. Además, es importante
recordar que
podemos usar la clasificación en primitivas
Louis. Si estás tratando de
ordenar aquí un objeto, no hará nada porque realmente no
puedes comparar objetos, pero puedes ordenar propiedades
y objetos del sitio. Y tenemos la tarea de
ordenar una serie de nuestros libros por el apellido del autor. Aquí podemos usar exactamente la
misma función de búsqueda Y. Estamos escribiendo aquí,
libros dot sort, y aquí estamos obteniendo
como argumento, libro uno y libro dos. Y ahora debemos
compararlos adecuadamente. Entonces, antes que nada,
debemos encontrar un apellido del primer autor y
del segundo autor. Aquí vamos a escribir
impresionante Apellido, uno. Y aquí nos llevan
nuestro libro one.org. Y aquí
queremos dividir nuestro nombre con espacio y llegar
aquí primer argumento. En este caso, conseguiremos el
apellido de nuestro impresionante. Ahora voy a copiar pegue esta línea y aquí tenemos
también LastName también, y aquí está el libro dos. Y ahora después de este fin de semana, compare estas dos cuerdas. Es por eso que aquí podemos escribir o LastName uno más pequeño que ASO, herramienta
LastName, entonces
queremos devolver menos uno. En el otro caso,
devolveremos uno. Y en realidad, como se
puede ver aquí, debemos usar menos
11 porque no son números donde país
restará cadenas. Y como puedes ver
aquí en el navegador, no
registramos nada en la consola. Ahora vamos a la consola de registro nuestros libros porque en realidad cuando
mutan nuestra matriz, volvamos a cargar la página. Y como pueden ver,
estos son nuestros libros. Pero ahora en primer lugar
tenemos a Susan Collins. Como se puede ver, se
ordena porque anteriormente
teníamos aquí rodando, luego Mary Lou y
luego John jawline, lo que en realidad significa que
este código está funcionando. Y así es como
estás clasificando matriz de objetos por alguna propiedad.
14. Entrevista No Es Lo Que Piensas: Mucha gente,
especialmente los principiantes, no entienden correctamente el propósito
de la entrevista. Piensan que deben
venir a la entrevista, responder un montón de
preguntas y conseguir un trabajo. Y no es así un alto porque entero es en realidad una comunicación entre
varias personas dondequiera que lado quisiera aclarar
algunas preguntas
respecto a otra persona. Por ejemplo, si estamos
hablando de entrevistador, le interesa
tus conocimientos y obviamente cómo
encajarás en su equipo. No se trata sólo de
responder preguntas. Es más como ping-pong. Estás haciendo una pregunta y entrevistador
haciendo las preguntas. No debe ser como
sólo entrevistador haciendo las preguntas y usar simplemente
responder porque en este caso, primer lugar, se pueden obtener
respuestas sobre sus preguntas. Y en segundo lugar, no estás
mostrando que te
interesa esta empresa ni en
esta posición específica. Cuando estás hablando
con el técnico chico y el especial con cada uno, debes demostrar que
te interesa. Debes hacer algunas preguntas sobre la empresa, sobre el equipo. ¿ Cuántos días hábiles tienes? Tiene horas extras aquí, con
qué frecuencia la gente
vive la empresa, cuánto tiempo la gente suele trabajar
en la empresa y así sucesivamente. Porque en primer lugar, se quiere
saber cuáles son
las condiciones de trabajo en esta empresa y
no sólo conseguir alguna empresa con malas condiciones de
trabajo. Y obviamente puedo entender que si
es tu primera tienda, quieres ir a cualquier parte, simplemente
quieres empezar a trabajar y lo
entienden totalmente. Pero si no
quieres sufrir más tarde, tiene mucho sentido
hacer estas preguntas. Además, debes gustar el
jefe de equipo o entrevistador, y típicamente será tu futuro jefe
porque trabajarás mucho con esta persona y va lo
mismo con el equipo. Es realmente buena idea conocer
a todo el equipo, al
menos para comprobar cuál es
el estado de ánimo dentro del vapor? ¿ Las personas son amigables
entre sí? ¿ Están contentos con
las condiciones de trabajo y así sucesivamente? Y lo mismo puedo decir
de revisar la oficina. Es realmente raro
a veces cuando no
se te permite
ver toda la oficina porque este será un lugar
donde estarás trabajando
y debes estar satisfecho
con las condiciones de trabajo. Te recomiendo encarecidamente que
pidas el corto plazo en
la oficina para que
al menos puedas ver las condiciones de
trabajo. ¿ Tienes suficiente luz ahí, qué monitores
tienes y así sucesivamente.
15. Función de rango de escritura: Podrías obtener un ejercicio de codificación
para implementar el rango. ¿ Qué tiene un medio? Se trata de una función auxiliar
que se ve así. Por ejemplo, si estamos
llamando rango de uno a 50, generará para nosotros una matriz 123456 y así sucesivamente hasta desplazado. Y esto es
realmente un ayudante realmente agradable cuando necesitas
generar algunos datos. Por ejemplo, desea
generar quinto usuarios aleatorios. En este caso, tu ensamblador
genera dicha matriz, y luego por
cada elemento que
estás mapeando y nuevo usuario aleatorio. Es por eso que este
ayudante existe en casi todas las bibliotecas ayudantes
como por ejemplo, un guión o Lambda. Y la diversidad es una solución de resultado pensando aquí
es usando for-loop. Aquí es donde se puede escribir
esta función así. Tienes aquí un rango de funciones, y aquí tienes inicio y fin, por
ejemplo, desde 150. Y luego dentro debemos escribir un for-loop desde el
punto de inicio hasta el punto final. Esto es y aquí,
dejame igualar estrellas. Entonces no vamos a partir de 0, pero desde el estilo aquí tenemos
razón en I menos o igual, y aquí estamos
haciendo yo plus plus. Ahora dentro de este for-loop, debemos empujar cada
índice a nuestro resultado. Esto es y Vamos a crear
aquí nuestro resultado principal. Esta es nuestra matriz. Ahora dentro podemos escribir
push resultado y estamos
empujando aquí nuestra I. Y ahora solo
devolvemos nuestro resultado. Así es como se puede construir una función de rango
utilizando for-loop. Vamos a comprobar en el navegador, estoy escribiendo aquí
función de rango una coma 15, y estamos obteniendo nuestra
matriz de uno a 50, lo que significa que nuestro código
está completamente bien, pero es de nivel súper bajo
y podemos hacerlo mejor. Nivel más avanzado es
aprovechar nuestra matriz. Podemos escribir en matriz de navegador y luego nuestro final,
por ejemplo 15. Y como se puede ver, esta devuelve primera matriz vacía donde hemos reservado 50 elementos y lo que podemos justo después de
este punto claves. Y ahora solo estamos
llamando a estas claves y estamos obteniendo iterador de
matriz. Ahora si vamos a tratar de difundir este iterador de matriz
dentro de la matriz, como se puede ver, estamos obteniendo nuestras 50 claves comenzando
de 0 a 49. Y después de esto,
simplemente necesitamos mapear cada elemento y
agregarle nuestro punto de inicio. Entonces aquí podemos escribir mapa de puntos, y aquí tenemos
cada elemento y estamos escribiendo elemento más
stat en nuestro caso, por
ejemplo, más uno, y estamos obteniendo exactamente
el mismo resultado. Esta es una matriz de uno a 50. Es por ello que esta variante es
un poco más avanzada. Aquí podemos crear nuestra función de rango y
estamos llegando aquí Stat. Y entonces ahora dentro
queremos devolver esta lógica. Y como se puede ver, esta
es una matriz donde estamos proporcionando y estamos haciendo claves y estamos difundidos en
este clasificador de matriz
dentro de nuestra nueva matriz. Y estamos mapeando
cada elemento. Y donde no
escuché nuestro punto de inicio, volvamos a cargar la página y
comprobar si está funcionando. Así que estoy pasando dentro de la función
naranja 150 y estamos obteniendo una
buena matriz de uno a 15. Y así es como la gente
suele escribir esta función dentro de las bibliotecas de
ayuda. Por ejemplo, lambda,
aunque dash.
16. Función de la shuffle de escritura: Podrías obtener una
pregunta en entrevista. Escribe una función que
implemente Shuffle. ¿ Qué significa shuffle? Simplemente cambia las posiciones de los elementos dentro de una matriz. Y en realidad no es tan fácil implementarlo con usar, por
ejemplo, para cada uno. Pero aquí podemos aprovechar el método aleatorio con el fin de ordenar
elementos al azar. Esto es en realidad lo que
queremos escuchar. Vamos a crear nuestra función de artículos
aleatorios. La idea principal es
que aquí estamos obteniendo nuestra matriz de artículos. Y esto puede ser lo que sea. Puede ser, solo un número, puede
ser un objeto o
tal vez incluso matriz de matrices. Debe funcionar en cualquier caso, es por eso que lo que
queremos hacer **** queremos recorrer
cada elemento y crear para cada elemento y un objeto con clave y valor. Y en realidad están dentro. Tendremos alguna
clave aleatoria generada por aleatorio. También tendremos su valor. Este es exactamente el
valor de nuestro elemento. En este caso, podemos
ordenar por este campo, nuestra matriz, y luego simplemente
eliminar esta clave aleatoria. Hagamos esto ahora. Yo uno directamente aquí
para devolver nuestros artículos. Y en primer lugar,
estoy llamando a mapa. Y aquí tenemos acceso
a cada elemento. Vamos a nombrarlo artículo alto. Y lo que queremos
hacer, queremos que
cada elemento devuelva un objeto con dos propiedades. Vamos a nombrar este tipo de propiedad porque en realidad esto es
apropiadamente para ordenar. Aquí. Acabamos de probar matemáticas al azar. Aquí tendremos
nuestra propiedad aleatoria y la siguiente será valor. Dentro del valor que
estamos almacenando nuestro artículo. En realidad cuando revisamos
nuestro código en el navegador ahora, solo
estamos llamando a
nuestros artículos aleatorios, por ejemplo, era 12. Como se puede ver atrás, nos estamos
metiendo en la ordenación de objetos y aquí el número aleatorio y
el valor es el valor de nuestro artículo. Y esto es realmente extremadamente bueno porque aquí
dentro del valor, podemos almacenar números,
objetos, o matrices. En realidad no
importa para nosotros. Después de nuestro mapeo,
queremos ordenar nuestros elementos dentro de esta matriz
por esta determinada propiedad. Es por eso que aquí
podemos escribir sort y estamos consiguiendo aquí el
ítem uno y el ítem dos. Aquí. Lo que queremos hacer, queremos escribir elemento
un punto ordenar menos elemento
dos punto ordenar y
en realidad sabremos ese ordenar usando propiedad
numérica, lo que en realidad significa que
aquí simplemente podemos usar sustracto y no
escribir menos 11. Lo ordenará correctamente. Pero para nosotros, el agua no
importa porque
solo necesitamos ordenarlo
para cambiar de posición. Y después de cambiar de posición, queremos obtener nuestra espec de valor. Para ello, debemos
probarlo un mapa más. Y aquí tenemos, vamos a nombrar a porque este es nuestro objeto y queremos
leer aquí un valor de punto. Y en realidad este es nuestro
artículo que se almacenó aquí dentro de cada
objeto. Echemos un vistazo a esto. Estoy recargando la página
aquí, barajó los artículos 12. Estamos llegando a uno. Lo vuelvo a llamar aquí
a uno de nuevo aquí 12, lo
que significa que está trabajando con cualquier elemento y
simplemente lo baraja. Y en realidad esta es una forma
increíble de resolver esto porque estamos
aprovechando aquí matemáticas al azar. Y por cada
elemento estamos creando este tipo en n valor. Simplemente ordenamos estos números
aleatorios y ahora se barajó. Después de esto, solo estamos
recuperando nuestros artículos. Esta es la forma más fácil y correcta barajar elementos
dentro de la matriz.
17. Encuentra el número de Occurences de Valor Mínimo en la Lista: Podrías conseguir una tarea como esta. Encuentra el número de monedas de valor mínimo en la lista. que en realidad significa que
tenemos una matriz de números y antes
que nada debemos encontrar el valor mínimo
dentro y luego calcular cuántas veces
tenemos este valor. Y en realidad si vas a
tratar de usar aquí FOR loop, entonces será realmente tedioso porque
necesitas usarlo dos veces. En primer lugar, para encontrar el valor
mínimo dentro de la matriz. Y en segundo lugar, para
calcular cuántas veces tenemos este valor dentro. Aquí es donde
en realidad debemos encontrar la función correcta dentro JavaScript para resolverlo con más fácil. Y en realidad tenemos
tal función dentro JavaScript y se
llama Matemáticas mínimo. Como se puede ver aquí,
estamos pasando insights varios argumentos y
volverá para nosotros los más pequeños. Es por eso que podemos
usar esta función, pero no funciona con matrices. Lo que podemos hacer en su lugar, podemos escribir matemáticas mínimo y no podemos pasar
dentro de la matriz, pero podemos usar un operador de
spread aquí, y convertirá nuestra
matriz dos argumentos. Aquí podemos tener una matriz 123
y estamos recuperando uno. Y eso es exactamente
lo que queríamos. Es por ello que, como se puede
ver en una sola línea, podemos reemplazar nuestro for-loop, que será mucho más
difícil de escribir. En primer lugar, aquí vamos a
nombrarlo valor medio. Aquí queremos
llamarlo en nuestra matriz. Y vamos a crear aquí nuestra matriz, que será 123. Y aquí queremos
difundir nuestra matriz. Encontramos nuestro
valor mínimo en la matriz. Ahora, cómo podemos encontrar cuántas veces tenemos este
valor dentro de la matriz. Y en realidad la variante más fácil
aquí es mediante el uso de filtro. Si vamos a filtrar nuestra matriz
por este ítem mínimo, obtendremos una matriz
de nuestros artículos mínimos. Y luego simplemente podemos obtener
una longitud de esta matriz. Se verá
algo así. Podemos llegar hasta aquí
nuestra matriz mínima. Y lo que queremos
hacer es filtro de matriz. Y aquí tenemos acceso a cada elemento y solo
comparamos si nuestro elemento
es igual a nuestro valor mínimo. En este caso dentro de
mí una matriz, no, sólo
tenemos nuestros valores mínimos. Ahora podemos escribir
aquí solo consola log min array dot length, y nos devolverá exactamente cuántas ocurrencias de este valor mínimo
tenemos dentro de la matriz. Vamos a revisar esto tiempo recargando la página
por conseguir uno. Si vamos a sumar aquí 11 dos veces, entonces aquí tenemos tres de ellos. Y como se puede ver,
nuestro código está funcionando y no me
emocionó líneas se resolvió nuestro problema. Es por eso que te
recomiendo encarecidamente que
intentes siempre encontrar la herramienta adecuada
para el salto correcto.
18. - Esto: En este video, veremos todas
las preguntas que estén relacionadas con esto y
contexto dentro de JavaScript. Podrías adivinar alguna
pregunta como esta. ¿ Qué se cerrará aquí? La primera tarea que
estás obteniendo, tienes una función
con la palabra clave function. Esto es importante. Ahora dentro solo estamos
escribiendo consola log esto, y ahora estamos dos puntos obtener elemento. Entonces la pregunta es ¿qué
veremos dentro de nuestro log de consola? Y en realidad en el navegador se
puede ver que estamos viendo ventana y se
podría pensar, bien, dentro de las funciones, esto
siempre se hace referencia en ventana, pero esto no es correcto. En cambio funciona, esto está
haciendo referencia al objeto global. Puede ser ventana, puede ser indefendido, puede ser otra cosa. Todo depende del contexto. Pero si define
una palabra clave de función directamente en
código JavaScript sin ningún anidamiento, será ventana. Ahora estás obteniendo la
Pregunta número dos. ¿ Qué se cerrará
en este caso? Como puedes ver aquí,
tenemos un objeto item con title y getItems método
dentro get item method, work console login esto aquí estamos llamando
item dot get item. En el caso de los objetos, cuando tenemos métodos
dentro de los objetos, siempre
estamos haciendo referencia a
este objeto. Esto significa que cuando estamos
recargando la página, estamos obteniendo esto y este es un objeto con
título y get item. En este caso, podemos utilizar
todas las propiedades dentro nuestro objeto porque están
disponibles para nosotros dentro de esto, cuando estamos
hablando de objetos, esto siempre hace referencia a
nuestro objeto. Aquí está nuestra tarea número tres, ¿qué se registrará
en este caso? Como puedes ver aquí,
no tenemos un objeto sino una clase. Y también tenemos dentro del método
title y getItems, y también vamos a tener esto dentro. Ahora estamos creando la
instancia de nuestra clase y llamamos a un
método GetItems desde nuestra instancia. Esto es importante
recordar que dentro de métodos en nuestra clase, cuando tenemos una instancia, tenemos una referencia
a nuestra instancia, como se puede ver en el
navegador aquí tenemos esto y podemos ver
esta palabra ítem. Esto realmente significa
que este objeto es una instancia de
nuestra clase de ítem. Y por dentro tenemos
nuestra pelota de título. Podemos utilizar todas las propiedades de
esta instancia dentro de esta. Pero ahora estamos recibiendo una
pregunta ¿qué pasará si escogeremos una función
dentro de nuestro método? Entonces en realidad lo que estamos
escribiendo aquí es función, por ejemplo, alguna función. Y por dentro estamos justo
en este log de consola. Y después de esto solo estamos
llamando a nuestra función sum, lo que en realidad significa que
definimos la función con palabra clave
function
dentro de nuestro método y la estamos llamando
aquí directamente. La pregunta es ¿qué
será el registro de consola dentro de esto? Como se puede ver en el navegador, esto es indefinido
porque como dije, en cambio funciona,
no estamos haciendo referencia a la ventana, pero estamos haciendo referencia a objeto
global. Y en realidad la palabra clave window siempre está haciendo referencia a objeto
global. Entonces en este caso nunca hará
referencia a nuestra instancia. Y esto es importante
recordar, lo que significa que si tienes una
función dentro de tu clase, esto por dentro no será correcto. No va a estar haciendo referencia a
nuestra instancia de la clase y no podemos
usar propiedades de la misma. Y exactamente el mismo
problema que tendrá no solo con definir
la función así, sino si está
escribiendo, por ejemplo, un mapa para array
dentro de su get item, y aquí tienes una función
para cada uno de los artículos. Ahora si escribiremos
consola log esto en su interior, tampoco será correcto. Como se puede ver en el navegador
estoy recargando página. Nos estamos quedando indefinidos a tres veces porque
aquí estamos usando palabra clave
function y luego establecer la función se está
haciendo referencia a ella undefined. Ambas variantes
son problemáticas. Y ahora la pregunta
es cómo podemos
arreglarlo y obtener la referencia
a nuestras teorías. Y tenemos dos
soluciones para esto. En primer lugar solución
que es más antigua, y también se usa cuando estamos incorporados JavaScript
toda la versión. Para esto simplemente podemos definir
antes de esto, por ejemplo, con un guión bajo y estamos asignando escuchar
referencia a nuestra lista. Esto será correcto porque
estamos dentro de nuestro método. Ahora podemos considerar aquí no esto porque aquí las
referencias fuertes, pero esto fue subrayado. Aquí tenemos otra referencia. Ahora volvamos a cargar la página. Como se puede ver, tenemos una referencia de carácter a
nuestra instancia de cómo ítem. Este es típicamente un enfoque
más antiguo y se utiliza en el
paso de compilación de JavaScript que el mejor
enfoque será usar una función de flecha aquí
en lugar de la palabra clave function. Así que podemos simplemente utilizar aquí función de
flecha de
magma Script six. Y ahora cuando estemos inicio de
sesión de consola dentro de
esto, tendrá la referencia
correcta. Como se puede ver, el resultado
es exactamente el mismo Porque función de
flecha está obteniendo
el contexto de nuestro padre. Lo que en realidad significa
a partir de aquí estamos consiguiendo contexto que tenemos
dentro de elemento de guitarra. Aquí tenemos una referencia
a nuestra instancia. Es por eso que te
recomiendo
que siempre uses
funciones de flecha y no funciones palabras clave
y luego no
tendrás ningún
problema con el contexto. Así que para resumir esto dentro de
la palabra clave de función, siempre
tienes una referencia
a un objeto global. Dentro de los objetos tienes una
referencia al propio objeto. Dentro de las clases, se
tiene una referencia a una instancia de la clase
y la función
interna, dentro, por ejemplo, método
o directamente dentro de la clase, se hará referencia
a undefined. Es.
19. Clases: Una de las preguntas más
populares en entrevista es
por supuesto, las clases. Podrías obtener una
pregunta como esta. Diseñar una clase para
empleado que tome un ADN llamado
construcción de orina de objetos. Y aquí hay una propiedad celular. Como se puede ver,
aquí no estamos recibiendo requisitos súper
estrictos recibiendo requisitos súper
estrictosy tenemos cierta
flexibilidad para implementarlo. Es por eso que te
recomiendo encarecidamente que
lo pienses e implementes de
la mejor manera posible. En primer lugar aquí,
pero quería crear una clase y vamos a
nombrarla empleada. Y ahora como cabeza, necesitamos tener un
constructor con el nombre DNS dentro. Esto es y Vamos a crear un
constructor y estamos obteniendo nuestro AD y nombre. Y después de esto los estamos
asignando a la Sadie. Aquí está nuestro AD y
este nombre es igual a nombre. Entonces estamos consiguiendo
estas dos propiedades. Pero puedes hacerlo
mejor porque
debes demostrar que
eres un buen desarrollador. Es por eso que es
realmente agradable comprobar si pasamos dentro de
estas dos propiedades. Entonces podemos simplemente agregar, vale, si no
pasamos AD o no pasamos nombre, entonces queremos lanzar un error. Es por eso que quería
tirar aquí en Nueva Era. Y aquí dentro podemos
escribir, por ejemplo, nuestra identificación y
nombre de empleado son obligatorios. Porque en realidad esto
es lo que está diciendo en la tarea y es agradable
cubrir esta característica. También, como se puede
ver, tenemos una línea y tiene una propiedad salarial, lo que en realidad significa que
podemos fijar el salario. No es que lo estemos
consiguiendo en constructor. Necesitamos un setter y getter
funciones para nuestro salario. En primer lugar, podemos definir ese salario establecido y
será una función, nuestra configuración para el salario, y estamos pasando
dentro de nuestro salario y simplemente
lo guardamos dentro de este. Por lo que este salario
puntual equivale a nuestro salario. Esto no es todo porque también
queremos conseguir tu show si el salario está
disponible dentro de nuestra clase. Pero realmente queremos construir esta clase de manera avanzada,
lo que en realidad significa
cupón tener alguna API pública y algunos
métodos para obtener nuestras propiedades. Esta es forma aquí te
recomiendo encarecidamente que creas, consigas salario y no
necesitamos nada aquí, y queremos volver
aquí este salario dot. Y también
tiene sentido crear dos getters para nuestro ID y nombre. Aquí podemos crear el método
GetID y su interior estamos devolviendo
nuestro thes dot ID. Y también estamos podemos crear
aquí el método getName, y va a devolver
nuestro thes nombre de punto. Para que como se puede ver con pensamiento bastante sobre nuestra clase, y se implementa
lo mejor que podamos. Ahora aquí podemos intentar usarlo. Entonces aquí estamos creando a
nuestro empleado con nuevo empleado y
estamos pasando ID
del sitio y el nombre porque
son obligatorios. Y en realidad podemos comprobarlo, podemos recargar la página
y estamos obteniendo identificación de
empleado y el
nombre son obligatorios. Y esto es agradable de comprobar. Aquí está nuestro 81 nombre,
por ejemplo, check. Y ahora nuestro empleado
no arrojará un error. Lo que podemos hacer ahora podemos escribir salario establecido
empleado
y estamos pasando, por
ejemplo, 1000 dentro. Y ahora podemos comprobarlo. Entonces voy a recargar la
página y aquí está nuestro empleado con un nombre
DNS y salario, pero también tendremos un
getters, por ejemplo, consigue salario volverá a nuestro salario y getName
devolverá el nombre. Lo que en realidad significa
que implementamos nuestra clase lo mejor posible. Pero ahora estás
consiguiendo una segunda tarea. Diseña una clase para gerente, que es empleado y puede
tener propiedad de departamento, lo que en realidad significa aquí, tu entrevistador quiere
ver extensión de nuestra clase porque podemos crear una nueva clase basado en
nuestra clase de empleados. Esto es y aquí en la parte inferior, podemos crear nueva clase Gerente. Aquí queremos utilizar
extiende para tomar la funcionalidad de
nuestra clase de empleados. Y en realidad esto
es casi t dt. Esto tomará todo
de nuestra clase de empleados, pero también necesitamos
crear un departamento. Es por eso que sólo necesitamos
un setter y getter, igual que lo hicimos anteriormente. Vamos a crear aquí
conjunto departamento y aquí dentro estamos pasando
departamento o simplemente nombre. Y aquí estamos guardando
nuestro nombre dentro
también tendrá que conseguir,
así que consiga Departamento. Y no necesitamos ningún
argumento aquí y queremos devolver nuestro departamento de
puntos de lista. Y en realidad también es súper importante tener unos
buenos nombres por todas partes. Como pueden ver,
no voy a nombrar cosas como set o simplemente al completo sobre el terror. Usualmente trato de hacer que estos nombres sean lo más
listos para la producción posible. Estamos utilizando aquí,
por ejemplo, establecer departamento, departamentos por lo que todo está
claro de qué se trata. Y realmente muestra en la
entrevista que eres un buen desarrollador y puedes
escribir código de alta calidad. Aquí tenemos nuestro
departamento de set y conseguimos Departamento. Ahora vamos a crear
nuestro chip administrado. Por lo que sólo creamos nuevo gerente y debemos pasar por
dentro como siempre, ID y nombre, por ejemplo John. Y ahora aquí podemos
consultar a nuestro directivo. Podemos hacer conjunto
departamento y lo estamos pasando dicho departamento
por ejemplo, desarrollo. Ahora podemos consultar a nuestro directivo. Por lo que no hemos dicho
departamento y hay una función de departamento GET que
nos devolverá el departamento. Así es como normalmente
responderás preguntas relativas a clases o
extensión de las clases.
20. Prototipos: En video anterior
hablamos de clases y
cómo extenderlas. Pero la siguiente pregunta del revisor de cambio puede ser clases
ocasionales. Pero ¿tenemos clases
realmente en JavaScript? Tenemos algo más porque no
tenemos clases en JavaScript y se
construyen como disparador
para prototipos. Es por eso que ahora debemos diseñar exactamente las mismas clases con solo usar prototipos JavaScript
sin uso de clases. Y en realidad hay
que hacerlo al menos una vez. Y entonces, ya sabes, ¿cuáles
son los problemas aquí? En primer lugar, tenemos a nuestro empleado de
clase y en segundo lugar, administrar chip, y ahora queremos
reflejarlo a los prototipos. En primer lugar, debemos
mover todos estos métodos fuera porque en realidad
podemos probarlos dentro de
la función. Y en realidad, ¿qué es un
prototipo? Esta es una función. No usamos la
palabra clave class y usaré y aquí porque estamos
hablando de prototipos. Entonces esta es la
versión más antigua de JavaScript. Así que aquí tengo var empleado, y esta es solo una función
normal típica con la palabra clave function aquí
estamos obteniendo un nombre DNS. Y en realidad este
también es nuestro constructor. No necesitamos constructor aquí. Comprobamos directamente, vale, si tenemos identificación y nombre, entonces estamos lanzando un error. Pero si no, estamos sentados
aquí este AD y este nombre, lo que en realidad significa que esta es nuestra clase típica cuando lo estamos
haciendo con prototipo. Ahora necesitamos ajustar
todas nuestras funciones. Como pueden ver aquí,
tengo estas funciones y ahora en lugar de simplemente establecer
salario como un método, debemos probarlo
dentro de un prototipo. Estamos diciendo
prototipo de punto de empleado, salario de punto establecido. Y esta será una función. Aquí, simplemente decimos
iguala palabra función, y aquí está nuestra función. Y tenemos que hacer exactamente lo
mismo en cada método. Entonces empleado dot prototipo
dot getID es igual, y aquí está nuestra
función y lo mismo con getName y también
con buen salario. Aquí está el prototipo,
getName es igual a función. Palabra clave aquí obtiene salario también el mismo prototipo de empleado, obtener salario igual a función. Y ahora hemos
refactorizado con éxito nuestra
clase a prototipo. No fue tan difícil
porque no nos extendimos. Por ahora quiero
comentar gerente, así que no estamos recibiendo ningún error. Ahora vamos a revisar y navegar por ella. Estoy recargando la página y ahora
tenemos aquí a nuestro empleado, como se puede ver, el código se
ve exactamente igual. Esta es la instancia
de empleado. Aquí tenemos, por
ejemplo, el método GetID. Estamos consiguiendo uno. Aquí, tenemos salarios para que podamos
hacer y conseguir salario. Y todo está funcionando, lo que significa que así es como
afectas a tu clase. Dos prototipos. Y ahora tenemos un
directivo y extendemos, y será más difícil. Por lo que aquí tenemos un gerente, dijimos departamento
y conseguimos Departamento. Y sí, también
debe ser una función. Entonces aquí solo podemos escribir var. Aquí tenemos a nuestro manager y sabemos que
esta es una función. Tampoco vamos a haber dicho departamento y meter
Departamento dentro. Los escribiremos después. Pero aquí también, el problema, nuestro directivo extiende a
nuestro empleado, pero estamos colocando dentro los mismos params y en realidad
no queremos escribir
aquí ID y nombre, pero sólo podemos
probarlo aquí, params. Y solo queríamos tirar
todos los campos que estamos recibiendo y usar
aquí a nuestro empleado. Y para esto podemos
escribir código como este. Podemos escribirlos jugar aplicar. Aquí dentro estamos pasando
estos argumentos de coma. Y lo que esto esencialmente
hace, utiliza argumentos de
esta función aquí, esto. Y como se puede ver
aquí, también escribí programas no los estaban
usando por ahora. Pero si obtienes una tarea para extender
manager con algún campo, puedes escribir aquí
estos, por ejemplo, imagen es igual a params dot imagen. Y en este caso
también debes pasar en tu
manager y una imagen. Esto es totalmente posible, pero no
lo necesitamos para nuestra tarea. Es por eso que simplemente
usamos aquí empleado aplicar estos argumentos
y lo que hace, literalmente hace una extensión
parcialmente de nuestro empleador. Como pueden ver aquí,
tenemos este ID y nombre,
y en realidad estamos
llamando a esta función, pero le estamos dando otro
contexto donde se da dentro del contexto de nuestro manager y argumentos de
esta función. Pero aquí hay una gran
diferencia que quiero mostrarte en realidad cuando estamos
saltando al navegador. Y justo aquí
manager prototipo, se
puede ver aquí en una función
constructor. Pero aquí si voy a escribir prototipo de
empleado, pueden
ver aquí
todas las funciones que teníamos anteriormente
aquí en la parte superior, porque en realidad
esta sola línea sólo
está llamando al
constructor de empleado . No tiene nada que
ver con este prototipo, lo que en realidad significa que
esto funciona EN dicho prototipo de empleado y
gerente no los consigue. Y esto es súper importante porque estamos
ampliando esta clase. Esto significa que queremos
tenerlos directamente dentro nuestro prototipo y
queremos copiarlos.
Cómo podemos hacer eso. Podemos escribir aquí manager
dot prototype iguala, y aquí queremos
usar object create porque queremos clonar
nuestro prototipo de empleado. Y por dentro estamos pasando
nuestro prototipo de punto empleado. En este caso, estamos clonando
todas estas funciones desde nuestro empleado hasta nuestro
prototipo de gerente. Así que vamos a revisar qué
estamos consiguiendo aquí. Estoy recargando la página y justo aquí, manager dot prototype. Y como pueden ver, esto es
ahora una copia de nuestro empleado. Y podemos escribir aquí
manager dot prototype, dot getID por ejemplo. Y estamos obteniendo este método. Obviamente es
indefinido porque esta no es una instancia
sino la clase, pero tenemos acceso a
este método por dentro. Pero aquí también hay un gran
problema cuando estamos escribiendo aquí manager dot
prototype dot dot constructor. Estamos consiguiendo al constructor de nuestro empleado y no
lo gestionamos y esto está mal. Es por ello que lo que
hay que escribir aquí también, gerente dot prototipo
dot constructor dot. Y queremos asignar aquí
nuestra función de manager. En este caso
será 100% correcto. Y como se puede ver
donde llego en referencia a nuestro manager, estas son dos líneas las cuales
son súper importantes cuando se está haciendo
extensión con prototipo. Porque en primer lugar, quieres obtener todos los métodos de nuestro empleado. Y en segundo lugar,
es necesario anular, construir una espalda a nuestro gerente. Y ahora podemos usar
departamento del SAT y conseguir Departamento. Esto es exactamente lo
mismo que era anteriormente. Se trata de manager dot prototype. Y aquí estamos asignando
nuestro departamento de sets y aquí gerente dot
prototype.js departamento. Aquí por supuesto, necesitamos escribir la palabra clave function en exactamente lo mismo debería
estar aquí en la parte superior. En este caso,
implementamos exitosamente manager, igual que se hizo clases
anteriores de Lucas. Recarguemos nuestra página y revisemos. Como se puede ver, estamos consiguiendo nuestro manager con ID y nombre, pero también tendremos un conjunto de
funciones Departamento. Podemos escribir, por ejemplo
aquí desarrollo. Y ahora no hemos dicho
Gerente, también desarrollo. Y tenemos una bonita función de
departamento GET. Y obviamente podemos
usar la misma función. Por ejemplo, obtener identificación de nuestros padres y también
está funcionando. Esto es lo que normalmente
usarás prototipos e implementarás clases con prototipos
nativos
dentro de JavaScript.
21. He Fallado De La Entrevista. ¿Qué es lo siguiente?: Puede ser que acaba fallar tu entrevista
y tal vez fue tu primera entrevista
y realmente querías ese trabajo y ahora estás realmente deprimido.
¿ Qué debes hacer? En primer lugar,
hay
que entender que esto es completamente normal y vas a fallar muchas
entrevistas durante tu vida, y yo fallé muchas de ellas, sobre todo al principio. Es por eso que lo que
necesitas hacer quieres, primer lugar, continuar. No debes parar justo después tu primera entrevista e incluso
después de tu quinta entrevista, no
debes parar porque tarde o
temprano
encontrarás tu primera empresa y
obtendrás tu primer empleo. En primer lugar,
no debes estar deprimido. Y en segundo lugar, debes usar las entrevistas como
fuente adicional de conocimiento porque en realidad este es un lugar
agradable para entender qué preguntas te han
hecho en la entrevista. Y también puedes entender qué conocimientos te están gustando. Aquí es donde hay dos puntos
principales que debes hacer. Después de cada entrevista. Justo después de la entrevista, debes sentarte y
escribir todas las preguntas que te
hicieron y no respondiste correctamente, no respondió A. Después de esto, debes Google todas estas preguntas
y aprenderlo. Obviamente, no puedes aprender
todo en un día, pero puedes dividir este conocimiento y aprender algo nuevo para ti. Esto es realmente importante
hacerlo directamente después, porque en el otro
caso lo olvidarás. El siguiente punto importante es
pedir la respuesta
a la empresa. Y en realidad podría ser
que no recibió una carta o
una llamada telefónica después su entrevista de
la empresa en absoluto. Y esto puede suceder
en muchas empresas. Aquí es donde debes
escribir tu gráfico con quien hablaste
al menos dos veces, puede ser en día o dos
después de la entrevista, y luego tal vez dentro de tres días después porque
debes obtener alguna respuesta. Y si decían que
no pasaste la entrevista, debes pedir la
revisión técnica de tu entrevista. Solo puedes preguntar, vale, esto es PT, pero
realmente quieren algo de retroalimentación. ¿ Qué conocimientos me gusta? Esto es completamente normal
y en realidad no proporcionarán ninguna
retroalimentación técnica muy a menudo, pero a veces podrían hacerlo. Y esto también es
extremadamente útil para ti porque
verás tus conocimientos desde la
perspectiva de otra persona. Tu entrevistador
puede escribir algo que es extremadamente
importante para que aprendas. Por eso no
se desanima si no pasaste
la entrevista, esto es completamente normal y solo
debes continuar.
22. Módulos: También podría obtener una pregunta
con respecto al sistema modular. Se refieren con este script EPMA seis módulos o módulos js
comunes. Por ejemplo, su
pregunta se puede crear una atmósfera cripta seis módulo
con funciones getName, apellido, y por defecto
experto obtener nombre completo. Para esto, debes saber que Harmodius está trabajando
en JavaScript solo porque es el componente
central de JavaScript y estamos
usando módulos por todas partes. Para utilizar las entradas, debemos
crear un archivo más. Como puedes ver aquí,
tengo JS principal. Este es nuestro principal
archivo e índice HTML. Entonces
digamos que estamos creando un nuevo módulo y
queremos nombrarlo. Por ejemplo, eg must
scripts dot js. En su interior escribiremos algún módulo
Atmos Script seis. En primer lugar, aquí queremos
crear un método getName, y lo estamos escribiendo
con export const. Aquí está GetName, y
aquí estamos obteniendo como nombre de
argumento y estamos
devolviendo nuestro nombre. Como se puede ver aquí, utilizamos el const experto en construcción, y esta es exactamente una de las funciones que
debemos crear. Y como puedes ver, consigue el
nombre y consigue su nombre. Simplemente no nombré funciones. Es por eso que
los estamos escribiendo y somos expertos en ellos desde este módulo
fue export const. Copiaré esta línea y pegaré
aquí y debemos nombrarla. Obtener cierto nombre. Aquí
estamos obteniendo cierto nombre y sólo estamos
devolviendo nuestro apellido. Lo último que
somos grado de máscara es experto
por defecto, nombre olvidadoso. Y si no sabes cómo
crear un experto predeterminado, esto es exportación por defecto. Y aquí no necesitamos
dar un nombre, lo que significa que aquí directamente
tenemos una función en nuestro caso puede ser
que podamos crearla así, nombre y apellidos y
simplemente lo concatenamos. Y dentro aquí tenemos una cadena críptica Atmos y
solo llamamos aquí a nuestras funciones. En primer lugar, GetName y
estamos pasando dentro de nombre. Después de esto tenemos
un espacio aquí, tenemos una segunda función, obtiene su nombre donde sea el apellido
bisonte dentro. Ahora nuestro archivo script seis sillas es un módulo y está
completamente aislado. Y en lo que somos expertos
aquí está disponible afuera, así que vamos a usarlo ahora. Tenemos aquí tres funciones, biomasa saltando nuestras sillas
principales aquí, hay
que importarlas y las
estamos introduciendo
así, importantes. Entonces tenemos corchetes y
dentro de lo que estamos introduciendo, es getName, Coleman
obtiene su nombre. Y como se puede ver, el editor de
mi y más viejo el camino desde aquí
en mi guión seis. Y como se puede ver
como por supuesto negro porque no estamos
utilizando estas funciones. Aquí es donde aquí
quiero escribir getName y estamos de paso. Entonces por ejemplo, JAK, entonces tenemos aquí conseguir apellido, y aquí estará gorrión. Así es como estamos entrando
y utilizando expertos en nombres. Estamos usando aquí importación de palabras, luego corchetes, y
dentro de funciones nombradas. En nuestro caso, getName, obtiene su nombre de, y esta es la ruta a nuestro
archivo ECMO scripts dot js. Ahora la pregunta
es cómo podemos conseguir nuestro experto predeterminado y
para este fin de semana, correcto, justo directamente después de la entrada, obtener el nombre completo y luego coma. En este caso, primero conseguiremos a
nuestro experto predeterminado, luego nombrados expertos solo
con corchetes después. Ahora aquí dentro de nuestro log de
consola podemos usar get fullName y estamos pasando
en el sitio dos cadenas. En primer lugar Jack y
segundo menos paralelo. Y ahora podemos usar estas
funciones igual que lo definieron
en este archivo de posición. Ahora la pregunta
es cómo podemos usar EKG prescript six
module dentro de nuestro HTML. Para ello, debemos
saltar dentro de nuestro HTML. Aquí tenemos guión
con fuente Manchester. Esto está totalmente bien, pero hay que escribir
aquí tipo módulo y luego lo importará como módulo
Atmos Script six. Ahora intentemos
volver a cargar nuestra página. Como se puede ver,
en realidad funcionó pero estamos consiguiendo
un estrecho y estamos recibiendo un error de curso porque
este índice país HTML realmente ruidoso Ajedrez principal
porque no se puede hacer un origen cruzado
solicita de archivo. Y esto es en realidad un problema
porque aquí estoy usando este archivo fuente al igual que el archivo HTML de índice
normal. Si estás usando algún framework
front-end como el reactor angular, no
tendrás tal problema porque tienes sistemas de
módulo, están fuera de la caja. Pero exactamente para este caso
particular donde he jugado
un índice HTML, debo servir este índice
HTML como un servidor web. Y para ello hay un
paquete que se llama servir. Puedes instalarlo
era conocido ajedrez, y como puedes ver ahora
está disponible para mí solo este índice HTML en
localhost 3 mil. Ahora como se puede ver, no
tenemos un error con respecto a curso, pero tenemos un problema para cargar nuestra atmósfera
cripta seis archivo, porque en realidad
aquí debemos poner dot js para cargar este archivo. Ahora no vamos a conseguir la Sarah. Y como se le puede ver consola, estas viejas funciones
están disponibles rápidamente. Aquí podemos ver a Jack
Sparrow y Jack Sparrow. Y esto significa que
entramos con éxito estas tres
funciones fue nombrado experto y exportación por defecto desde nuestro módulo mediante el uso de
Atmos grupo seis módulos. Ahora tenemos una siguiente pregunta. Debemos crear exactamente
las mismas cosas con el módulo js común. Y si no lo sabes, el modelo SIG
común se usa
típicamente
dentro de sillas conocidas. Es por eso que ahora
quería escribir nuestro archivo
atmos Script six JS
con el uso de sillas comunes. Es por eso que copiaré la tabulación de
pegado y
crearé aquí un nuevo archivo, solo nombrelo punto común js. Y vamos a reescribir
todo aquí. En el módulo js común, puedes hacer lo mismo. No se puede tener simultáneamente expertos en exportación y nombres
predeterminados. Y esto es porque en lugar de export const,
dondequiera que ponga aquí, module.export dot getName, y estamos asignando
una función aquí. El punto principal es
si Libro quiere escribir un
experto por defecto donde las TIC y en lugar de exportar el
modulo.export por defecto es igual. Y aquí está nuestra función, lo que significa que aquí tenemos una plantilla predeterminada
para nuestra función. Entonces lo que podemos hacer en
este caso es simplemente dejar este getName
y obtener el apellido como funciones
privadas
porque controlamos experto
las simultáneamente
sin experto por defecto. Y como puedes ver aquí, tenemos expertos en Módulo solo
para tener a nuestro experto predeterminado. Ahora podemos saltar directamente en Manchester y aquí importar
nuestra función predeterminada. Pero para ello debemos
usar la palabra clave require. Es por eso que aquí quiero escribir const y nos estamos volviendo
grandes conseguir nombre completo. Y aquí iguales requieren, y aquí está nuestro camino
común JS o simplemente común. Puedo saltar dentro de consola
y nodo derecho principal ajedrez. Y obviamente estamos recibiendo un mensaje GetName
no lo define porque aquí estamos tratando consola log getName
y obtener apellido. Ahora aquí
acabo de conseguir FullName. Vamos a intentarlo de nuevo. Como se puede ver, no tenemos ningún error y estamos
recibiendo cheques padres. Si realmente queremos conseguir
las tres funciones, debemos saltar aquí y
simplemente usar en todas partes module.export dot y
aquí estará nuestro getName. Ahora aquí estará más a sus expertos de
punto punto obtiene apellido. Y aquí queremos más expertos en puntos azulados y
aquí estará buen nombre completo. En este caso, funcionará y obtendremos nuestras
tres funciones. Ahora tenemos tres expertos. Podemos volver a saltar en Manchester. Y aquí en lugar
de obtener el nombre completo, solo
podemos desestructurar
y obtener tres funciones. Getname, consigue su nombre, y aquí obtener FullName. Y ahora podemos descomentar
estos dos registros de consola. Echemos un vistazo a esto. Estoy saltando a la consola
y ejecuto Node Manager y todavía obtenemos un
getName ágil no lo define. Pero en realidad el problema aquí
es que dentro de js comunes, no
tenemos una función
getName y obtenemos apellido porque en realidad
los tenemos en expertos en Módulo. Es por eso que este
código no funcionará. Berlín necesita
escribir, en primer lugar,
constituir nombre y luego despuésde constituir nombre y luego después este módulo expertos dot getName
y aquí es igual a getName. En este caso, esta
función también puede funcionar. Debemos hacer exactamente lo
mismo para nuestro obtener apellido. Aquí estará const obtener apellido y vamos a moverlo a la cima. Y ahora aquí está nuestros
expertos getName, y ahora aquí tenemos
el apellido y estamos asignando aquí nuestra
función consigue Ernie. En este caso, todas las funciones
están disponibles para nosotros dentro este archivo y también fuera a través de expertos en módulos.
Echemos un vistazo a esto. Estoy ejecutando nodo principal ajedrez y no tenemos ningún error. Para que como pueden ver, tenemos dos variantes diferentes
en mi guión, seis y cofre común. Y si lo captuviste
todas estas preguntas, entonces la siguiente pregunta podría ser, ¿Cuál es la diferencia
entre Atmos Script seis módulos y módulos js
comunes. Y en realidad SAL hace este set. Los módulos de ajedrez comunes se utilizan típicamente
dentro del cofre conocido. Este es el sistema
modular estándar para pecho
conocido ECMO Script seis
módulos que tenemos en navegador. Se trata de ECM Script
seis JavaScript. Y en realidad puedes
usar ECMO Script seis módulos dentro de sillas de nodo. Y esto es sólo un
azúcar alrededor requieren. Es por esto que si asumes un postscript seis módulos
dentro no ajedrez, sabes que dentro todavía
te has requerido porque es
obligatorio para NodeJS. Demo scripts seis
módulos son en primer más nuevos que
los módulos js
comunes, y en segundo lugar son estáticos, lo que en realidad significa que
puedes empacar esto requiere dentro si condición
por ejemplo, dentro para bucle . Pero realmente no puedes
hacerlo con entrada
porque la entrada debe estar
siempre en la parte superior. Y si la entrada no está en la parte superior, entonces burbujeará
automáticamente hasta la parte superior cuando
JavaScript lo analize. Y esto es en realidad
mucho mejor, primer lugar para la seguridad. Y en segundo lugar, implementar diferentes herramientas incorporadas en la parte superior de Atmos
Script seis módulos.
23. Implementar la función de debounce: Una de las preguntas que
están aquí de vez cuando es escribir
la función de los huesos. Y si no sabes
cuáles son los huesos, significa
que la
función será llamada solo después de
cierto periodo de tiempo, lo que en realidad significa que
cada llamada de esta función se
retrasará. ¿ Cómo podemos implementar
esta función? En primer lugar, debemos crear una función que
queramos a los huesos. Aquí quiero
crear una función, por ejemplo, guardar entrada. Y aquí nos proporcionan
dentro de nuestro nombre. Entonces la idea es que en el interior simplemente
consolemos
registrar algo. Y podemos ver que esta
función está funcionando. Aquí está guardar entrada y nombre. Y estamos usando la función de
bonos. Por ejemplo, cuando queremos enviar alguna información
al back-end, el usuario está escribiendo algo
en el campo de entrada. Y queremos
esperar, por ejemplo, 200 milisegundos o dos segundos después de que la persona dejará de escribir
algo en la entrada. En este caso, los alumnos enviaron
al back-end solo una
sola solicitud para comprobar la validación y no muchas solicitudes después
de
cada carta. Es precisamente por eso
que necesitábamos los huesos. Por lo que tenemos nuestra función de guardar
entrada y ahora queremos
llamarla los huesos. Por ejemplo, vamos a
nombrarlo cambio de proceso. Aquí queremos utilizar una
función DBMS que vamos a crear en un segundo dentro
debemos proporcionar en primer lugar,
nuestra función, esto es
guardar entrada y en segundo lugar, delay, por ejemplo, dos segundos. Después de esto, simplemente podemos llamar a cambio de
proceso con una cadena. Y en realidad no
importa cuántas veces llamaremos a esta
función la idea principal, se llamará a las. Después de dos segundos. Aquí quiero registrar
nueva función, los huesos. Y aquí estamos obteniendo
como argumento. En primer lugar, alguna función, vamos a llamarlo funk. Y en segundo lugar nuestro tiempo de espera. Y es un buen enfoque
establecer el tiempo de espera por defecto, por ejemplo, a
300 milisegundos. Esto significa que no es
obligatorio prever. Y ahora dentro de nuestra función
de
desacreditación debe devolver una función. Porque como puedes ver aquí, estamos llamando a la función bones y el cambio de proceso también es una función donde
dentro podemos proporcionar algunos datos para nuestra función de entrada
salada, que en realidad
significa aquí debemos regresar y que funcionen. Aquí queremos esparcir nuestros args. Y vamos a revisar qué nos
estamos volviendo opuestos. Por lo que aquí quiero consola
iniciar sesión función comma arcos, y podemos ver en qué
formato los estamos obteniendo. Estoy recargando la página. Como se puede ver, estamos recibiendo
cuatro veces porque
llamamos a esta función cuatro
veces en una función. Y aquí sólo tenemos
un solo argumento foo. Pero este spread con
args transformó nuestros argumentos a
una matriz porque para nosotros es más fácil
trabajar con la matriz. Lo segundo que queremos
hacer es crear un temporizador y en realidad un tiempo de grupo quieren almacenar en el cierre
aquí en la parte superior. Aquí solo podemos dejar el temporizador
sin ningún valor predeterminado. Y ahora dentro de nuestra función
interna después nuestro lote de consola con solo
quería escribir setTimeout. Aquí tendremos una
función y en realidad el segundo parámetro aquí
será nuestro tiempo de espera. Después de qué hora
llamaremos a este código dentro. Lo que queremos hacer aquí
es func dot apply. Aquí estarán estos aurochs de coma. ¿ Qué tiene un medio? Utilizamos aquí están
la función de bonos y aquí estamos brindando
nuestro aporte Salvador. Es nuestro func. Aquí está nuestro tiempo de espera. Entonces en este momento, este cambio de proceso es
esta función interna. Y después de que estamos
llamando a esta función, estamos llamando a esta parte. Aquí, estamos obteniendo
nuestros argumentos. En nuestro caso, esto
es array con foo. Aquí tenemos nuestro registro de consola y esto
generará setTimeout, lo que en realidad significa que
cada línea aquí cuando llamemos a esta función, generará un setTimeout. Con este tiempo de espera, lo que
estamos haciendo dentro
donde llamar func. Entonces estamos llamando a esta
entrada de guardar con apply this args, lo que en realidad significa que
queremos llamar a esta función después del tiempo de espera con
el contexto correcto, con el contexto de esta
función, con estos argumentos. Pero aquí tenemos un problema
cuando recargamos la página. Como se puede ver,
estamos obteniendo cuatro veces en una función y después de dos segundos obteniendo la entrada
guardada completa cuatro veces. Y esto está mal porque
aquí hay que ponerlo en los unos porque esto en realidad
está en los huesos. Debemos borrar nuestro temporizador
cada vez que hacemos
una llamada a la función,
porque en este caso, porque en este caso, nuestro tiempo de
espera establecido anterior debe ser ignorado exactamente para esto
creamos aquí plazo de entrega la misma. Lo que podemos hacer aquí, podemos asignar setTimeout
al temporizador. Y en realidad si
no conoces SetTimeout, devuélvanos un
número y esta es nuestra identificación específica
que podemos limpiar. Es por ello que antes de nuestro temporizador, ahora
podemos escribir un tiempo de espera claro y en su interior podemos
proporcionar nuestro temporizador. Si es indefinido,
no
importa, no hará nada. Pero si tenemos un AD, entonces setTimeout anterior
será destruido. En este caso, cada
vez que volvamos a llamar a esta
función, se
regarán
todos los tiempos de espera anteriores y ahora
crearemos un nuevo tiempo de espera establecido. Y después de este tiempo
llamaremos a nuestra función. Esta es exactamente la
idea de los huesos. Ahora volvamos a cargar la página. Estamos obteniendo nuestra
función interna cuatro veces, y ahora estamos recibiendo entrada
guardada por solo una vez después de dos segundos. Y esto es exactamente lo que
queríamos cuando
implementamos nuestros adeudos. Una vez más, la
función de los huesos nos permite
llamar a algo solo una vez
después de un tiempo específico. Esto es realmente
importante cuando estamos hablando de
algo que el usuario puede llamar muchas veces
durante la entrada en
el formulario, por ejemplo.
24. Implementar la función del acelerador: Nosotros implementamos con éxito
son la función de los huesos. Pero también podría
obtener una pregunta cómo implementar la función
del acelerador. Y en realidad
son súper similares. Y es por eso que tengo
el código de nuestra
función bones porque realmente
necesitamos
cambiar como 1% del código. Entonces la idea de la función del acelerador es que se
ejecutará de inmediato. Y solo para recordarte, la función de los huesos se
ejecutará en o
después de nuestro tiempo de espera. Aquí, la función de acelerador
lo ejecuta de inmediato, pero después de eso, la columna de la función es completamente ignorada
para nuestro equipo fuera, lo que en realidad significa que si
el usuario está escribiendo algo, podemos llamar a nuestra función solo al principio y
luego cada vez fuera, así que cada dos segundos,
por ejemplo. Y este es exactamente el propósito
central del acelerador. Para simular, debemos
cambiar un poco nuestro código. Aquí tenemos nuestra aportación Salvador. Esto está bien. Aquí hay cambio de proceso, pero no queremos usar aquí los huesos querrían
escribirlo con acelerador. Los argumentos son
exactamente los mismos. Y ahora aquí llamamos
cambio de proceso al inicio. Esto está totalmente bien, pero ahora quiero simular que
lo estamos llamando con SetTimeout. Aquí, tenemos razón
y setTimeout, y queremos llamar a esta función cambio de proceso dentro de él después de algún
tiempo, por ejemplo, después de 1 segundo, luego
copiaré pegue este setTimeout y ejecutaré se después de 1
segundo, 200 milisegundos. Ahora lo copio pegarlo de nuevo, y volveré a llamar a esta
función después dos segundos
y
400 milisegundos, y luego eliminaré dos
última trama ha cambiado. En realidad, como se puede ver aquí, ponemos tiempo de espera 200 milisegundos, lo que en realidad
significa que esta función debe ejecutarse de inmediato. Este setTimeout será ignorado. Esto también será ignorado y descarga el último tiempo de
espera establecido llamará a esta función
porque sucederá después de este tiempo fuera
de 200 milisegundos. Ahora antes que nada, cambiemos el nombre de nuestros
huesos por acelerador. Estamos llegando aquí
los mismos argumentos, una función y nuestro tiempo de espera. Pero ahora aquí no necesitamos un ID de
temporizador, sino un booleano. Y este booleano nos mostrará si podemos ejecutar esta
función de nuevo. Es por ello que no el tiempo de entrega, pero el plomo, por ejemplo, está esperando y por
defecto es falso. Ahora aquí también estamos devolver una función que no necesitamos
aquí, claro tiempo de espera. Y en realidad SetTimeout
se está quedando aquí, pero no necesitamos tiempo
porque en realidad vamos a prohibir este setTimeout
con una condición if aquí. Podemos escribir si no está esperando, entonces queremos llamar a
este setTimeout. En otros casos, no llamaremos a nada y este código solo
será ignorado. Además, es importante que
llamemos a esta función directamente. Es por eso que quiero
moverlo dentro de nuestra condición
if y
insights setTimeout, simplemente
cambiamos nuestro peso
en propiedad a false back. Para que como se puede ver, esta línea significa que al principio
en la primera llamada
llamaremos a esta función. Pero después de esto, queremos
poner nuestra bandera a verdad. Esto es y aquí donde no lo hice
está esperando es igual a verdad. Entonces tenemos un tiempo de espera establecido, por ejemplo, dos segundos. Y después de dos segundos que estamos
configurando está esperando a false, lo que en realidad significa que
podemos llamar a esta función en el después de dos
segundos y no antes. Para que como se puede ver, el
código es 99% igual. La idea principal es que estamos construyendo aquí es el
peso y la bandera, y solo permitimos acceder a esta función una vez
en nuestro tiempo de espera. Ahora vamos a comprobar si está funcionando. Estoy recargando la página, estamos consiguiendo directamente
ahorrando put foo primera vez. Y luego vemos en Lovaina
CV entrada f2 segunda vez. Y esto es exactamente este cambio de proceso de
código y este último modo de tiempo establecido Con dos segundos y
400 milisegundos. Porque en realidad aquí en nuestro primer intento
vamos a acelerarse, está esperando, es falso. Vamos aquí, estamos
revisando una llave, no es cierto. Entonces estamos llamando directamente a esta función y estamos
poniendo nuestra bandera a true. Y luego después de nuestro tiempo de espera
establecido y luego estamos cambiando su
peso y volvemos a falso. Y no necesitamos
aquí ningún tiempo ROJO porque nunca a
bordo de nuestro SetTimeout. La siguiente pregunta
que podrías obtener. Vale, pero ¿cuál es la diferencia entre los huesos y el acelerador? Y como ya dije, estamos llamando a los huesos
después de que los usuarios se
detuvieran a hacer algo. Estamos llamando acelerador en primer lugar
al principio y después después de cierto
intervalo de tiempo.
25. Resalta Todas Las Palabras Sobre 8 Cartas Con Amarillo: También podrías obtener
algunas preguntas con respecto a cómo JavaScript
está funcionando la sabiduría. Por ejemplo, aquí hay que
destacar todas las
palabras de más de ocho caracteres de largo en los textos de párrafo
con fondo amarillo. Y como pueden ver aquí, tengo index.HTML y
tenemos nuestro párrafo, y tenemos nuestro párrafo de
encabezado, y tenemos bastante texto aquí. Si quieres probarlo tú mismo, enlazaré el código fuente
en el cuadro de descripción a continuación. No se debe volver a escribir todo
este texto. Así es como se ve ahora, ¿cómo podemos implementar
esta tarea específica? En primer lugar, debemos
encontrar nuestro párrafo. Esto es realmente fácil que solo
tengamos un solo párrafo. Aquí. Podemos decir que
estamos encontrando párrafo y aquí está el selector de consulta de
puntos de documento. Y aquí este P y esto
se puede ver que utilicé aquí
QuerySelector. Y esto es súper importante
si intentarás
usar getElementById o
obtener elemento por clase, este no es el
mejor enfoque y detalles que no
trabajaste con Tom para igualar. Es por eso que siempre debes usar QuerySelector
o QuerySelector. Oh, si quieres conseguir una
lista de tus elementos, en nuestro caso obtenemos
sólo un solo elemento. Es por eso que simplemente escribimos aquí p y estamos recibiendo
nuestro párrafo. También podríamos escribir aquí un signo de
dólar al principio, al igual que en estilo jQuery. Por ejemplo,
prefiero hacerlo con demasiada facilidad distinguida
por el nombre, La diferencia entre
solo dos elementos
y elementos DOM. Pero por ahora
lo mantendremos igual que un párrafo. Pero queremos hacer ahora Poupon para cambiar nuestro contenido
por lo que nuestro HTML interno, es por eso que podemos escribir
párrafo punto HTML interno igual. Y queremos en primer lugar
leer párrafo punto innerHTML. Y como se puede ver,
así es como se ve
el contenido dentro de innerHTML
. Entonces esto es solo una
cadena simple y ahora podemos trabajar con ella igual que con la corriente
normal de JavaScript. Lo que queremos hacer ahora
aquí queremos ante todo dividirlo con espacio. En este caso, estamos
obteniendo una matriz de palabras y ahora podemos usar el mapa para
trabajar con cada palabra. Entonces en realidad aquí estamos recibiendo palabra y por dentro queremos
comprobar si nuestro mundo es
más largo de ocho símbolos. Así que podemos simplemente
volver aquí palabra punto longitud
más grande que ocho símbolos. Entonces aquí queremos
escribir operador ternario. Y si somos
más grandes que ocho símbolos, entonces cupón para
envolverlo en amarillo, que en realidad significa que queremos
escribir otro nodo DOM dentro. Aquí es donde aquí voy a crear una cadena div con estilo
interior y dentro del estilo, tenemos razón y
color de fondo, por ejemplo, amarillo. Aquí debemos cerrar nuestro div
y en realidad dv es malo. Debemos usar aquí span
porque este será un elemento interior
dentro de este lapso donde justo en nuestro mundo
que estaba allí anteriormente. Entonces en este caso estamos
regresando y no lo sabes. Y si no
cambiamos el mundo, simplemente devolvemos
esta palabra. Como se puede ver en este
caso, en primer lugar, tomamos nuestra cadena
dentro del innerHTML. Lo dividimos por palabras
con espacio donde mapear cada palabra y
estamos comprobando la longitud. En este caso estoy devolviendo su nodo DOM o estoy
devolviendo la palabra misma. Y después de que
terminemos con nuestro mapa, debemos volver a unir todo. Aquí es donde aquí nos estamos
uniendo con el espacio, igual que lo hicimos anteriormente. Vamos a revisar lo que estamos consiguiendo. Estoy recargando la página. Y como se puede
ver, todas nuestras palabras que más de ocho símbolos, se
resaltarán con amarillo, lo que significa realmente líneas
iniciales. Podemos resolver esta tarea. Puedes obtener diferentes
tareas con respecto a DOM. Lo que necesitas saber es cómo
obtener elementos de Dom, cómo eliminarlos de ellos, cómo actualizarlos, y en realidad cómo transformar elementos
DOM directamente a cadenas de
JavaScript, por ejemplo. Puedes trabajar con ellos.
26. Añadir un enlace: Otra tarea tonta que
puedes obtener es agregar un enlace nuevo a la fuente del
texto después de la etiqueta del párrafo. Y en realidad tengo exactamente el mismo HTML como perversamente. Pero al final, debemos proporcionar un
enlace a nuestra fuente. ¿ Cómo podemos resolver esto? En primer lugar, debemos
crear un nuevo elemento DOM. Ahora en caso de que sea un enlace, entonces vamos a proporcionar gráfico de
visión, y luego
lo vamos a anexar al final de nuestro DOM. En primer lugar, vamos a
crear un enlace. Para ello, podemos usar
documento dot create element y dentro del útero debemos proporcionar qué elemento DOM
queremos crear. En nuestro caso es un a después de este boop quiere dentro
vinculado para asignar nuestro gráfico. Por lo que simplemente escribimos enlace href iguala en caso de negación lo
copiaré desde aquí. Será HTTPS para ipsum.com. Y también estamos debemos
proporcionar una visión, un texto interno que
será un contenido de nuestro enlace. Es por ello que lync dot texto interno. Y aquí estamos asignando texto
generado desde Lorem Ipsum. Nuestro elemento DOM está listo. Ahora simplemente necesitamos
ponerlo al final de nuestro DOM. Podemos escribir aquí documento
dot body, dot append child. Y aquí solo estamos proporcionando
nuestro nuevo elemento DOM. En este caso, aparecerá
al final de nuestro cuerpo. Echemos un vistazo a esto. Estoy recargando la página
y ahora al final
tenemos textos generados
desde Lorem Ipsum, y este es un enlace y
va en la página correcta.
27. Dividir cada frase en una línea separada: Otra tarea con el
evento DOM puede ser así. Dividir cada nueva frase una línea separada en
el texto del párrafo. Se puede suponer que una frase es una cadena de textos
terminados con un periodo. Y en realidad tenemos exactamente el mismo texto dentro del párrafo, igual que lo hicimos anteriormente. Ahora la pregunta es ¿cómo
podemos implementar esta tarea? Y en realidad
podríamos pensar, vale, tenemos periodo,
simplemente podemos dividirlo por periodo. Probemos esto. En primer lugar,
quiero encontrar aquí nuestro párrafo con selector de consultas de
documentos p, igual que lo hicimos anteriormente. Y ahora aquí podemos escribir párrafo punto innerHTML iguala
párrafo punto innerHTML. Queremos dividirlo con punto. Y vamos a revisar qué
vamos a tener en este caso, después de dividirlo y tenemos
una serie de nuestras fortalezas, debemos volver a unirnos a ella. Pero en este caso queremos
poner aquí en primer lugar punto porque nos estamos
uniendo por DOD. Pero entonces necesitamos una etiqueta cercana para nuestra p y etiqueta abierta
para nuestra nueva p. En este caso, estamos
escribiendo párrafos por cada línea y join no se aplica
al último elemento. Es por ello que al final
queremos escribir plus, y aquí debemos cerrar
nuestra p. adicional vamos a ver esto hacia fuera. Estoy recargando la
página y en
realidad está funcionando pero
sólo parcialmente. Sí, está trabajando para
las frases simples, pero no va a funcionar para las frases donde
tenemos dos o tres puntos. Por ejemplo, como
puedes ver aquí, tenemos líneas con
un punto en él. Y este es exactamente el problema
porque aquí lo dividimos solo por un punto y esto
es un botón incorrecto total, nuestra lógica es correcta. Podemos inspeccionar nuestros
elementos HTML, como puedes ver, están envueltos
correctamente wispy, y luego estamos cerrando
nuestra lista p Aquí. Está funcionando, pero dividido
por un punto no es nuestro caso. En realidad aquí estamos llegando
a expresiones regulares. Y este es algún conocimiento
que debes aprender, al
menos en el nivel básico, porque lo usarás en muchos casos cuando
estés trabajando, por
ejemplo, con cuerdas y para intentar comprobar
expresión regular, te
recomiendo encarecidamente que
uses un sitio web, reg x.com. Es completamente gratis. Puedes encontrar otros sitios web, pero aquí es realmente agradable ver qué vamos
a encontrar. Como puedes ver aquí, puedes escribir una expresión regular y aquí puedes proporcionar el texto
y comprobar cómo funcionará. También aquí a la derecha, puedes establecer algunas banderas, por
ejemplo, multilínea
global y así sucesivamente. Como pueden ver, esta es
la expresión regular que queremos escribir. Y cuando estoy flotando
sobre los símbolos, te mostrará qué
exactamente estamos haciendo aquí. Este es el comienzo
de la expresión regular, y estamos envolviendo la expresión
regular siempre con dos barras. Esta slash al
principio y al final es solo un comienzo y fin de
la expresión regular. Ahora aquí dentro tenemos dot, pero dot es un símbolo especial
dentro de Expresión Regular. Es por eso que debemos escapar de
ella con la barras invertidas. Como puedes ver aquí, esto es sólo coincide con un carácter de punto. Ahora aquí tenemos
corchetes. Y como se puede ver,
todo dentro corchetes
es un conjunto negado, lo que en realidad significa que
esto no debe estar ahí. Este símbolo actual es
el inicio de nuestro set. Y aquí hemos
pensado y abierto tag. En este caso,
solo buscamos un solo punto, pero no por varios puntos. Esto es todo lo que
queríamos decir aquí. Y como se puede ver aquí en nuestro
código está funcionando correctamente. Y ahora tenemos este coincidencias
sólo con un solo punto, como se puede ver aquí, tenemos
tres puntos, botón de movimiento. El último punto será revisado porque nos
interesa sólo punto cuando no tengamos
el segundo punto después. Es por eso que podemos copiar y pegar esta expresión regular y
simplemente ponerla dentro de nuestra división. Aquí debo escribir slash
al principio y al final. Y esta es nuestra expresión
regular. Y
entiendo totalmente si no consigues un 100% lo que estoy haciendo aquí, porque primero debes aprender algunos conceptos básicos de
expresiones regulares. Pero son extremadamente importantes para si estás trabajando
con cuerdas. Ahora vamos a comprobar si
este código está funcionando. Aquí. Estoy saltando a la
página estoy recargando, y ahora está funcionando correctamente. Hicimos nuestra división. Y aquí, por ejemplo, siguen ahí
tres puntos y esta es la frase única. Y cuando tenemos un solo disparo, entonces simplemente
consideramos la división y luego movemos este
texto en la siguiente línea. Y en realidad el conocimiento de
expresión regular está un poco
fuera de JavaScript, pero todavía lo usarás mucho. Pero también, si aprenderás
que las expresiones regulares, puedes usarlas en
cada idioma. Porque en todos los idiomas
es exactamente lo mismo.
28. Delegación de eventos: También podría obtener una pregunta
como esta implementada haga clic en el ítem
lo más rápido posible. Y como se puede ver aquí
dentro de index.HTML, Tenemos tal marcado. Tenemos una lista UL y dentro solo
tenemos elementos li. Normalmente puedes
resolverlo de manera diferente. Aquí tenemos dos soluciones
típicas, pero una es mucho
mejor que otra. En realidad, lo que podemos hacer aquí, podemos encontrar ítems en dólares con documento y aquí estamos
usando el selector de consultas todos. Y aquí, como se puede
ver en nuestro index.HTML, Lee con elemento de clase. Aquí puedo encontrar por
clase nuestro artículo, y aquí estamos obteniendo
una lista de nuestros artículos. Después de esto, podemos recorrer
esta lista de nodos DOM. Y por cada elemento
podemos adjuntarlo un oyente. Aquí podemos escribir
artículos dot para ricos. Aquí tenemos nuestro ítem
que es un nodo DOM. Y en su interior podemos escribir
elemento dot addeVentListener. Aquí tenemos nuestro clicker
y aquí está nuestro manejador. Lo que queremos hacer cuando
estamos haciendo click en el ítem, al
menos probé algunos textos
con respecto a nuestro ítem. En realidad dentro sólo
tenemos un valor. Es por eso que podemos escribir aquí. Usted hizo clic en el artículo y aquí sólo
podemos escribir más
elemento punto texto interno. Entonces, en primer lugar, encontramos la lista de nuestros
artículos y luego por cada elemento en el bucle
se agregaron oyente de eventos. Echemos un vistazo a esto. Estoy recargando la página. Vemos nuestra lista de artículos. Ahora estamos haciendo click en un
elemento y estamos obteniendo un bonito registro de consola con
el contenido de este ítem. Estamos haciendo click en otro extremo, estamos consiguiendo el registro de la consola y en realidad está funcionando
y todo está bien, pero tenemos una tarea para
construirlo lo más rápido posible. Y en realidad aquí el problema es que si tenemos una lista súper enorme, entonces no es lo suficientemente performant. Porque en realidad aquí
tenemos para cada uno, para todos nuestros artículos, lo que significa que tenemos
aquí una lista de ciento, diez cientos artículos donde se suman aquí ciento,
diez cientos oyentes. Y esto es súper malo
para nuestra actuación. Es por ello que esta no es la
mejor solución para nuestra tarea. Lo que podemos hacer, podemos encontrar
al padre o para nuestra lista. Y como puedes ver aquí,
tenemos UL con app de clase Todo. Aquí es donde aquí
vamos a encontrar el elemento app y podemos usar aquí
el documento QuerySelector, y sabremos que la
clase está fuera de hacer app. Ahora en el interior podemos adjuntar solo un solo oyente
para nuestro elemento app. Así AB addeVentListener. Aquí tenemos nuestro click y
aquí está nuestra escucha. Y luego justo aquí evento, por lo que tenemos acceso a nuestro evento. Y en realidad lo
que queremos hacer por dentro, queremos comprobar a qué
elemento estamos apuntando. Porque podemos hacer click aquí en nuestro contenedor o podemos hacer click en cualquier artículo dentro
y en realidad muy interesado en el
click sobre el ítem. Es por esto
que aquí podemos escribir una K Si tenemos aquí objetivo de evento, lo que significa que
hicimos clic y queremos comprobar aquí si nuestro cargo de evento tiene
una clase del ítem, entonces esto significa que
calentamos nuestra LEA. Es por eso
que aquí podemos intentarlo incluso tocarlo lista de clases de puntos. Aquí contiene realmente la propiedad de lista de
clases dentro del nodo tiene una función contiene para comprobar si
tenemos tal clase. En caso de que
estemos comprobando si pulsamos en nuestro artículo. Si esto se hace,
entonces podemos copiar nuestro candado de consola aquí dentro y simplemente
cambiarlo un poco. Nos vamos de aquí nuestra cuerda. Has hecho clic en el elemento aquí en
lugar de item.name en un texto, podemos escribir texto de punto de destino de evento
, y funcionará
exactamente igual. Echemos un vistazo a esto. Estoy recargando la página. Estoy escondido aquí en algunos artículos y nos estamos
volviendo amables. Usted hizo clic. Y en realidad si vamos a
hacer clic en algún lugar afuera, no
hace nada. Pero la principal diferencia en
este código es mucho más rápida porque tenemos aquí
solo un solo oyente para nuestros padres. Y no estamos generando cientos de miles de
oyentes por cada ítem.
29. Xml HTTP Solicitud: Podrías conseguir una entrevista
la pregunta, ¿verdad? Un ejemplo de obtener datos de API con solicitud HTTP XML. Y en realidad esta es
una pregunta súper vieja. Y normalmente la gente no
debería hacer esta pregunta hoy en día
y entrevistas, pero todavía estoy aquí en esta pregunta mucho
porque algunas personas todavía quieren saber cómo
resolvimos nuestra búsqueda y problemas hace diez o 15 años. Los proyectos modernos, nunca
usarás la solicitud HTTP XML de forma nativa. Por eso no tiene sentido hacer esta pregunta, pero debemos
aprender a responderla. Es por eso que vamos a escribir un
ejemplo de cómo está funcionando. En primer lugar, debemos
crear nuestra solicitud XHR. Entonces es por eso que
te estamos llamando solicitud XML HTTP. Ahora tenemos una instancia de
nuestra solicitud HTTP XML y podemos decir qué método
queremos enviar y en qué URL. Es por eso que tenemos razón
y silla XC dot abierta. Y como se puede ver aquí, tenemos dos parámetros. En primer lugar, es método. Aquí queremos escribir GED porque estamos haciendo
una solicitud GET. Y aquí está nuestra URL API y
pegaré aquí y API URL de github comm para recuperar todos los repositorios de
este usuario específico. Después de esto, tenemos razón en XHR
dot cn y corchetes redondos. Pero no es todo. También debemos precisar lo que
sucederá en caso de éxito y sobre error. Y para esto estamos
escribiendo punto XHR en Lord. Y aquí debemos
asignar una función. Y dentro de esta
función, antes que nada, quieres comprobar qué
estado estamos recuperando. Entonces podemos escribir aquí
si el gráfico xy ese estado no equivale a 200, lo
que significa que
no tiene éxito, entonces queremos
consolar algún error. Quiero escribir
aquí, por ejemplo, flecha última y tal vez
XHR status glass, y aquí texto de estado XHR. En este caso,
podemos ver directamente qué problema tenemos en el otro caso
donde conseguir éxito. Por lo que aquí escribiremos el éxito del registro de
consola. Y después de esto, pasamos a
leer nuestra respuesta de puntos XHR, donde dentro tenemos
nuestra respuesta y
también vamos a querer verificar
el error dentro de las solicitudes de gráfico
xy. Entonces aquí podemos escribir
xy chart dot on error. Y sólo para recordarte, todo está en minúsculas y aquí
estamos asignados una función. Y dentro podemos
escribir, por ejemplo, registro de
consola solicitud de
cargo extra falló. Así es como normalmente
define la función XHR. En primer lugar, creamos una
instancia de solicitud HTTP XML. Entonces hacemos un abierto
con nuestro método y URL. Entonces vamos a conseguir arena, y luego tenemos función onload
y en función de error para manejar ambos estados incorrectos o una flecha con una solicitud. Ahora veamos si está funcionando. Estoy saltando al navegador
y recargo la página. Y como puedes ver aquí, estamos recibiendo nuestra respuesta
y estamos consiguiendo nuestro éxito de registro de consola
también en nuestra red, puedes ver que tenemos una solicitud wrappers y
esta es solicitud XHR. Y como pueden ver,
este es nuestro adelanto. Esta es nuestra respuesta
desde el backend. Y esto significa que implementamos
con éxito nuestra solicitud de fetch
mediante el uso de solicitud XML HTTP.
30. Fetch API: Otra búsqueda y sobre la
obtención de datos de API está un poco
más actualizada. Esto es lo que estamos
usando todos los días. Aquí tienes una pregunta, ¿verdad? Un ejemplo de obtener
datos usando la API de Fetch. Él Pi es una forma moderna de
cargar algunos datos de API. Y en realidad aquí no
eliminé la solicitud XML HTTP. Se puede comparar código que
escribimos como hace diez años. Y ahora aquí podemos usar la función
fetch y solo
proporcionamos una entrada y get es el método dentro
fetch por defecto, lo que significa que aquí debemos
proporcionar solo una URL. La parte más importante es que Fetch nos devuelve una promesa. Y esto significa que
podemos usar aquí entonces y coger para obtener algunos resultados. Aquí tenemos nuestra respuesta, pero normalmente queremos
convertir nuestra respuesta a JSON. En este caso, podemos
utilizar fácilmente estos datos en cliente. Aquí es donde reservará
en frío res.json, que es una
función asíncrona y
transformará nuestra
respuesta a JSON. Y después de esto,
podemos llamarlos de nuevo. Y aquí vamos a conseguir nuestros datos. Ahora dentro podemos trabajar con
estos datos, por ejemplo, éxito del registro de
consola,
y aquí están nuestros datos. Y como se puede ver, este código es mucho más pequeño y más fácil leer entonces este código antiguo
con solicitud XML HTTP. Y obviamente aquí también
estamos escribió un error y también
queremos manejarlo aquí. Es por eso que aquí
podemos escribir la jaula de puntos. Aquí vamos a conseguir nuestra era. Y ahora aquí podemos
escribir consola log era. Y esto se activará
cuando tengamos un error. Vamos a ver ahora si
este código está funcionando, estoy recargando la página en el
navegador y como pueden ver, estamos consiguiendo un éxito. Aquí están nuestra respuesta. Y como se puede ver
dentro de la red, tenemos nuestra solicitud de rápidos
y el tipo se obtiene. Y aquí está nuestra respuesta, lo que en realidad significa que este código está funcionando exactamente igual, pero se basa en promesas, lo que significa que podemos mezclar
fácilmente este código fue cualquier otro asíncrono que se basan en locales. Por ejemplo, si tienes dos o tres fuentes,
por ejemplo, si tienes varias
fuentes de datos, puedes
combinarlas fácilmente porque todas están
basadas en premisas.
31. Llamada básica: Podría obtener otra pregunta con respecto a un
JavaScript síncrono. Por ejemplo, escribe una función
asíncrona, que ejecuta Kohlberg después terminar su tarea
asíncrona. Y en realidad si no lo
sabes en JavaScript, estamos usando
bastante devoluciones de llamada. Y anteriormente
antes de las promesas y el solo peso que usamos
callback para buscar datos también incluso ahora Kohlberg es una forma
bastante popular de trabajar
dentro de la aplicación. Así que en realidad antes que nada, queríamos escribir alguna función que hará algún código
asíncrono. Y la
forma más fácil de simular en código asíncrono
javascript es
mediante el uso de setTimeout
porque por ejemplo, donde h y algunos datos del
backend y lleva tiempo. Es por eso que quiero
crear aquí una función sinc y
simplemente lo nombran un fregadero, un ventilador. Y aquí queremos conseguir nuestra
devolución de llamada como parámetro. Y en realidad la devolución de llamada
es sólo una función. Pero lo más
importante es que la función asíncrona
no sabe qué es Kohlberg. Puede ser lo que sea porque lo
estamos llamando desde fuera. Ahora dentro estamos haciendo
algún código asíncrono. Por ejemplo,
obtenemos datos de API, o en nuestro caso aquí estamos usando SetTimeout para simular esto. Y hemos establecido el tiempo de espera, por ejemplo, durante dos segundos. Y luego al final libro
uno para llamar a nuestra devolución de llamada. Aquí es donde simplemente
llamamos a esta función o a veces con los datos
como resultado de nuestra API. A lo mejor aquí podemos
escribir Kohlberg hecho, y esta es nuestra
función asíncrona está lista. Ahora cómo estamos usando
esta función, acabamos de probar una función sinc y estamos proporcionando
nuestra devolución de llamada dentro. Esta es una función que se
ejecutará en el interior al final. Es por eso que aquí podemos
decir que estamos recibiendo una función con mensaje de
argumento. Esto es lo que estamos
recuperando de nuestra función
asíncrona aquí podemos escribir el log de consola Kohlberg
y aquí mensaje de coma. Comprobemos si está funcionando. Estoy recargando la página
y como pueden ver, no
tenemos nada ahora después dos segundos estamos
haciendo Kohlberg. Así es exactamente como funcionan las
devoluciones de llamada. Esto es exactamente lo que
implementamos. Tenemos una
función asíncrona que ejecuta Kohlberg después de terminar
su tarea asíncrona. Y la segunda pregunta
que podrías llegar aquí, ¿qué problema resolver la devolución de llamada? Y en realidad hay
dos puntos importantes. En primer lugar, Kohlberg nos
permite hacer algún personal síncrono
y esperar el resultado. Porque en realidad aquí
solo estamos proporcionando una función desde fuera y se llamará
más tarde y no de inmediato. Este es el propósito principal
del Kohlberg. Y en segundo lugar, es
importante recordar que dentro de nuestra función
asíncrona, no
sabemos qué Kohlberg, por eso podemos
construir cosas compartibles. Este Colbert puede hacer lo que sea
en diferentes casos. Por ejemplo, en una página, reserva para buscar datos y
tal vez renderizar estos datos. Y en otra página, queríamos recuperar estos
datos y calcular el número total de publicaciones
o algo así. Lo que en realidad significa que Kohlberg
es una función genérica. Es por ello que podemos compartir fácilmente nuestra
función asíncrona sin la implementación
específica
de nuestra devolución de llamada.
32. Array paralelo de Async: Aquí hay un ejemplo más
de una pregunta síncrona, pero un poco más avanzada, como puedes ver aquí,
tenemos una pregunta. Ejecute la lista dada de funciones
asíncronas en paralelo y devuelve los resultados como una matriz a la devolución de llamada. Como pueden ver aquí,
ya tenemos tres funciones, y esto se da con la tarea. Entonces cada función tiene
aquí dentro de la devolución de llamada, que devuelve 123 parte más
importante aquí, esa primera función
es de tres segundos, luego dos segundos, luego 1 segundo. Entonces debemos escribir la
función como fregadero paralelo. Estamos dentro donde lanzar una matriz de funciones
asíncronas, lo que significa que cada
función es una devolución de llamada. Y luego el segundo
parámetro que tenemos aquí, ONE Kohlberg para
un fregadero paralelo. Aquí estamos obteniendo nuestro resultado y estamos en la consola de inicio de sesión aquí. Y debemos conseguir, en este caso 123
porque debe imprimir
resultados o fisuras, función
síncrona en orden, lo que en realidad significa que estamos
ejecutando tres funciones en paralelo y estamos esperando
para que todos ellos se completen. Y después de esto, tenemos el orden
correcto de los resultados, lo que en realidad significa que
estamos obteniendo resultados de
cada función. Y en realidad estamos usando la moda
paralela, por ejemplo, bastante todos los días porque
queremos, por ejemplo, buscar tres
solicitudes diferentes simultáneamente y luego obtener todos los datos en un solo
lugar y fusionarlos de alguna manera. Esto es y Construyamos esta función ahora, pero no es fácil y
realmente necesitamos pensar
lo que estamos haciendo aquí. Queremos implementar una función paralela de
fregadero. Y en realidad aquí estamos
obteniendo antes que nada, una matriz de nuestras funciones
asíncronas. Para que podamos escribir
aquí me sinc ufuncs. Y el segundo parámetro
es nuestra devolución de llamada. Y lo más importante es un
Kohlberg para un lavabo paralelo, no para la función
func asíncrona específica. En primer lugar, aquí
quiero crear una matriz donde
pondremos nuestros resultados. Aquí. Puedo intentar dar como resultado array. Aquí queremos
escribir nueva matriz y dentro de un sinc
funciones dot length. En este caso, estamos preparados en la matriz vacía con
tres elementos. Y obviamente son
tres sólo para nuestro caso. Y puede ser cualquier longitud de
nuestras funciones asíncronas. Después de esto, quería
crear un contador de resultados, y por defecto será 0 hasta la longitud de nuestra matriz. ¿ Por qué necesitamos eso? Porque en realidad cada sola función
asíncrona se
puede terminar en tiempo aleatorio y
debemos esperar a que todas estas
funciones se completen. Esto significa que debemos
contar cuántas funciones
ya están terminadas hasta que
seamos ricos en longitud. Esto es y aquí vamos a
crear nuestro contenido de resultados. Y por defecto será 0. Y ahora queremos
recorrer nuestras funciones
asíncronas. Así que aquí sincronizo
fuentes dot para cada uno, y realmente
usan for-loop aquí. Y estamos obteniendo acceso para cada función
asíncrona. Y también necesitaremos aquí
un índice porque necesitamos almacenar los resultados también
en el mismo orden correcto. Ahora dentro para cada uno, debemos llamar a nuestra función
asíncrona. Lo más importante es que no sabemos en absoluto lo que esta
función está haciendo. Pero sabemos que esta
función consigue un Kohlberg. Es por eso que aquí podemos
escribir nuestra devolución de llamada. Estamos llamando a una función sinc
sin ningún argumento. Y por dentro nos
proporcionan nuestro colon. Si se activa este codebook, esto significa que estamos listos con nuestra función
asíncrona. Y ahora queremos escribir el
resultado dentro de nuestra matriz. Aquí es donde en realidad estamos obteniendo en nuestro valor de devolución de llamada. Y como puedes ver aquí
dentro de cada devolución de llamada, estamos obteniendo un valor. Y este es exactamente
el valor que
obtenemos un dentro de nuestra devolución de llamada aquí. Ahora, queremos almacenar este valor dentro de
nuestra matriz de resultados. Aquí podemos escribir matriz de
resultados y aquí estará nuestro índice igual a valor. Sólo para recordarte,
tenemos nuestro índice aquí. Es por ello
que sabremos que lo almacenamos correctamente. Por ejemplo, esta es
la tercera función y se activará primero, luego la escribiremos
en la tumba índice. Después de esto, debemos
aumentar nuestro
contador de resultados para saber que se realiza una
de las funciones. Y por último pero no menos importante, queremos comprobar aquí si esta
función fue la última. Aquí, podemos comprobar si nuestro
contador de resultados más grande o
igual a un fregadero ufuncs, entonces queremos llamar a nuestro
Kohlberg para un fregadero paralelo. Entonces aquí podemos simplemente
escribir callback y dentro estamos proporcionando
nuestra matriz de resultados. Una vez más, lo que estamos
haciendo aquí, en primer lugar, estamos preparados una
matriz vacía y nuestro contador. Estamos haciendo un looping a través de nuestras funciones
asíncronas
y estamos llamando a cada una de las funciones aquí se proporcionaron en cada
función, una devolución de llamada. Cuando estamos consiguiendo éxito, primer lugar
almacenamos nuestro resultado dentro del índice de resultados y luego
aumentamos nuestro contador. En este caso, sabemos que esta lógica
nos devolverá Kohlberg para un fregadero paralelo cuando estemos listos y cuando todas nuestras funciones
estén terminadas. Aquí estamos llamando a nuestra matriz de resultados de ancho de
codebook. Ahora en realidad debemos mover esta función antes de nuestra
llamada a un fregadero paralelo, porque debemos
escribirla con const. Y vamos a comprobar si está funcionando. Estoy recargando la página
y estamos consiguiendo una asignación a variable
constante. Echemos un vistazo a esto.
Sí, como se puede ver, se puede
aumentar
un contador de resultados porque es const. Aquí. Podemos escribir LED y
luego debería funcionar. Echemos un vistazo a esto. Estoy recargando la página. No tenemos ningún error. Ahora pasan tres segundos y estamos obteniendo nuestra
matriz con 123, lo que en realidad significa que
aquí hay un sumidero paralelo que espera
a que se
complete cada función
asíncrona y luego regenerar como un Kohlberg nuestro resultado
aquí y ahora podemos usar aquí nuestra matriz en
el orden correcto. Y esto está completamente
bien si no
puedes construir esta función rápidamente. Lo más importante, si lo estás
haciendo en una entrevista, siempre
debes decir nuestra Cloud, lo que estás haciendo y
cómo estás pensando. Porque normalmente una entrevista no
es tan importante. Si resuelves esta
tarea completamente o no, debes mostrar tu
forma de pensar y cómo quieres resolver
esta tarea específica.
33. Convertir Llamada a Promesa: También podría obtener otra pregunta con respecto a
un JavaScript síncrono. Aquí debemos crear la función
premisa para poder usar la función de devolución de llamada
a
través del enfoque Promise. Y en realidad solo
para que sepas anteriormente teníamos muchas funciones de devolución de llamada porque no teníamos premisas. Entonces después de algún
tiempo en JavaScript, migramos completamente dos premisas, y ahora son soportadas
en JavaScript por defecto, lo que en realidad significa
que ya no estamos usando tanto devoluciones de llamada. Y como se puede ver aquí, tenemos una función de
devolución de llamada estándar donde dentro estamos haciendo alguna suposición es fría y
dominamos escribir esta función
para prometer enfoque, que en realidad
significa, por ejemplo, estamos usando alguna biblioteca más antigua que se basa en las devoluciones de llamada, pero todo el código de nuestro
proyecto está usando premisas. Es por ello que tiene
mucho sentido hacer
un rapero y usar esta función de devolución de llamada
a través de la premisa. Para ello,
debemos crear una delgada que se llama la función
Promises phi, que en realidad significa
la misma función pero envuelta y promesa. Podemos nombrarlo de mí, Sci-Fi, y este es el nombre típico
y liberó una función sinc, igual que en la parte superior. Aquí no tenemos argumentos dentro aquí queremos
llamar a nuestra función asíncrona. Y cuando tenemos un codebook, entonces queremos llamar a nuestra
devolución de llamada desde la premisa. Aquí es donde aquí estamos
maestro regreso y tú lo prometes. Aquí dentro promesa
hemos resuelto y rechazado, pero vamos a utilizar aquí en Lou resolver porque no
tenemos ningún error aquí. Ahora dentro de nuestra premisa, podemos simplemente llamar a la función asíncrona regular
y poner una devolución de llamada dentro. Y en realidad esta devolución de llamada nos
devolverá algunos datos. Por eso estoy
escribiendo datos e incluso no sabemos de qué
datos estamos hablando. Ahora en el interior solo queremos llamar
a la resolución y pasar datos de insight desde nuestra función
asíncrona. En este caso, cuando se haga la función
síncrona, entonces
estará sucediendo nuestro Kohlberg. Aquí. Dentro de Kohlberg,
estamos obteniendo datos de una
función síncrona y trabajo de colon en Kohlberg resolver para esta premisa
que creamos. Y lo más importante que esta función
devolverá una promesa. Es por eso que podemos usarlo ahora, como esta premisa de
alta función asíncrona, simplemente lo
llamamos
retornos terminados como premisa. Por eso podemos escribir aquí. Entonces estamos obteniendo
algunos resultados y podemos hacer por ejemplo, resultado del registro de
consola. Estamos usando esta función como
una promesa y hemos envuelto nuestra función sinc en premisa si phi, vamos a
ver esto hacia fuera. Estoy recargando la página
y como pueden ver, estamos recuperando
una después de algún tiempo. Porque aquí tenemos codebook con 3 mil milisegundos, lo que en realidad significa que
estamos obteniendo nuestros datos después de tres segundos y
este código está funcionando. Y ahora
en todas partes de nuestra aplicación, podemos usar esta
función de devolución de llamada en promesa Enfoque.
34. Mapa de datos en Promises: Podría obtener
otra tarea típica de mapear datos con locales. Como se puede ver aquí,
tenemos tal característica. Tiene dos funciones
que devuelven premisas, metadatos de usuarios
y estados de usuarios para obtener matriz de usuarios con nombre
AED y está activo. Como puedes ver aquí, tenemos una matriz de usuarios
con una D y nombre, y tenemos un usuario
secundario etapas con el dN dt es propiedades
activas. Y en realidad este AD es exactamente lo
mismo como una D aquí. Y estos son exactamente los
datos que necesitamos mapear. Entonces necesitamos obtener una matriz
con un nombre DNS y esté activo. Pero el punto principal es que estos datos no están
disponibles rápidamente. Solo están disponibles aquí dentro de obtener usuarios y
obtener estados de los usuarios. Tenemos dos funciones
que son promesas, y típicamente obtendrá
estos datos de la API. Esta es la forma aquí conseguir que los usuarios devolverán falsas promesas. Es por eso que estamos
resolviendo matriz de usuarios aquí y aquí están
lo mismo con los estados de usuario, lo que en realidad significa que
tenemos dos premisas. Debemos
resolverlos y combinarlos. Hay diferentes formas de
cómo podemos resolver esta tarea. El
enfoque más principiante aquí es
buscar la primera premisa
y luego la siguiente. Vamos a probar esto. Ahora. Podemos escribir aquí conseguir usuarios, y esto nos
devuelve una premisa. Aquí es donde aquí
podemos escribir entonces y estamos recuperando
a nuestros usuarios. Ahora después de esto, queremos
recuperar nuestros estados getUser. Aquí estamos llamando a los estados de
GetUser, y también los usamos aquí, y estamos recuperando
nuestros estados de usuario. Y ahora dentro de esta
función tenemos acceso a
estados de usuarios y usuarios. Porque aquí conseguiremos sólo después de resolverlos a
ambos, pero no en paralelo,
sino uno por uno. Lo que podemos hacer aquí,
podemos mapear usuarios, que podamos crear,
por ejemplo, usuarios mapeados. Y necesitamos recorrer
nuestros usuarios con mapa, tenemos acceso a
cada usuario. Y ahora tenemos que encontrar esta es propiedad
activa porque esto es exactamente lo que queremos
poner en nuestra matriz. Es por eso que aquí podemos
escribir const está activo, y aquí queremos encontrar
dentro de los estados de usuario, nuestro estado, aquí es
donde aquí tenemos razón y encontrar el estado de los usuarios. Y aquí necesitamos
revisar el estado del usuario. Dot id es igual a nuestro ID de punto de usuario. Pero esto volverá
más rápido al estatus y debemos probarlo
al final está activo. En este caso, nos pondremos
en la propiedad específica. Ahora después de que conseguimos nuestro ejecutivo, queremos ponerlo dentro de
cada objeto, pero no vamos a usar aquí push porque recuerdas empuja mal. Es por eso que Google
más simple regresa aquí y te objetas y estamos
difundidos aquí. Todos los campos de nuestro usuario. El vidrio es propiedad activa. En este caso, somos Putin es propiedad
activa en
cada usuario. Y después de esto, solo podemos
consola de registro a nuestros usuarios mapeados aquí y están disponibles para nosotros dentro de nuestra aplicación. Vamos a revisar esto. Estoy recargando la página y
estamos consiguiendo ser conocido usuario. Y como se puede ver,
esto como una matriz con tres objetos, ID, name,
y está activo, lo que
en realidad significa resolvemos con éxito esta tarea. Pero hay bastantes problemas en este código. En primer lugar, tenemos dos premisas diferentes y no
dependen el uno del otro, lo
que significa que no
tiene sentido esperar a primera premisa y Don hará
entonces una segunda premisa. En realidad debemos
hacerlas en paralelo. En otros casos, es demasiado lento. Por lo que quiero escribir aquí
que esta es la solución uno y quieren
comentar nuestra primera solución. Ahora probemos la
segunda solución. Para la segunda solución, podemos usar premisa si
no sabes cuál es su premisa. Entonces esto es exactamente
lo que nos está ayudando a hacer varias
premisas en paralelo. Podemos escribir aquí promesa dot o, y debemos pasar matriz
de premisas en el interior. Aquí tenemos una matriz
y podemos escribir aquí, conseguir usuarios y luego coma,
obtener estados de usuarios. En este caso, estamos tirando dentro premisa toda matriz
con nuestras dos premisas. Y después de premisa
todo al final, solo
podemos probarlo entonces aquí vamos a conseguir nuestro
resultado como una matriz, pero no es muy cómodo
trabajar con array aquí. Es por eso que podemos desestructurar
directamente aquí nuestra matriz a
nuestras dos propiedades. Aquí estamos consiguiendo a nuestros usuarios y aquí estamos obteniendo
nuestros estados de usuario. Y después de esto,
podemos hacer nuestra lógica, que hicimos aquí
con usuario mapeado. Es por eso que voy a cortar este
código fue mapeado usuarios y simplemente ponerlo dentro de aquí porque se quedará
exactamente igual. Aquí tenemos acceso a nuestros usuarios y a nuestros usuarios estatus SES, y los estamos mapeando y
consola iniciando sesión aquí. Vamos a revisar esto. Estoy recargando la página y estamos obteniendo exactamente la
misma respuesta de vuelta. El punto principal es
que aquí usamos promesa todo. Esto es mucho mejor
porque en este caso estamos haciendo estas dos
solicitudes en paralelo. También, como se puede ver,
la solución a, pero no tengas este mal
desagradable con entonces y luego, y aquí solo tenemos un
single entonces esto obviamente es mejor porque queremos
evitar este código profundamente anidado, pero podemos hacer que este
código sea aún mejor. Como se puede ver,
tenemos este mapa a los usuarios y en realidad podemos mover este código fuera de nuestro Entonces solo para
hacerlo más legible. Aquí podemos crear función
adicional antes,
por ejemplo, de los usuarios del mapa. Y sabemos que
estamos llegando aquí nuestros usuarios y estados de usuario. Y en realidad esta es una función
completamente pura que acaba de mapear a nuestros usuarios. Para que pueda cortar este código
y ponerlo aquí dentro. Aquí, no
necesitamos nuestra constante. Podemos devolver directamente nuestro mapa. Y en realidad este código será exactamente el mismo como lo
usamos anteriormente. Y ahora lo que podemos hacer aquí, solo
podemos crear usuarios mapeados. Y aquí estamos firmando usuarios de
mapas y estamos pasando dentro de nuestros estados de usuarios
y usuarios. Como se puede ver ahora este
código es aún mejor
leer porque aquí
tenemos simplemente premisa todo. Entonces estamos mapeando
a nuestros usuarios con función
adicional y
trabajamos en así Logan ellos. Vamos a ver esto como se
puede ver por aquí, exactamente la misma respuesta. Y en realidad podemos mejorar esta función incluso
un poco más, como se puede ver,
donde estoy mapeando usuarios de adentro hacia afuera con ellos. Pero en realidad podemos
encadenar nuestro baile, lo que en realidad significa
aquí tal vez queremos directamente devolver
nuestro mapa a los usuarios. Por lo que nuestro primero, luego nos acabamos reunir con los usuarios
y los devolveremos aquí. Y después de este fin de semana, correcto Uno más que, y aquí tendremos a
nuestros usuarios mapeados, y aquí queremos
trabajar con ellos. Por lo que aquí voy a la consola
log a nuestros usuarios mapeados. En este caso, dividimos dos mapeo de danza diferente de los usuarios y trabajando
con éxito. Y en realidad aquí con
consola más simple registran a nuestros usuarios, lo que significa que este es nuestro éxito. Y incluso podemos
quitar retorno de aquí y escribir esto
como una sola línea ella, en este caso
será aún más legible. Yo diría que este código
es lo más seco posible. Es por eso que si quieres demostrar que eres un desarrollador
avanzado, debes escribir tu
código e intentar mejorarlo tantas
veces como sea posible.
35. Reescribir los datos de asignación en Async Await: La siguiente pregunta asíncrona en JavaScript será con seguridad un sumidero de ayuda aquí realmente dominará el ejercicio
anterior, como mapear usuarios con dos premisas en un fregadero,
una función de peso, como se puede ver aquí, tenemos nuestros estados de usuarios usuarios
y dos funciones, conseguir usuarios y obtener locales de usuario. Y
en realidad me pongo en duda nuestro
código anterior para que podamos copiar partes del mismo. Lo primero que
debemos hacer aquí es crear función adicional. ¿ Por qué es eso? Porque no se le permite
escribir de una manera más simple directamente en la parte raíz del archivo
**** JavaScript.
Esto es y aquí. En primer lugar, debemos
crear algo como conseguir usuarios mapeados quizá porque queremos que sea
una función asíncrona. Aquí es donde aquí estamos
usando nuestra palabra clave asíncrona. Aquí estamos creando
nuestra función. Y esta palabra clave asumida nos
permite usar
un peso por dentro. Pero queremos hacer
ahora queremos conseguir nuestros estados de usuarios finales. Aquí puedo simplemente escribir usuarios. No olvides este peso aquí. Sólo estamos tratando de conseguir usuarios. Y si te olvidas aquí un peso, entonces aquí no vamos a
conseguir a nuestros usuarios, pero llegarás aquí una premisa. Y esto no es lo que queremos. Queremos resolver nuestra premisa. La siguiente línea aquí
será el estado de usuario es, y aquí queremos conseguir
nuestro uso de estados. Y obviamente, como se puede ver, este código es
mucho, mucho más fácil de leer
porque no
tenemos ninguno entonces no
tenemos premisa todo. Parece que es
un código sincrónico simple porque las líneas se
ejecutan una por una. Y después de esto, en realidad
queremos copiar, pegar nuestro mapeo y
ponerlo aquí porque no lo
cambiaremos y no tiene
sentido crear una función
adicional. Porque dentro de esta función solo
tenemos dos líneas. Es por ello que aquí podemos
escribir const usuarios mapeados. Aquí estamos asignando el mapa de puntos de
los usuarios y estamos haciendo exactamente lo mismo que hicimos en video anterior. Después de la tercera línea, ya
tenemos nuestros datos de mapa. Aquí podemos escribir mapa de
registro de consola a los usuarios. Y aquí podemos consultar a
nuestros usuarios mapeados, pero también debemos llamar a alguna parte nuestra función get mapped users. No necesitamos escribir
aquí un peso o algo porque simplemente llamamos una función
asíncrona. Ahora, recargaré esta página. Como se puede ver, estamos
consiguiendo usuarios mapeados. Y esta es nuestra respuesta, lo que en realidad significa que este
código está funcionando correctamente. Y este código se ve
súper legible porque
usamos aquí un solo peso
por esto no es suficiente, pero siempre queremos envolver
nuestro código de bytes un try-catch. ¿ Por qué es eso? Porque si aquí
vamos a obtener algún error, entonces nunca lo veremos. Tendremos un error
y atrapado premisa. Es por eso que aquí queremos
al principio escribir prueba aquí al final después nuestro cupón de registro de consola para
cerrarlo y secarlo aquí, jaula y aquí estamos recibiendo
nuestro error dentro de nuestro efectivo. Queremos escribir algo así
como el registro de consola Azure. Y aquí hay error
que podemos conseguir. En este caso, estamos del lado
seguro y sabremos si algún código asíncrono no
funciona aquí o estamos
recibiendo algunos errores, entonces
arrojaremos un
error aquí dentro catch. Vamos a revisar esto. Nuestro
código sigue funcionando y utilizamos
con éxito
el peso singular a la derecha son
promesas con él.
36. Debes usar el vocabulario correcto: Una cosa más importante
a recordar es bastante complicado y la gente no está
hablando mucho de ello. Y aquí estoy hablando de
tu vocabulario de programación. Lo que quiero decir con eso, en realidad, hay muchas palabras que
puedes usar cuando estás
hablando de programación. Entonces persona te entiende
mejor o al menos correctamente, y no debes mezclarlos. Hay un comienzo. Podría ser realmente difícil para ti porque no conoces todos estos términos o
no estás realmente seguro de lo
que quieres decir, pero necesitas tenerlo en cuenta y tratar de mejorar con el tiempo. Por ejemplo,
realmente debes entender
lo que estás diciendo. Por ejemplo,
mostré una función o creé un método
dentro de mi clase. Esta es una instancia
de la clase. Debes usar todos estos términos correctamente si ves una función, pero estás llamando a ese método, o tal vez
lo estás llamando otra cosa. Esto no es correcto. Y luego obtendrás muchas preguntas
adicionales o
serás visto como un mal desarrollador. Por supuesto que no quieres eso. Es por eso que necesitas
pensar un
poco qué palabras estás usando e intentar usarlas
correctamente cuando estés describiendo algunas cosas de
programación.
37. Gerente de Solicitud de Diseño: Aquí hay otra tarea
síncrona, que es un poco compleja. Por lo que necesitas algo de
tiempo para resolverlo. Y realmente no se puede resolver como en tres
o cinco minutos. Como puedes ver aquí,
debemos diseñar una utilidad que tome una URL y
el valor para los intentos, que intentará
hacer una solicitud de fetch. Si tenemos un fallo, entonces esta función intentará de
nuevo recuperar algunos datos con un retraso creciente por número de veces que
el usuario ha solicitado. que en realidad significa que debemos crear una función
que va a buscar una URL específica que vamos a proporcionar y también tener
alguna cantidad de intentos. Y queremos refrescar
estos datos una y otra vez varias veces si
no recibimos un mensaje de éxito. Y en realidad este es un problema
realmente común porque a veces nuestra API no
está funcionando o los datos no están ahí y queremos
intentarlo de nuevo. Vamos a tratar de crear esta función y
quieren nombrarla, por
ejemplo, gestor de solicitudes. Y en realidad aquí vamos a
conseguir nuestra URL porque
queremos buscar algo desde el exterior y cada
vez algo nuevo. Y aquí tenemos algunas
opciones para nuestra URL. Y el último parámetro
serán intentos. Y por defecto pueden
ser tres, por ejemplo. Por lo que estamos tratando de refrescar a
algún personal tres veces. Así es como vamos a utilizar esto. Por lo que tenemos aquí gestor de solicitudes y nos proporcionaron alguna URL. Usarán aquí alguna
URL que no existe. En este caso, lo
actualizaremos. Tenemos foo.com y esta función debe
devolver premisa más rápida, es donde aquí
tenemos, entonces, aquí tenemos éxito y error. Aquí es donde aquí estamos esperando alguna respuesta y
solo podemos probarlo log de consola, por ejemplo, respuesta para
comprobar si está funcionando. Así es como
típicamente usaremos esta función. Queremos buscar alguna URL
y simplemente las tenemos. Y obviamente aquí
podemos pasar algunas opciones. Por ejemplo, método
post y alguien, o cantidad de intentos si
queríamos cambiarlo, si no pasamos nada, entonces aquí no
tenemos ninguna opción y nuestro intento es tres. Ahora la pregunta es ¿qué
queremos volver aquí? El punto más importante para entender cómo lo construiremos. Vamos a ejecutar esta función
recursivamente porque esta es una forma más fácil de llamar a esta función varias veces, es que llamaremos de nuevo en el
gestor de solicitud de jaula aquí. Y simplemente
proporcionaremos aquí dentro opciones de
URL y luego intentos, vamos a disminuir, lo
que significa que al principio
tenemos tres intentos. Ahora la próxima vez
serán dos, luego uno, y luego arrojaremos
un error porque
no tenemos ningún intento
restante. Entonces, antes que nada, debemos devolver una promesa porque esto es
lo que estamos esperando afuera. Y aquí es donde aquí estamos
regresando, lo prometes, y aquí tenemos nuestra
determinación y rechazo. Ahora dentro de esta función, queremos intentar
buscar nuestros datos, y simplemente usaremos
aquí la función fetch porque está disponible
para nosotros de forma nativa. En su interior estamos pasando en
primer nuestra URL y en segundo lugar opciones. Y ahora aquí tenemos nuestra, entonces tenemos atrapar y
en realidad entonces podemos simplemente
llamar nuestra determinación. Esto pasará los
datos de éxito directamente dentro de resolver, porque Resolve es una función. Aquí. También queremos una captura. Aquí dentro de la jaula. Queremos hacer nuestra matriz. Por lo que aquí estamos recibiendo
nuestro error y queremos llamar de nuevo a nuestro gestor de
solicitudes. Pero aquí debemos saber cuándo
voy a intentar es el último. Por lo que aquí quiero crear una
propiedad es el último intento. Y aquí solo podemos comprobar
si nuestro intento es igual a uno. En este caso,
sabremos, bien, esta es la última vez cuando
podemos llamar a nuestra gestión de solicitudes. Y después de esto estamos comprobando
si este es un último intento, entonces queremos
devolver la flecha de rechazo, lo que en realidad significa que solo
estamos rechazando nuestra premisa porque ya no podemos continuar después de este EQ, pero no tienen 0s último intento, entonces queremos hacer
setTimeout porque en realidad queremos llamar a esta
función después de algún tiempo. No tiene sentido
llamarlo directamente después, porque tal vez API aún está abajo. Aquí. Escribiré setTimeout, por ejemplo, con tres segundos. Y obviamente también podemos
implementar un argumento para pasar el intervalo
para llamar a datos. Dentro de SetTimeout, queremos
solicitar de nuevo nuestros datos. Por lo que aquí llamaremos a gestor de
solicitudes y estamos pasando aquí
URL ahora opciones. Y el último
serán intentos menos uno, lo que en realidad significa que no
iniciamos intentos en ninguna parte. Simplemente proporcionamos recursivamente en gerente de solicitud disminuyó cantidad de intentos. Esto es y aquí la
primera vez que son tres, luego venimos
aquí en SetTimeout. Es a uno. Y luego revisamos este
intento igual a uno y estamos aquí dentro de esta IV
y lo estamos rechazando. Así que vamos a comprobar si está funcionando. Estoy recargando el navegador. Y como se puede ver,
estamos consiguiendo obtener y una flecha porque esta
URL no existe y estamos consiguiendo intentos no
se define en línea 13 dentro de nuestro tiempo de espera establecido. Y en realidad el nombre
del argumento aquí no
es correcto. No es intento, sino intentos porque
tenemos varios de ellos. Y también aquí debe ser intentos igual a uno
y no intento. Volvamos a cargarlo. Como se puede ver, estamos
consiguiendo obtener cabecera. Después de tres
segundos estamos recibiendo esta solicitud de nuevo porque lo
intentamos de nuevo y luego otra vez. Aquí tenemos un
error no capturado no pudo buscar, lo que en realidad significa que aquí
debemos escribir no sólo ellos, sino también caché, porque
aquí vamos a obtener un error si no podemos obtener datos. Y aquí solo podemos
probarlo error de registro de consola. Y aquí queremos
ver nuestro error. Pero como se puede ver, seguimos obteniendo un error unquote type
pair de fallido al terminar, lo que significa que nuestro código no
es un 100% correcto. Y en realidad el problema es aquí que esta es nuestra primera llamada de gerente de solicitud y lo estamos
manejando afuera
con luego y atrapar. Pero aquí en cambio SetTimeout
tenemos gestor de solicitudes, pero no tenemos entonces y atrapamos esto es por
lo que se está rompiendo. Tenemos un error
en nuestro tercer carbón, y esto está aquí, pero no
especificamos qué
pasará con él. Esto es lo que aquí,
boom, debe escribir. Entonces aquí queremos
resolverlo con datos y también atrapar y en efectivo simplemente
queremos rechazar. En este caso,
funcionará correctamente. Probemos esto. Estoy recargando la página. Estamos consiguiendo a través de
errores y ahora nuestro error se burbujea afuera y vemos que
TypeError falló en buscar. En este caso, está
funcionando correctamente. No debes olvidar burbujear a nuestro gerente interno de solicitudes
afuera con entonces y coger. Por lo que puedo decir que esta función
es bastante complicada. Entonces si recibes algo
como esto en la entrevista, realmente
debes tomarte tu
tiempo para resolverlo correctamente. Realmente no se puede diseñar tal función en
cuestión de minutos.
38. Implementar Comparación poco profunda: También podría obtener una
pregunta con respecto a la igualdad o comparación
dentro de JavaScript. Y como se puede ver aquí,
tenemos una pregunta, diseñadores función de
comparación superficial. Para ello, debes conocer la diferencia de comparación de
JavaScript, que es nativa, comparación poco profunda y
comparación profunda. Dentro de JavaScript, podemos
simplemente escribir uno es igual a dos. Nos estamos volviendo falsos.
Uno igual a uno es cierto. Esto está funcionando porque
estamos comparando primitivas. Pero si vamos a
comparar aquí un igual uno y aquí hay
un objeto a igual a uno, nos estamos
volviendo falsos. Considerando que porque no podemos comparar objetos como este en JavaScript porque
están haciendo referencia diferentes objetos
dentro de la memoria. Y tienes exactamente el
mismo problema con la matriz. La matriz vacía no es
igual a matriz vacía. Sí, podemos entender por
qué está funcionando así, pero no es
cómodo porque normalmente los desarrolladores
quieren comparar matrices y objetos por valores y no como referencia al
objeto en la memoria. Es por ello que tenemos funciones de comparación
superficial y comparación profunda. Entonces la idea es que comparación
superficial es
más rápida que la comparación profunda, pero solucionará problemas con comparación de objetos o matrices. Se arreglará sólo las matrices no
anidadas son objetos, lo que en realidad significa si lo
haremos con comparación superficial, comparamos a, y aquí tenemos un objeto con B1 y aquí B1,
seguiremos obteniendo respuesta equivocada incluso con la función de
comparación superficial. Esto es completamente normal
porque en este caso, queremos comparar cada valor
único anidado, y luego debemos usar comparación
profunda. Y la comparación profunda es extremadamente lenta porque estamos revisando
cada valor, pero seguro te
dará una respuesta verdadera. En este video, debemos escribir una función de comparación superficial, lo que significa que queremos arreglar comparación de
matrices y objetos, pero no debemos comparar matrices y objetos
anidados. Así está funcionando la
comparación poco profunda. Y en realidad aquí tengo un tipo
de función
adicional de la cual nos ayudará tremendamente en la construcción de comparación
superficial. Y como se puede ver en el navegador, simplemente
podemos usar typeof en
diferentes tipos de datos. Por ejemplo, para el número, estamos obteniendo un número
tenso para palabra de
cadena en lugar de
obtener una cadena. Y aquí podemos escribir un objeto y luego
estamos obteniendo un objeto, lo
que en realidad significa que es realmente agradable
obtener el tipo de nuestra
variable como una cadena. Para nosotros, la parte más
interesante es este prototipo de objeto
para transmitir entrada de llamada. Y como se puede ver en
la entrada donde
por ejemplo uno y estamos
obteniendo el número de objeto. Y en realidad esta expresión
regular aquí simplemente moverá objeto y obtendremos
esta parte con número. Así es como esta
función está funcionando. Aquí quiero crear nuestra función de comparación
superficial. Debemos aportar
aquí dos argumentos. Entonces tenemos fuente y objetivo, y estas son dos cosas
que queríamos comparar, por
ejemplo, dos variables. En primer lugar, queremos comparar un tipo de datos porque si
tenemos un tipo de datos diferente, entonces no debemos hacer nada y significa que no
son iguales. Es por eso que podemos escribir aquí. Si typeof source
no es igual typeof, entonces aquí podemos
simplemente devolver false. Es por eso que es
super rendimiento. No comparamos nada. Simplemente conseguimos un tipo
compararlos y estamos fuera después de este boom hay que escribir
lógica para nuestras primitivas. Y aquí podemos simplemente usar comparación
JavaScript nativa
simple. Estoy escribiendo aquí si fuente es igual a tres
igual a hoja de estilo, entonces aquí estamos volviendo, lo que en realidad significa
esta sola línea. Vamos a comparar o primitivas. Y ahora solo necesitamos construir casos para nuestros
objetos y matrices. En primer lugar, vamos a
cubrir nuestras matrices. Aquí queremos comprobar el tipo de
nuestra fuente es igual a array. Entonces queremos
aplicar esta lógica. Y podrías preguntar, vale, pero ¿por qué solo estamos comprobando
fuente y no un detergente? Porque en realidad
aquí en la parte superior, ya
sabemos que tanto fuente como objetivo
del mismo tipo. En otros casos,
ya estamos fuera de la función. Aquí. Sabemos que la fuente
y el destino son ambas matrices y ahora
queremos compararlas, pero en realidad podemos hacer alguna mejora
del rendimiento. Aquí podemos comparar sólo
una longitud de dos matrices. Y si son diferentes
de lo que no debemos comparar nada
porque no son iguales. Entonces aquí puedo escribir IV, fuente, tierra no equivale a
nuestra longitud objetivo. Entonces estamos aquí afuera,
simplemente devuélvete falso. Ahora queremos comparar
estas dos matrices, y la forma más fácil de
hacerlo es usar promedio. Estamos revisando
cada elemento dentro de una matriz y lo comparamos. Aquí quiero escribir fuente de
retorno cada, así que estamos revisando
cada elemento de la fuente. Y aquí tenemos acceso
a elemento e índice. Y lo que podemos hacer aquí mismo es que nuestro elemento equivale al índice objetivo. En este caso, estamos comparando
cada elemento de nuestra fuente con cada uno de los
elementos del objetivo. Pero como puedes ver aquí, estamos usando la comparación nativa de
JavaScript, lo
que significa que
funcionará para primitivas, pero no funcionará, por ejemplo, para objetos o matrices,
¿cómo se ve? Volvamos a cargar la página y justo aquí nuestra función, comparación
superficial. Y podemos proporcionar ahora
array con primitivas. Entonces aquí tenemos 11 y
nos estamos volviendo verdaderos, lo que en realidad significa que
nuestra función está funcionando correctamente porque el
JavaScript
nativo no
se puede comparar 11, será falso y nuestra
función está funcionando correctamente. Ahora debemos probar el
código similar para nuestro objeto. Es por eso que aquí podemos escribir si typeof source es igual a objeto, entonces queremos aplicar nuestra lógica. Y de nuevo, quiero mejorar el
rendimiento. Esto es y aquí. En primer lugar, podemos
comprobar, por ejemplo, las claves de
objeto y
comparar la longitud de las claves si la longitud es diferente a estos objetos
son con seguridad diferentes. Por lo que aquí podemos escribir claves de punto de
objeto. Aquí tenemos fuente y
estamos comparando la longitud. Entonces aquí longitud no
equivale a nuestras claves de punto objeto, y aquí tenemos nuestra longitud de punto
objetivo. En este caso,
podemos simplemente devolver false y
no debemos hacer ninguna comparación. Y en realidad aquí ahora
necesitaría comparar objetos. Entonces para esto,
también usaré cada. Entonces aquí quiero devolver
nuestras claves de punto objeto, y estoy obteniendo una matriz de cadenas de claves de nuestro objeto. Y aquí estamos
brindando nuestra fuente. Después de esto, podemos usar todos y aquí como un elemento
cada uno. Estamos consiguiendo nuestra llave. Ahora podemos comparar clave fuente. Entonces estamos obteniendo
el valor y
comparamos aquí clave objetivo. En este caso, estamos comparando cada valor único
de nuestro objeto. Pero como se puede ver con la comparación de JavaScript
simple, lo
que significa que
funcionará para primitivas, pero no funcionará para elementos anidados
profundos.
Echemos un vistazo a esto. Voy a recargar la página. Aquí está nuestro comparador superficial. En este caso, queremos comparar
objeto a y objeto
que desee. Y como puedes ver
aquí, tengo algún errata. Aquí no hay fuente. Vamos a cambiar esto. Ahora como se puede ver,
está funcionando y podemos comparar nuestros objetos. Y en realidad ahora quiero una comparación
más para las fechas, y esto es extremadamente
fácil de hacer. Aquí. Podemos probar tipo de
fuente es igual a estado. Entonces queremos comparar solo dos números porque
en realidad podemos comparar cada fecha dos milisegundos y comparar números es
extremadamente eficiente. Es por eso que aquí podemos escribir
retorno fuente dot obtener tiempo. Esto obtendrá milisegundos
es igual a punto objetivo obtener tiempo. Y en este caso simplemente
estamos comparando dos números y esto
está totalmente bien. Así es como estamos construyendo la función de comparación
superficial. Y en realidad así es
como quiero ver comparación por defecto
en JavaScript, pero desafortunadamente
no la tenemos. Es por eso que debemos construir esta función por
nuestra cuenta o usarla desde alguna biblioteca como Rumba
la dash o simplemente paquete NPM. Si estás respondiendo a
esas preguntas sobre la comparación superficial, debes decir que es super rendimiento en
comparación con la comparación profunda, pero no puede comparar elementos
anidados, que está totalmente bien. Y solo necesitas saber para
qué caso lo estás usando.
39. Implementar una comparación profunda: En video anterior escribimos la función comparación superficial. Pero también puedes conseguir
una pregunta, ¿de acuerdo? Pero, ¿cómo podemos escribir la
función para una comparación profunda? Esto es lo que queremos
hacer en este video. En realidad, como se puede ver, no
eliminé ningún código. Tengo aquí un tipo de comparación y poco profundo y quieren
copiarlo y pegarlo completamente y comparar más adelante con comparación
profunda. Es por ello que, como se puede ver, copio pegado toda la
función y
solo quieren renombrarla para comparar en profundidad. Y en realidad el código será 90% similar porque en
primer lugar, queremos comprobar el
tipo de datos y es permanecer igual y
que al final vamos a comparar fecha y fuente y destino para primitivas
de la misma manera. Así que en realidad la biomasa
solo cambia
la comparación de nuestras matrices y objetos y en realidad
incluso el código dentro será casi el mismo. Entonces, antes que nada, para carrera,
estamos comprobando longitud. Aquí tenemos todos, pero aquí debemos eliminar
nuestra comparación de elemento porque es comparación
nativa. Pero aquí queremos recursivamente revisar
cada elemento. Es por eso que aquí
podemos simplemente escribir comparación
profunda y estamos tirando dentro de nuestro elemento índice de objetivo de
coma. En este caso, lo que estamos haciendo, estamos colon profundo comparar de nuevo. Y en realidad aquí podría
ser que tengamos un objeto, entonces estamos viniendo recursivamente
y decimos comparación profunda. Y vamos a comparar el tema y lo estamos
haciendo una y otra vez hasta que comparemos todo
el objeto o toda
la matriz. Y no importa cuán profundo sea el sujeto ni cuán
profundo sea este arrays, lo que en realidad significa que
esto no es rendimiento. Esto es realmente lento, pero te dará la respuesta correcta cuando
estés trabajando con datos
anidados y exactamente lo
mismo debemos hacer ahora
con nuestros objetos. Aquí podemos dejar nuestra
comparación con llaves. Esto está totalmente bien. Aquí tenemos nuestro Cada, pero debemos eliminar esta comparación y llamar a
deep compare en su lugar. Y estamos pasando
dentro de nuestra
clave fuente y aquí clave objetivo. En este caso, estamos comparando dos valores de nuestro
objetivo y de nuestra fuente. Y también lo estamos haciendo
con profunda comparación. Y esto es en realidad,
transformará completamente nuestra
función de comparación superficial en comparación profunda. Vamos a ver esto ahora, voy a recargar la página aquí, el poco profundo compare A1, A1, es cierto, pero en realidad
aquí dentro de poco profundo compare, si voy a lanzar un B1, así que tenemos un
objeto anidado y aquí un B1, devolverá false,
lo que en realidad significa que la comparación
superficial no
puede funcionar con datos anidados. Pero aquí estamos llamando a nuestro profundo compare y nos estamos haciendo realidad porque dip compare es recursivo y se
comparará n en estan correctamente en exactamente lo
mismo que tenemos para una carrera. Por ejemplo, si tenemos
aquí una matriz de matrices, digamos array con array one. Y aquí tenemos array
y array uno dentro. Como se puede ver, nos
estamos pasando y
podemos comparar matrices de cualquier nivel.
40. Crear una función de Memoization: También podría obtener una
pregunta sobre la memorización. Aquí como se puede ver
donde la máscara diseña una
función de memorización que suma diez para proporcionar valor y tomarlo de la caché si fuera
todo lo calculado. Si no sabes qué significa
la memorización del término en
JavaScript, significa que estamos
almacenando valores en caché para evitar volver a hacer la
misma operación, lo que en realidad
significa, por ejemplo, queremos restar dos números. Y si lo hicimos con anterioridad y ya
sabemos la respuesta, entonces debemos simplemente devolver el sensor y no volver a
calcularlo. Obviamente no tiene sentido
hacer que nos restemos o algunos, pero tiene mucho
sentido cuando
tenemos algunos
cálculos difíciles. Es por ello que aquí debemos construir un ejemplo de función de
memoización. Y en realidad
no es tan difícil. Entonces aquí quiero crear
una función memorizar, agregar. En cambio esta función.
No necesitamos ningún argumento, pero queremos crear
un caché en su interior. Es por eso que aquí voy a
crear propiedad en efectivo. Esto es sólo un objeto. Ahora aquí quiero
devolver una nueva función. Y se puede ver que este es
un cierre porque en realidad podemos almacenar encendido con algunas variables cuando
tenemos un cierre. Es por eso que aquí devolveré
la función con valor. Ahora aquí es cómo lo estamos
usando afuera. Aquí queremos crear nueva función add y
simplemente lo llamamos MIS add, en este caso, nueva
función de usuario de AD y podemos utilizarla. Es por ello que aquí
podemos escribir nuevo anuncio, por ejemplo nueve, y
este es nuestro valor. Y haciendo este caso
será de salida 19 calculado por 19 porque realidad como se puede
ver en nuestro futuro, debe sumar diez a
nuestro valor proporcionado. Estamos tirando dentro de
las nueve y estamos recuperando 19. Pero en realidad cuando estamos llamando nuevo anuncio con Snyder, de nuevo, la salida será también 19, pero debe
tomarse del cache. No debe calcularse. Nuevamente, esto es exactamente lo que está haciendo
la memorización. Ahora solo necesitamos implementar
esta lógica de memoización. Entonces aquí podemos escribir si
tenemos un valor en efectivo, así que estamos comprobando si tenemos tal válido dentro de nuestro objeto, entonces queremos simplemente devolverlo. Y aquí quiero
escribir el log de consola puedas ver
que está minimizado. Aquí va a ir a buscar de dinero en efectivo. Y después de esto, quiero
escribir devolución en efectivo. Y aquí está nuestro valor. Como se puede ver, aquí no
hacemos ningún cálculo. Simplemente devolvemos valor
y también tendremos otra cosa. Y aquí tenemos
cálculos estaban justo aquí
calculando los resultados. Y después de esto,
realmente debemos calcularlo. Entonces vamos a crear aquí un
valor, por ejemplo, resultado. Y queremos poner
aquí valor más diez. Y después de esto debemos ponerlo en efectivo antes de devolverlo. En este caso, estamos almacenando nuestro resultado para la siguiente raya. Aquí es donde aquí podemos escribir valor
en efectivo equivale a resultado. En este caso, estamos asignando
efectivo para nuestro número nueve. En este caso cuando, cuando la
próxima vez aquí nueve, entonces estamos obteniendo
el valor del efectivo. Y después de esto,
simplemente podemos devolver nuestro resultado. Y este es solo el valor
que calculamos aquí. Echemos un vistazo a esto. Estoy recargando la página. Como se puede ver, estamos obteniendo el
cálculo de los resultados finales. Este es nuestro primer intento
aquí y calculado 19, lo que en realidad significa que
realmente calculamos algo. Pero la segunda vez que este carbón, tenemos sacando del efectivo 19, lo que en realidad significa que
no calculamos esta vez, este número, pero lo
tomamos del efectivo. Y así es como típicamente
implementa la memorización. Se puede conseguir tarea diferente, pero la idea es la misma. Tienes algo de efectivo, tienes un cierre, y debes entregar el
valor del cache y ponerlo en el cache
en el primer cálculo.
41. Fibonacci: Bienvenido a algunas preguntas realmente
hilarantes, porque estas cosas nunca
usarás en tu vida cotidiana
como programador, pero debes
saber resolverlo. Y el primero aquí, que es mi diseño favorito, una función que devuelve si Fibonacci
valor de secuencia y
no intentaron funcionar para obtener el valor de Fibonacci
en los últimos 12 años, lo que en realidad
significa que no es necesario. Pero constantemente escucho esta pregunta una y otra
vez en la entrevista. Y en realidad creo
que está totalmente bien preguntar al entrevistador. Vale, no sé una
fórmula para Fibonacci. ¿ Puedes por favor guardar y
luego lo pueden codificar. No es un problema. Esto está totalmente bien
porque no debes saber de memoria todas las fórmulas
matemáticas. Aquí es donde aquí realmente
puedes conseguir algo como esto como resultado
para tu pregunta. Entonces aquí se puede ver
que la secuencia de Fibonacci es una secuencia entera
donde los dos primeros términos son 01 después de que el siguiente término se define como una suma
de dos términos anteriores. Y el término else es la suma de n menos uno y n menos dos, lo que en realidad significa que este es un inicio típico de la
secuencia que tenemos aquí 0112. Y como pueden ver
aquí, podemos sumar por
ejemplo 11 y estamos llegando hasta aquí con unos 12 y nos estamos poniendo tres
y así sucesivamente y así sucesivamente. Entonces, como podemos resolver esto, debemos proporcionar una función R, un valor de secuencia de Fibonacci, que en realidad significa el
índice en la secuencia. Por ejemplo, si vamos a
proporcionar siete como argumento, entonces debemos llegar aquí
en banda a banda, porque en realidad vamos a
resumir 813 y estamos recibiendo 21. Ahora llamemos a este ejercicio. Y en realidad aquí
vamos a utilizar la recursión porque queremos
calcularla recursivamente. Aquí podemos crear una función
Fibonacci y llegamos aquí n, que es nuestro índice aquí. En primer lugar, debemos comprobar
si son menos de dos, porque en este caso
nuestros lazos lógicos funcionan porque aquí tenemos 01. Aquí es donde aquí
debemos revisar, ¿de acuerdo? Si n menos de dos, entonces aquí queremos devolver uno. En otros casos,
debemos aplicar nuestra lógica. Aquí simplemente devolvemos Fibonacci, y aquí estamos
pasando n menos dos, lo que en realidad significa que
calculamos esta función recursivamente y cada llamada
recursiva de Fibonacci, llamaremos una y otra vez hasta que llegaremos a
esta primera condición. Aquí tenemos
Fibonacci n menos dos más Fibonacci y menos uno. Y en realidad este es todo el
código que debes probarlo. Echemos un vistazo a esto. Simplemente saltaré a la consola y justo aquí Fibonacci siete. Y como pueden ver,
estamos recibiendo 21, lo que en realidad significa que
nuestro código está funcionando. Pero aquí hay algunas
cosas importantes que recordar. Como programador,
debes saber
convertir fórmulas matemáticas o alguna lógica. En JavaScript, las
funciones son funciones en cualquier otro idioma, pero está totalmente
bien no saber de memoria todas las fórmulas matemáticas. Es por eso que no debes
tener miedo de preguntar por ellos. Y en segundo lugar,
creo que está totalmente bien preguntar a cambio. Ok. Realmente no puedo codificar, pero ¿estás usando estas cosas todos los días
en tu proyecto? Y probablemente
obtendrá una respuesta no. Es por eso que en realidad
no tiene sentido preguntar estas
cosas en primer lugar.
42. Palindrome: Una pregunta más popular
que estoy escuchando mucho es por favor escribir una función
para revisar el palíndromo. Porque en realidad esto es lo que los programadores están haciendo
todos los días. Están revisando palíndromes. Pero lo que sea que podamos resolverlo. En realidad, si no
sabes qué es el palíndromo, esta es una cuerda que es la misma desde el principio
y desde el final. Por ejemplo, si
tienes cadena completa, no
es un palíndromo. Pero si tienes, por ejemplo, para o cuerda completa, es un palíndromo porque es la misma fuerza del
Stat y desde el final. Así que probemos esto ahora. Y en realidad es realmente fácil. Lo que queremos hacer aquí, queremos crear una
función es palíndromo. Y lo que queremos hacer con
uno para resolver con prudencia. Y en realidad no tiene
sentido dividirlo por letras y revisar
cada letra y así sucesivamente. Simplemente puedes revertir
una cuerda y compararla. Es por esto que aquí podemos
escribir que nuestra cadena igual y podemos
compararla con cadena dot split. Y aquí solo proporcionamos
una cuerda vacía. Entonces lo dividimos por letras
ahora con solo hacer reversa,
retroceder en nuestra matriz y
luego lo estamos uniendo de nuevo, lo que en realidad significa
donde el revés en este mundo y estamos
comparando dos mismas palabras. En este caso obtendremos la misma cadena si
son iguales. Vamos a revisar el Sur
aquí donde justo en palíndromo del
Este y estamos brindando una visión completa
y nos estamos volviendo falsos. Pero si vamos a escribir foo, foo, entonces nos estamos haciendo realidad. Se resuelve la tarea.
43. Anagram: Una pregunta más que
escucho a menudo es escribir la función que comprueba
que la cadena es un anagrama. Y en realidad este material es súper similar al palíndromo,
como puedes ver aquí, anagramas de palabras que tienen los mismos caracteres
en la misma cantidad, lo que en realidad significa que dos
cadenas son anagramas si podemos reorganizar cuerdas
y conseguir el otro. Y aquí hay algunos
ejemplos de anagramas. Por ejemplo, escuchar
y callar y así sucesivamente. Entonces ahora vamos a escribir la
función es anagrama. Aquí tenemos ys
anagrama y sabemos que estamos llegando
aquí dos fortalezas que queremos comparar. Vamos a nombrar es 31
y transmitir dos. Entonces lo que queremos
comprobar aquí es que estas dos cadenas tienen
las mismas letras. Pero para comprobar esto, debemos ajustar ordenar nuestras cadenas. En este caso, podemos simplemente comparar las cuerdas por igualdad. Pero antes que nada, me
gustaría revisar aquí una longitud, porque si tenemos diferente
longitud en estas dos cuerdas, entonces no funcionará. Es por esto que aquí, si longitud de nuestra primera cadena no igual a la longitud de
nuestra segunda cadena, entonces simplemente devolvemos false
y no verificamos nada. Y por supuesto aquí
debe ser bancario y no igual porque queremos comprobar
que no son iguales. Lo segundo que
queremos hacer es convertirlo minúsculas porque en realidad
podemos tener diferentes casos, pero las cadenas
siguen siendo válidas. Esto es y Nombrémoslo filamento inferior uno. Y aquí simplemente llamamos
string1 a minúsculas, y tenemos dos minúsculas
directamente dentro de JavaScript. Aquí vamos a nombrar la cadena más baja, y estamos convirtiendo
cadena a minúsculas. Ahora lo que queremos comprobar, queremos comprobar si estas
dos cadenas son iguales. En este caso, dominamos en falso porque no
son anagramas. Es por eso que aquí
escribiré el flujo de cadena1 es igual a la cadena
más baja dos, entonces esto es falso y
esto no es un anagrama. Y el último
debemos escribir nuestra lógica. Y lo que quiero hacer, quiero más simple convertir
nuestras cadenas a matriz que
cierta matriz y fusionarla directamente de nuevo en cadena
para este fin de semana, ¿verdad? Por ejemplo, ordenó la cadena uno, y aquí vamos a escribir la cadena
más baja una división de puntos. Y aquí queremos
dividir solo por letras. Y aquí solo estoy llamando
sort sin ningún argumento. Se ordenará de alguna manera. Y después de este **** uno para recuperar una cuerda, esto es y aquí. Únete nos traerá de vuelta una cuerda. Quiero hacer exactamente lo
mismo en la segunda cuerda. Y aquí ahora podemos
compararlos porque en este caso ordenamos todas nuestras letras en
la misma dirección. Y ahora aquí puedo
simplemente escribir return cadena
ordenada uno es
igual a cadena ordenada. En este caso, estamos comparando dos cadenas que fueron ordenadas, y ya sabemos que es entrar a Chrome si son iguales, vamos a ver esto hacia fuera. Estoy saltando al navegador y
estamos escribiendo es anagrama. Aquí, sólo estamos
proporcionando completa y Byron. Y como se puede ver, es falso porque se trata de dos cadenas
diferentes. Pero ahora intentemos con escuchado
y silencioso. Por ejemplo. Aquí estoy escribiendo lección, y a la derecha
estoy escribiendo en silencio. Y en realidad estamos
llegando aquí verdad, y está funcionando lo que
estamos haciendo aquí. En primer lugar, estamos comprobando
si la longitud es la misma. Bienvenido aquí,
tenemos dos fortalezas, minúsculas, así que no estamos aquí. Y ahora solo estamos
seguros de estas dos cadenas que fueron
convertidas a nuestras matrices, y luego
las estamos convirtiendo de nuevo en cadenas. En este caso, estamos consiguiendo
algo como E y St. pero está totalmente bien porque
queremos simplemente compararlos. Y así es como estás escribiendo función para comparar anagramas.
44. Encontrar vocales: También podrías conseguir
una tarea como esta. Escribe la función que
cuenta vocales en la cuerda. Y no siempre son vocales, sino algo que
debes contar en la cuerda. Y en realidad
no es tan difícil porque la idea principal
es que primero
debemos definir algo así como matriz de posibles tambores
o posibles símbolos. Y luego solo intenta revisar cada letra dentro nuestra fuerza. Hagamos esto ahora. En primer lugar, aquí
queremos crear una función phi y vocales, y estamos llegando aquí
string como argumento. Ahora segundo hígado debe
definir lo que nuestras vocales. Aquí podemos crear vocales
array y vamos a definir aquí a, e, I, o, y u
Y podemos resolver con,
con dos formas diferentes, ya sea con for-loop
siempre reducir y en realidad ambos
están bien. Aquí. En primer lugar, quiero crear un contador porque queremos
aumentarlo cada
vez que encontremos nuestra vocal, necesitaría un bucle for. Entonces aquí podemos escribir el carácter
principal fuera, y aquí habrá
cadena a minúsculas. En este caso,
obtenemos un acceso a cada personaje dentro nuestra cuerda y podemos comprobar, vale, si las vocales
incluyen a nuestro personaje, entonces queremos
aumentar nuestro contador. Por lo que aquí se
contará más, más. Y después de este for-loop, simplemente devolvemos nuestra
cuenta que creamos. Aquí. Tratemos de encontrar las entrañas y
tenemos alguna cuerda, como se puede ver aquí, estamos
consiguiendo tres vocales porque tenemos
aquí e tres veces. Y en realidad diría
que este código está bien, pero podemos escribirlo
mejor con reducido. Es por ello que quería comentar
este recuento de leads y seguimiento directamente
aquí, devolver un reducido. Entonces aquí antes que nada, queremos convertir nuestra
cadena a minúsculas. Entonces aquí solo podemos intentar
cadena a minúsculas. Y después de esto, queremos
dividirlo en personajes. Esto es y aquí se
dividirá cadena vacía. Ahora queremos llamar aquí reducir
y estamos consiguiendo acceso, primer lugar a nuestro acumulador y segundo a
cada personaje. Después de esta función, queremos definir nuestro recuento
y será 0. En el interior se reducen. Queremos hacer exactamente
la misma lógica. Podemos volver aquí
que si nuestra
matriz de vocales incluye carácter
que estamos revisando, entonces queremos
aumentar nuestro contador. Aquí estamos aumentando nuestro
acumulador con más uno. En otro caso no
lo aumentamos y simplemente devolvemos acumulador. Vamos a revisar la sal
que estoy recargando la página aquí es la misma cadena
y estamos recibiendo tres. En realidad este código es mejor
porque en primer lugar, podemos leerlo línea por línea. Y en segundo lugar, esto totalmente
puro y funcional.
45. Convertir a Title Case: También puede obtener una tarea para convertir su caso de título de cadena. Y en realidad puede ser complicado. Es por eso que es
realmente bueno que aquí nos dieron casos de prueba proporcionados. Por lo que en realidad debemos construir
un caso de título de función. Y cuando nos
proveen dentro soy una pequeña tetera. Deberíamos devolver una cuerda y
debe ser capitalizada. Y como se puede ver,
cada palabra aquí está capitalizada, no sólo la primera palabra, y esto es importante. También. No importa
cómo proporcionemos nuestra cadena, debe ser capitalizada
correctamente. Construyamos esta función ahora. Y de hecho de nuevo, tenemos dos posibilidades aquí
podemos usar for-loop over, podemos usar métodos
JavaScript nativos. Entonces, antes que nada, vamos a
escribirlo usando for-loop. Aquí estamos crear el método de caso
titulado y estamos obteniendo
cadena como argumento. En primer lugar, queremos
crear aquí una matriz. Tenemos a todos los
personajes aquí. Podemos escribir aquí
que nuestra cadena equivale a cadena a división en
minúsculas, y aquí habrá un espacio. Así que en realidad aquí estamos
escribiendo array dentro de string. Y en realidad estoy
escribiendo código como este porque quiero mostrarte cómo no
debes escribir tu código. Y no se trata sólo de lógica aquí que estamos usando for loop, sino de considerar lo que están haciendo, como se puede ver, en primer lugar, la mala práctica aquí es usar el mismo argumento
que tenemos aquí. Sobreescribió nuestro argumento en el interior, lo que significa en primer lugar, podríamos modificarlo. Sí, no es el
caso de la cuerda, pero será así. Con matrices son objetos porque estamos más
definidos en una referencia. En segundo lugar, aquí estamos
volviendo en array, pero aquí
lo estamos escribiendo en tal stream, que lo hace confuso. Y ambas cosas
no debes hacer en tu código
ni en entrevista. Porque con esto
estás mostrando que estás escribiendo código embed. Tanto mejor enfoque
aquí será crear matriz de propiedad
adicional
o lo que quieras. Aquí estamos consiguiendo una cuerda a la división en
minúsculas y
estamos totalmente bien. Después de esto, hay que
escribir para bucle aquí podemos simplemente escribir
llano nativo for-loop, que tampoco aconsejo. Entonces aquí podemos escribir
var I es igual a 0, yo menos que longitud de cadena. Y aquí yo plus, plus. Y por supuesto aquí no es
stream sino nuestra matriz. Por lo que aquí dentro ahora podemos
mutar cada uno de los elementos. Por lo que podemos escribir aquí
array I iguala, y aquí tenemos el mismo
elemento dot carácter en 0. Y en realidad lo que hace, se necesita el primer
elemento de nuestra corriente. En nuestro caso,
cada elemento de nuestra matriz es una cadena. Y aquí estamos recibiendo la
primera letra para que podamos capitalizar fue de esta
manera justo en mayúsculas, que también es un
método nativo dentro de JavaScript. Y aquí podemos escribir
un i dot rebanada uno. Y en este caso estamos obteniendo todos nuestros elementos de la cadena a excepción de
la primera letra. Esto es lo que queremos.
Queremos capitalizar la primera letra y luego solo tomar todas las demás letras. Y después de esto,
simplemente podemos volver a unir nuestra matriz. Estamos justo aquí,
volver matriz unirse, y nos unimos,
en por espacio. Ahora podemos escribir
aquí el registro de consola, donde aquí dos puntos por si se
proporcionaron dentro de nuestra cadena. Soy una pequeña tetera. Comprobemos si está funcionando. Estoy recargando la página y al conseguir soy una pequeña tetera, que en realidad se ve bien
y resolvemos la tarea. Pero antes que nada,
usamos aquí cuatro negativos. Y como dije anteriormente, no
es el mejor
enfoque si estamos haciendo bucle a través de cada
elemento de la matriz, al
menos debes usar para ricos, para array y no nativo cuatro, entonces tu código será mejor. Lo segundo que no les
gusta aquí es que estamos anulando cada
elemento de nuestra matriz, lo que en realidad significa que
no estamos creando nueva matriz, pero estamos anulando
el anterior. Y tampoco es el
mejor enfoque. Esto es y Vamos a reescribir todo este código solo usando métodos
JavaScript simples. Porque en realidad aquí
ni siquiera necesitamos bucle FOR en absoluto. Lo que quería hacer
aquí, quiero tomar nuestra cadena y quiero
convertirla a minúsculas. Esto estuvo totalmente bien. Después de esto, queremos
dividirlo con espacio. Esto también fue totalmente bien. Pero después de esto
podemos usar map porque esencialmente lo que estamos
haciendo aquí es un mapa. Queremos cambiar cada
elemento dentro de la matriz. Es por eso que estoy llamando a mapa y estamos llegando
aquí nuestra junta directiva. Y en realidad como se puede ver, ahora está más claro porque estamos usando el mundo de la propiedad y no alguna IA o matriz donde no sabemos de qué
estamos hablando. Y aquí queremos hacer exactamente la misma palabra carácter de
punto a 0. Por lo que estamos consiguiendo primer elemento. Aquí estamos usando para mayúsculas, y aquí estamos usando plus, y nos toman todas las
demás letras con word dot Slice y aquí hay una. Y como se puede ver, este código
es esencialmente el mismo. No
lo cambiamos, pero es mucho más eficiente, más fácil de leer. Y muestra que eres desarrollador
más avanzado, porque aquí no estamos
usando for-loop sino map, que no es tan difícil. Y aquí
solo estamos regresando por cada palabra en tu trabajo. Y es importante aquí
mencionar que el personaje añadir y rebanar no mutan
en funciones, lo que significa que estamos consiguiendo flujo
juvenil y
no mutamos la corriente Alt.
Echemos un vistazo a esto. Yo soy el Señor en esta
página y estamos consiguiendo nuestra matriz batidor cadenas
capitalizadas, lo que significa que olvidé al
final de hacer nuestro gigante aquí, podemos simplemente llamar que me
uniría con espacio dentro. Vamos a ver esto y estamos obteniendo exactamente la misma cadena. Por lo que te recomiendo encarecidamente en el entrevistador que
veas tu nomenclatura, que
compruebes que tus tipos de datos estén emparejados con tus nombres y facilites tu código de
lectura si es posible.
46. Convertir la entrada de tiempo dada en formato de 12 horas a 24: Aquí hay una tarea más que requiere un
poco de pensamiento. Y como se puede
ver, debemos escribir la función que pueda convertir la entrada de tiempo dada en 12 horas a formato de
24 horas. Aquí tenemos casos de uso. Es por eso que es
más fácil para nosotros comprobar si estamos cubiertos
todo correctamente. Así que intentemos
crear esta función. Y una vez más, esta no
es una función que puedas resolver
en treinta segundos. Para que puedas tomarte tu tiempo y pensarlo un poco. Vamos a crear aquí convertir
a formato de 24 horas. Y estamos llegando hasta
el tiempo texto. Y en realidad lo que
quería hacer aquí primero, quiero
convertirlo a minúsculas, porque en realidad aquí
vamos a conseguir AM y PM y queremos estar seguros de
que son minúsculas. Es por eso que aquí podemos
intentar tiempo para xt más bajo. Y aquí queremos llamar texto de
tiempo a minúsculas. Lo segundo
que quiero hacer es conseguir horas y
minutos por separado. Lo que quiero escribir
aquí es tiempo tech más lento split y queremos
dividirlo por columna
porque en realidad tenemos dos puntos en
cada caso. Y a la izquierda
tenemos nuestras horas, y a la derecha
tenemos minutos. Y en realidad aquí quiero hacer una deestructura y
asignación aquí directamente. Quiero conseguir antes nada nuestras horas y
segundo minutos. En este caso, estamos creando
dos variables locales. Si no quieres
escribir así, puedes nombrarlo con alguna variable de
temperatura T y luego simplemente leer esta
variable temporal punto horas y minutos. Pero aquí llegamos a cosas
difíciles. Como se puede ver,
a veces
sólo tenemos un solo dígito y
a veces tenemos dos dígitos. Pero también tenemos un caso en el
que tenemos ceros al
principio. Aquí. También tenemos un caso más
que necesitamos cubrir. Si tenemos aquí 12 como nuestro, entonces debemos
convertirlo a ceros 0. Es por eso que quería
escribir exactamente esta lógica. Así que el tiempo de Eva marque más lento punto y ancho y
en realidad termina con Israel. Una buena función en
JavaScript que está comprobando el tostring está
terminando con algo. Aquí podemos comprobar por AM porque en realidad
sabemos que aquí tenemos 12 AM y significa que
debemos convertirlo a dos ceros. Es por eso que aquí quiero
escribir los nuestros iguales, y aquí estamos
comprobando si nuestro horario igual a 1212 como una cadena, porque aquí estamos
divididos en nuestra cadena, entonces queremos aquí para conseguir 0. En otro caso, estamos
llegando aquí horas. Y como se puede
ver, antes que nada, escribí aquí un solo
0 y no dos ceros. Y esto también es importante. Aquí acabo de
asignar directamente las horas, lo que en realidad significa que cubrimos esta lógica para obtener un solo 0 y en todos los demás casos sólo
obtendríamos lo que obtenemos. Si son cinco,
vamos a conseguir cinco. Si es 01, conseguiremos 01. Cubrimos nuestra AMK es ahora
quería cubrir caso PM. Es por eso que aquí
podemos escribir otra cosa y hasta tal vez else-if porque
queremos comprobar por PM. Y aquí podemos escribir tiempo
tech punto más lento y ancho, y aquí estamos consiguiendo nuestro PM. Y en este caso queremos
aplicar lógica diferente. Queremos asignar
aquí nuestros horarios y queremos comprobar si
nuestro horario es igual a 12, porque este es de
nuevo otro caso. En este caso queremos
aplicar aquí horas, o queremos escribir
aquí cadena y dentro más horas duran 12. Este código está haciendo un alto,
como se puede ver aquí, escribí más horas, lo que hace en realidad, estamos recibiendo nuestras
horas como una cadena. Entonces digamos que
estamos llegando hasta aquí 12. Ahora si voy a escribir aquí
plus al principio, estamos llegando aquí directamente
número de una cadena, lo que en realidad significa que
estamos convirtiendo esto a número y luego hacemos más 12. ¿ Por qué es eso? Porque
digamos que aquí estamos revisando PM, por
ejemplo, este caso con 01, y aquí estamos revisando, Ok, horas es igual a 12, No, Entonces queremos
hacer 01 más 12. Revisemos al Sur
cómo será. Entonces estamos llegando aquí 01 y en realidad se
convierte a uno. Y ahora después de esto
estamos recibiendo más 12 y nos estamos metiendo en estaño, lo que en realidad
significa al agregar 12, lo
estamos convirtiendo a
la hora correcta de PM. Y si tenemos 12 PM así, entonces simplemente lo dejamos como 12. Por lo que en realidad aquí
podríamos escribir 12 más, sólo
podría tomar nuestras horas. Entonces, lo que quiero hacer ahora, quiero comprobar lo que estamos
consiguiendo dentro de horas. Por lo que aquí quiero consolar registrar nuestro formato Convertir a 24 horas, y aquí está nuestros
textos de tiempo y nuestras horas. Y ahora quiero copiar todos
estos casos y simplemente ejecutarlos. En este caso, podemos comprobar que están funcionando correctamente. Estoy recargando la página
y estamos consiguiendo asignación a
constante, variable. Y como pueden ver aquí, estamos tratando de sobrescribir la nuestra. Y por supuesto que está prohibido. Es por eso
que aquí debemos escribir LED. Echemos un vistazo
a esto. Estoy recargando y estamos recibiendo
412045512120113. Aquí tenemos PM 11231022, lo que en realidad significa que nuestra
lógica por horas es correcta. Después de esto, debemos sumar un 0
líder en este conjunto de casos. Y como se puede ver,
a veces no lo
necesitamos y a veces
hay
que tenerlo y podemos resolverlo fácilmente con una función
JavaScript más simple. Podemos escribir aquí,
nuestro punto pad de inicio. Aquí. Podemos proporcionar a 0. Lo que hace es que
se vea aquí que rellena la cadena actual con otra cadena varias
veces si es necesario. que en realidad significa que aquí
estamos proporcionando herramienta, lo que significa que tendremos dos
símbolos y aquí tenemos 0, lo que en realidad significa que si
no tenemos un símbolo ahí, entonces pondremos 0 dentro. Y en realidad ahora quiero
copiar esta parte y simplemente poner dentro de nuestro
registro de consola para comprobar si está funcionando. Estoy recargando la página
y como pueden ver ahora, estamos consiguiendo la hora correcta. Entonces aquí tenemos dos ceros, 05, y luego todos son números
correctos. Ahora debemos implementar nuestras actas y en realidad
es mucho más fácil. En primer lugar, sólo
para recordarte, dentro de minutos también tendrán PM y TM y debemos
deshacernos de él. Es por eso que podemos escribir
aquí directamente significa dot rebanada y aquí estamos
usando 0 menos dos. En este caso, vamos a
deshacernos de dos símbolos, AM o PM, y nos
pondremos a pocos minutos aquí. Y después de esto, quiero
usar filamento de PET, igual que lo hicimos anteriormente. Y aquí estarán también 20. En este caso,
comprobaremos, vale, Si tenemos aquí ocho, entonces debemos llegar
aquí pseudo ayuda. Si vamos a tener aquí dos dígitos, entonces está totalmente bien. Ahora solo podemos eliminar
este registro de consola, pero ya no lo necesitamos. Y en realidad aquí en
cada caso, quiero escribir el registro de consola. Esto es y Cambiemos esto. Ahora. Quiero escribir aquí el registro de
consola, luego abrirlo. Y aquí tenemos convertir. Y cerrémoslo era el soporte. Ahora tenemos todos nuestros casos. Vamos a
revisarlos. Estoy recargando la página y estamos
consiguiendo nuestro tiempo, y se ve totalmente bien
en realidad aquí por ejemplo, tenemos ceros minúsculos 0
a 35508 y así sucesivamente. Pero el problema es que
olvidamos poner una
columna entre ellos. Aquí es donde aquí
debemos escribir plus y entre ellos solo poner
una cuerda con dos puntos. Y como se puede ver
ahora, nos estamos pasando un buen rato en formato de 24 horas. Y en realidad desde
mi punto de vista, esto es difícil resolver esta tarea en cinco
o diez minutos. Realmente necesitas
sentarte ahí como tal vez 15 minutos o media hora
para revisar diferentes casos, cómo quieres
resolverlo y así sucesivamente. Entonces esta es una buena tarea para
comprobar cómo se pueden convertir cosas
diferentes entre
ellas con diferente lógica. Pero no es
algo que puedas resolver en uno o dos minutos.
47. Datos de Mapeo: Aquí hay una tarea más para ti que se toma
del proyecto real. Esto no son solo algunas
tareas para la entrevista, sino las tareas que
verás en tu vida cotidiana. Y como se puede ver,
donde deben mapear datos al frente y formato, lo que en realidad significa que estamos obteniendo nuestros datos, por ejemplo, del backend, no
informarlos como queramos. Por eso queremos
convertirlos. El elemento principal
es la clave de ubicación, y necesitamos mapear
todos los datos a ella, y
entonces lo tendremos cinco objetos. Como se puede ver aquí. En primer lugar, tenemos
una matriz de ubicación, y aquí tenemos dos objetos. En primer lugar, clave de ubicación y este es nuestro identificador único. Y tenemos aquí
algunas ideas y externa asignan exactamente lo mismo
en el segundo objeto. Y ahora aquí tenemos una tarifa configurada
a granel. Esta es también la
matriz con objetos. Y dentro de cada objeto
único tenemos un dato valores y conflicto mantener. El punto principal es que los estamos
mapeando uno a uno, lo que en realidad significa que
el índice 0 en matriz de
ubicación es igual
a las configs masivas 0 index. Y en este caso, necesitamos mapear todo a la estructura. Al final, debemos
obtener una matriz de objetos con antes que
nada, clave de conflicto. Esta es esta parte y ubicación más cercana a
dos, como se puede ver, ubicación kids a22 es esta parte y también
externa asignada de ella, lo que en realidad significa que un
segundo elemento
también será conflicto 100 kit de
ubicación cuando T2, este es nuestro segundo número y luego externo asignar
y así sucesivamente y así sucesivamente. Y se dice que el ID
único rápido es esto, lo que en realidad significa que estamos
llegando aquí 12345 objetos. Por lo que Adviento debemos tener una
matriz con cinco objetos. Ahora intentemos
escribir esta lógica y en realidad no tendremos
nada complicado aquí. Se trata de mapeo de datos. Vamos a intentarlo aquí. Nuestro resultado, como quiero hacerlo
directamente resulta para
bucles de manera eficiente. Y no van
a aquí para trabajar con ubicación solo porque dentro
tenemos nuestras identificaciones únicas. Y aquí dentro de la ubicación
estamos obteniendo mapa, lo que en realidad significa que estamos haciendo un
lazo a través de estos objetos. Aquí dentro del mapa. Estamos obteniendo elemento ubicación y también estamos
consiguiendo aquí índice. Por eso debo poner aquí corchetes
adicionales. Ubicación n, el índice
son lo que necesitamos. Ahora dentro podemos hacer nuestra magia porque ahora dentro de elemento de
ubicación, están consiguiendo
cada objeto que queremos aquí, un mapa topo, porque dentro de nuestro elemento
localizacion, queremos bucle a través de
nuestra clave de ubicación. Es por eso que aquí podemos
devolver nuestro elemento de ubicación, y aquí tenemos
nuestra clave de ubicación. Aquí también tengo
un mapa y tenemos acceso a nuestra clave de ubicación. Y como pueden ver, lo
escribí con CamelCase porque tenemos razón en código
JavaScript y típicamente todas nuestras variables son CamelCase. Ahora aquí dentro queremos
devolver lo que necesitamos. En primer lugar, necesitamos
aquí clave de asignación. Es por eso que aquí estoy
escribiendo clave de ubicación. Podemos dejarlo con
subrayado como de backend, superarlo, convertirlo mayúsculas solo
depende de lo que quieras. Y aquí solo estamos
asignando nuestra clave de ubicación. Después de esto, debemos
conseguir nuestra clave de conflicto. Esto es extremadamente fácil de hacer porque aquí dentro del conflicto
masivo, solo
podemos obtener esta clave de
conflicto por índice. Es por eso que aquí podemos escribir Bow config index porque es el mismo lago y ubicación valores de datos de
punto, clave de configuración de punto. Y la última parte es
exterior asignar signo delta. Nos estamos metiendo en el
elemento de ubicación punto una señal. Y así es como remapeamos
lo que necesitábamos. Entonces, en primer lugar,
tenemos un mapa a través nuestra ubicación,
a través del tema. Y en un mapa tenemos
para nuestra llave de ubicación. Es por ello que por cada ID
único, podemos mapear datos que necesitamos. Vamos a revisar
esto. Escribiré la consola de bloqueo aquí nuestro resultado, y vamos a comprobar si está funcionando. Estoy recargando la página y
obtenemos una matriz de matrices. El primer array
que estamos llegando aquí, clave de
ubicación configurada al aire libre, asignar, y todo está bien. El único problema que tenemos es que obtenemos una matriz de matrices, pero en realidad
queremos una matriz plana. Es por eso que debemos hacer
algo con este código. Podemos utilizar aquí reducir para
simplemente crear una matriz plana porque no tenemos método
aplanado nativamente
dentro de JavaScript. Aquí tenemos nuestra matriz
y el acumulador. Y al principio podemos decir que estamos obteniendo
una matriz vacía. Lo que queremos hacer en su interior es
usar array.com catenate. Y aquí estamos concatenados
y esto fue acumulador. Lo que se hace aquí por defecto, tenemos aquí
matriz vacía y tenemos cada matriz única
que se puede ver aquí. Y queremos concatenar
nuestra matriz con acumulador. Entonces esencialmente por
cada elemento, lo estamos concatenando
con nuestro acumulador. Vamos a revisar esto. Estoy recargando la página y estamos obteniendo nuestra
matriz huida con temas. Y así es como
mapea datos, por ejemplo, desde el formato backend a
nuestro formato front-end.
48. Reemplazar parámetros en URL: También podrías conseguir
una tarea como esta. Cree una función para
reemplazar parámetros en URL. Y en realidad esta es una tarea del mundo real porque
aquí tenemos una URL inicial, como se genera en enrutadores
antiguos para todos los frameworks
front-end. Y en este caso
tenemos barra de URL inicial, tanto slash como aquí columna post AD slash comment slash
column comment ID, lo que significa que estos dos
parámetros con columnas serán reemplazados por IDs en
algún momento más tarde. Y en realidad
demostrar una función reemplazar params en
la URL donde podemos tirar dentro de la URL con tal estructura y
matriz de reemplazos. Y como se puede ver dentro de
cada objeto único debemos proporcionar desde y
hacia, por ejemplo, desde post-Covid significa que
debemos reemplazar colon
post AD por id1, y aquí comentó con 83. Y por supuesto esta
función debe ser genética. No es sólo para
publicaciones y comentarios, sino para cualquier reemplazo dentro de URL. Y en realidad antes de
empezar a resolver, quiero mostrarles
una cosa más, cómo se puede pensar en
resolver problemas. Por ejemplo, puedes escribir
algo así como lista de tareas pendientes. Y en este caso, estamos
tratando de pensar en pasos respecto a lo que
queremos implementar. Por ejemplo, ¿cuál
será el primer paso aquí? Como ves, tenemos una
matriz de nuestros reemplazos, lo que en realidad significa que tenemos una función con dos argumentos. Y en realidad
queremos recorrer cada reemplazo y aplicar este reemplazo
a nuestra URL. Por lo que en realidad aquí podemos escribir
pasar por reemplazos. El segundo será tal vez reemplazar partes de cada reemplazo. Lo último que estaremos aquí, regresa en tu arroyo. Esta lista, en este caso podría sonar
como algo obvio, pero puede ayudar si
escribes algo como esto para implementar una lógica
más compleja. Y en realidad directamente quieren implementar aquí una solución
correcta. Y podemos usar reducido para esto porque es enorme nuestro código mejor. Pero también quiero mostrarte el único problema
que podrías hacer. En realidad aquí queremos
crear nuestra función, reemplazar params en URL, y estamos obteniendo aquí URL
y nuestra lista de reemplazos. Y en realidad lo que
queremos girar aquí se reduce para nuestros reemplazos,
reemplazos dot reducen. Y aquí tenemos
nuestra función con acumulador y cada uno
de reemplazo. Este valor inicial
tenemos aquí nuestra URL, porque esto es lo que
queremos cambiar. Ahora aquí dentro de la función, debemos devolver cadena actualizada. Y para esto podemos usar una función JavaScript simple
que se llama reemplazada. Y en realidad aquí podrías
intentar dibujarte así. Puedes pensar,
Ok, tengo una URL, podemos simplemente escribir aquí, URL es igual a URL dot replace. Aquí estamos reemplazando en
primer lugar, columna más punto de
reemplazo de, y lo estamos cambiando
a punto t2 de reemplazo. Esto es todo. Y después de esto, queremos devolver nuestra URL. Y en realidad este código
parece algo correcto. Y ahora quiero mover nuestra URL
inicial y los resultados aquí a la parte inferior y escribir la URL del resultado del registro de
consola. Y vamos a revisar lo que tenemos. Estoy recargando la página
y estamos recibiendo exactamente slash post slash one,
slash common slips tres, lo que en realidad significa que esta lógica con reducida está
funcionando correctamente. Estamos haciendo un bucle a través de
cada reemplazo. Aquí actualizamos nuestra URL y aquí la devolvemos y
no se ve bien, pero en realidad tienes
aquí un problema enorme. Como se puede ver, mi variable
acumuladora no
está resaltada, lo que en realidad significa que no
estamos usando aquí reducir correctamente y no estamos
usando acumulador en absoluto. Lo que estamos usando, estamos
usando esta URL desde params y con mutar directamente
esta URL cada vez. Y en realidad esto está
completamente equivocado, primer lugar, porque no
debemos mutar nuestros params. Y en segundo lugar, la parte más
importante que estamos usando aquí se reduce como un
for-loop porque realidad simplemente
mutamos nuestra variable desde afuera en el bucle y
no estamos usando nuestro acumulador. En realidad el código correcto
aquí no es reemplazar, sino simplemente devolver
acumulada reemplazar. Porque como se puede ver,
proporcionamos aquí rail aquí como un valor inicial y
no deberíamos usar URL aquí dentro. No queremos cambiar nuestra URL. Queremos cada
vez actualizar nuestro acumulador y volver
en nuevo acumulador. Como se puede ver que este código está funcionando exactamente igual, pero esto es
completamente diferente. Anteriormente, si
escribieras código como este, esto está completamente equivocado en la entrevista porque no
estás usando reducido,
reducido, pero al igual que for-loop, lo mismo ocurre con
el mapa. Si estás usando el mapa
solo para recorrer cosas que estás haciendo
una tendencia con el mapa, necesitas transformar tu
matriz y devolverla.
49. Mensajes de validación: También podría obtener una
pregunta como esta para mensaje de validación de backend
MOD al frente y al formato. Y en realidad este es un ejemplo
real porque a veces estamos recibiendo mensajes de validación
backend, no en el formato como
es adecuado rápido en el front-end para
nuestros formularios JavaScript. Es por eso que aquí estamos obteniendo nuestros errores de backend
en tal formato. Tenemos aquí un
objeto con claves y cada clave es una
propiedad del back-end. Nuestro campo que estamos validando,
por ejemplo, correo electrónico. Y aquí hemos llenado errores, y esto
es lo que le interesa los errores de archivos es una
matriz de objetos. Y dentro de cada objeto individual, tenemos propiedad de mensaje
con algún mensaje. Por ejemplo, aquí tenemos
contraseña con dos errores. Esto es lo que aquí es una
matriz con dos objetos. Aquí está el mensaje debe
contener símbolos en diferentes casos y debe ser de al
menos ocho símbolos lente. Lo que queremos hacer
en este ejercicio, queríamos convertirlo
a nuestro frente y formato. Esto es solo una matriz plana con cadenas y cada
flujo individual es nuestra clave. Entonces nuestro alimentado como el correo electrónico, y ahora tenemos todos nuestros errores
concatenados como por ejemplo, no
pueden estar en blanco. Y si tenemos dos
de ellos que
simplemente los
concatenamos con coma. Por lo que en realidad puedes
resolverlo de diferentes maneras, pero recomiendo encarecidamente
usar un objeto entra aquí. Podemos simplemente escribir aquí entradas de
puntos de objeto y proporcionar
dentro de nuestros errores backend. Y como se puede
ver, estamos obteniendo un formato
tan bonito como
matriz de matrices. Y cada matriz individual
aquí es ante todo, sigue una clave y el valor
es lo que teníamos aquí. Por lo que tenemos un valor con errores y por dentro
tenemos nuestros errores. Y este es realmente
cómodo formato para trabajar para nosotros porque realmente no
podemos llamar mapa en
JavaScript en el objeto. Es por ello que lo
que queremos hacer aquí, queremos en primer lugar, para crear alguna
propiedad normal puede ser errores de backend legibles por
humanos. Y ahora queremos llamar
aquí entradas de puntos de objeto. Y queremos proporcionar
dentro de nuestros errores backend. En realidad ahora tenemos
matriz de matrices y podemos mapear aquí
cada valor. Y ya viste
lo que llegamos aquí. Estamos recibiendo una
matriz con el correo electrónico como clave y algún valor. Y en realidad aquí quiero
usar el regular esta estructuración para conseguir en primer lugar nuestra clave y segundo bucle, estamos obteniendo nuestro valor. Esta es la forma más fácil de
usar el mapa en el objeto. Y aquí estamos
consiguiendo en primer lugar, nuestro campo y en segundo lugar
valoramos con los errores. Es por ello que debemos
preparar nuestros errores. En este caso, vamos a
nombrarlos, por ejemplo, mensajes de
campo y
debemos concatenarlos. Para que podamos escribir aquí los errores de puntos de
valor. Entonces estamos recibiendo nuestra
matriz de errores. Y ahora aquí necesitamos
mapear cada error. Aquí estamos llamando
mapa sin error y queremos devolver mensaje de
error. Y como se puede ver
aquí, esto es cierto. Tenemos aquí array
con objetos y cada objeto individual
contiene nuestro mensaje. Aquí solo estamos
mapeando estos mensajes. Y después de este grupo quería
conseguir el nombre de ellos. Aquí pondré unirme coma y espacio porque nacemos para
tener una bonita cuerda legible. Y después de esto,
simplemente necesitamos devolver nuestra cadena porque
estamos dentro del mapa aquí. Quiero usar aquí
script ECMO sexta cadena, y en su interior querían
proporcionar nuestra clave. Pero aquí está el problema. Como se puede ver,
siempre está capitalizado. En primer lugar, debemos
capitalizarlo y ya lo
hemos hecho
en videos anteriores. Aquí es donde aquí podemos
nombrarlo capitalizar campo, y en realidad creo
llenar este mejor nombre. Así que cambiemos el nombre de
nuestra clave de campo. Y ahora aquí
hay que llamar al campo, en primer lugar carácter a 0. En este caso, nos llevan
nuestro primer elemento y
queremos concatenar que
se llenó dot rebanada. Y aquí estamos poniendo uno, fueron cortados en un símbolo. En este caso, es nuestro nombre
capitalizado del campo. Ahora aquí debemos proporcionar
este campo capitalizado, y aquí D es importante. En otro caso, podemos
pensar que esta es una función y después de esto
se puso simplemente espacio de columna. Y aquí nuestros mensajes de campo. Lo que estamos haciendo aquí,
estamos mapeando a través nuestras entradas de objetos donde conseguir directamente nuestro campo y valor. En primer lugar, estamos uniendo a
nuestros mensajes de campo. Y en segundo lugar, estamos
capitalizando nuestro campo y ahora estamos devolviendo stream
por cada error. Echemos un vistazo a esto. Estoy recargado nuestra página y
vamos a revisar lo que
tenemos dentro de los errores
legibles humanos. Y como se puede ver, esta es nuestra bonita matriz en
el formato correcto. Entonces tenemos aquí cadenas para cada campo y
capitalizamos el nombre
de cada campo. Y aquí nos hemos
unido a nuestros errores, lo que significa que tenemos éxito en
resolver este problema y transformar datos en
el formato correcto.
50. Lista anidada: También podría obtener una
pregunta como esta. Transformar lista plana
en lista anidada. Y esto es algunas cosas
súper reales. Normalmente desde el backend, estás obteniendo todos los datos
como una lista plana y típicamente estos datos pueden tener
hijos unos de otros. que en realidad significa para
nosotros en el front-end, no
es cómodo
renderizar estos datos. Simplemente podemos ir con for loop
porque tenemos hijos. Necesitamos ante
todo renderizar en pequeños niveles y luego
por cada elemento, encontrar a sus hijos
y renderlos. Esta es la razón por la que normalmente
desea transformar sus datos de lista plana a lista
anidada solo una vez. Y esto es exactamente lo
que debemos hacer en este video. Como puedes ver aquí, tenemos nuestra lista plana y
cada elemento es un objeto. Contamos con ID único, algún nombre y datos de padres. Y en primer lugar, es importante porque este es nuestro identificador único
y en segundo lugar, padre ID y puede ser
o bien añadir de otro ítem. Por ejemplo, aquí, padre uno, este es este ítem. Entonces este objeto es
uno de los padres de este ítem. Y en segundo lugar,
los datos padre pueden ser nulos si
se trata de un elemento raíz y
no tiene un padre. Para que como se puede ver aquí, tenemos dos elementos raíz
con ad1 y dos. Ahora tenemos un D3, que es el hijo
del padre edu uno. Entonces este es el segundo nivel. Aquí es donde el nombre de su
nivel dos, punto tres. Entonces entiendes el nivel. Y ahora tenemos un defecto, que es aparentemente D tres, lo que en realidad significa que
esto es un hijo de este elemento y en realidad
este padre tres es esto. Es por ello que es el nivel
tres, punto cuatro. Y aquí tenemos ad5, que en realidad es un
hijo del padre D dos, lo que significa este ítem y
en realidad así es
como típicamente estamos obteniendo datos del backend. Ahora debemos
transformarlo en tal formato. Por lo que tenemos una matriz plana
con solo dos elementos. Para que como se puede ver aquí, tenemos dos objetos objeto con
81 y el objeto con ad2 porque ambos
son a través elementos y sus datos
padre es ahora. Ahora en el interior tenemos una
nueva propiedad niños. Y esto es exactamente niños
que están mapeados dentro. Y aquí como se puede
ver, tenemos ad3 y también niños
dentro porque en realidad ad4 está anidado dentro D tres y exactamente lo
mismo que tenemos aquí. Tenemos dentro de D dos niños
y aquí ad5 y niños. Y he omitido aquí nombres porque no son
importantes para la comprensión. Pero obviamente puedes tener todas las propiedades adicionales aquí. Y como se puede ver
en el último nivel, uno, no
tiene hijos. Entonces entramos aquí,
niños, matriz vacía. Entonces nuestra tarea ahora es transformar lista
plana a lista anidada. Y como
dijo anteriormente el anciano, para algunas personas es mucho
más fácil simplemente tratar de señalar cómo lo resolverán y luego solo codificarlo. Es por esto que. Tratemos de hacerlo ahora. Entonces, antes que nada, escribiré aquí para hacer lo que estamos haciendo. El primer punto es deshacerse de los elementos porque esto es
lo que queremos renderizar. Tratemos de, así como esto, conseguir los elementos raíz. Entonces debemos tener una matriz
de nuestros elementos raíz. El segundo punto es revisar
a todos los niños y entender si nuestros dos
elementos tienen hijos. Si no, entonces simplemente los
devolvemos hoy. En caso afirmativo, entonces necesitamos
recursivamente encontrar niños. Y debemos hacerlo recursivamente
porque necesitamos
revisar cada elemento
y comprobar si tiene hijos. Para que podamos escribir aquí
algo como esto. Revise a los niños si
tienen hijos. Y ahora el siguiente punto
será, si no, entonces solo devolvemos artículo
con niños vacíos. Y el número cuatro aquí es si sí, entonces queremos
ir al número dos, lo que en realidad significa que
estamos haciendo el número dos recursivamente hasta que estemos
al final de nuestros elementos. Ahora intentemos escribir el código. Entonces, antes que nada, quiero
asignarlo a nuestra lista anidada. Y lo que quiero hacer, quiero tomar nuestra lista plana
y encontrar en pequeños elementos. Y para esto, solo podemos usar
filtro porque queremos
encontrar todos los elementos donde está ahora
nuestro ID padre. En este caso, podemos simplemente
decir que tenemos nuestro ítem
y ítem dot
ID parental es igual a nulo. Entonces estamos bien para irnos. Echemos un vistazo a esto.
Tiempo para cargar en la página. Y ahora tenemos nuestra lista anidada. Como se puede ver, tenemos
nuestra matriz de objetos. Y aquí tenemos 81 y 82 porque su
padre. Estos son ahora. Esto es exactamente lo que queríamos. Después de esto, solo quiero escribir ese mapa y dentro de la
función como niños. ¿ Por qué estoy haciendo así? Porque en realidad esta
función se llamará recursivamente y sería una función completamente sin estado, lo que en realidad
significa que debemos llamar a esta función en cualquier
elemento y debe funcionar. Esto es lo que quiero
crear aquí. Nuestra función ADD niños
y nos metemos aquí un artículo pero no necesitamos
nada más porque aquí tenemos nuestra
lista plana en la parte superior. Si no lo tienes
disponible en la parte superior, entonces tal vez puedas conseguir
aquí un segundo argumento, una lista plana en tu código, pero será en
tu proyecto real. Aquí tenemos acceso
a nuestra lista huida. Entonces, lo que estamos haciendo aquí, estamos haciendo un looping a través de
nuestros elementos raíz y estamos mapeando a los niños, lo que en realidad significa
si queremos agregar niños a cada elemento de ruta
individual. Entonces, antes que nada,
debemos encontrar a nuestros hijos. Así que vamos justo aquí, niños. Y sabemos que nuestros
hijos solo es lista plana, cual se filtra por los datos de los
padres donde
ID es igual a
Id. de punto de elemento. Entonces hagamos esto. Ahora simplemente tomamos lista
plana, filtro de puntos, y aquí tenemos nuestro hijo y vamos a
nombrarlo, por ejemplo, elemento
hijo y queremos revisar elemento
hijo dot padre ID igual
en nuestro caso item dot ID. En este caso, estamos
encontrando a todos nuestros hijos. Vamos a console.log
lo que tenemos aquí. Así que sólo estoy escribiendo niños
subrayados en la página. Y como se puede ver aquí,
tenemos un solo elemento, porque este es un hijo de elemento
fotográfico con un D1. Y aquí tenemos
también un hijo más de elemento frutal con el padre 82, lo que en realidad significa que
está funcionando correctamente. El siguiente punto es comprobar
si tenemos hijos. Entonces aquí podemos escribir. Si nuestros hijos se alargan
más de cero, entonces debemos hacer nuestra magia
recursiva porque no sólo necesitamos
conseguir hijos de niños, sino que debemos hacerlo recursivamente. Lo que quiero hacer
antes quiero crear un tipo de propiedad era propio
ness a los niños y ellos quieren asignar aquí matriz
vacía porque
en realidad si
no estamos dentro del SIF entonces
no necesitamos cambiar cualquier cosa. Simplemente necesitamos
devolver a los niños vacíos. Y como se puede
ver, asigné por defecto matriz vacía aquí para que podamos devolver aquí objeto
asignar y aquí estoy. Correcto, un objeto vacío
luego coma, elemento, coma. Y aquí están nuestros hijos. Niños anidados. ¿Por qué
escribí así? Porque en realidad, si
vas a utilizar aquí push o simplemente con almacenado, estás diciendo que aquí
están nuestros hijos anidados. Entonces mutarás el elemento, lo que en realidad significa que
cambiarás este artículo dentro lista
plana porque tenemos una referencia de objeto.
No queremos esto. Simplemente queremos
devolver sus datos. Es por eso que estoy usando aquí objeto asignar con objeto vacío. Después de esto estamos usando nuestro artículo por lo que copiamos
todas las propiedades de nuestro artículo dentro de este nuevo objeto y fueron firmados aquí en
su propiedad hijos, que es nuestra ness para los niños. Y en este caso, simplemente
hemos dejado que los niños anidados
vacíen el objeto. Echemos un vistazo a esto.
Tiempo para cargar en la página. Aquí está nuestra lista anidada. Y como se puede ver, ahora tenemos hijos matriz vacía porque en realidad no escribimos
ninguna lógica para esta víspera. Es por eso que simplemente
devolvemos datos en dicho formato ID nombre padre ID realidad todos los campos y
adicionalmente hijos. Y como pueden ver, tenemos
aquí sólo dos elementos, que en realidad significa que todo
está funcionando correctamente y debemos simplemente llamar
recursivamente aquí nuestro código. Entonces, lo que queremos hacer aquí, queremos mirar a través de
cada niño y llamar a la
función infantil en este niño. Por lo que podemos asignar aquí
a nuestros hijos anidados. Y esto es sólo nuestros
hijos, ese mapa. Y tenemos acceso a
cada niño. Y lo llamamos
niños con nuestro hijo. Entonces, ¿qué está pasando
en este caso? Por ejemplo, encontramos al niño. Estamos revisando aquí, ¿de acuerdo? Tenemos un hijo
en, digamos, niños. Y aquí estamos mapeando
a través de nuestra matriz. Y por cada elemento
estaban llamando a los niños parte
más importante que eran Colin esto funciona
recursivamente. En primer lugar lo llamamos
aquí dentro del elemento raíz. Ahora aquí dentro los niños
estaban Colin era mapa. Y cuando lo
llamábamos aquí estaban pollos niños de este niño, lo
que en realidad significa que irá recursivamente hasta que
no tengamos hijos y simplemente
no vamos a esta condición. Entonces, por ejemplo, en nuestro caso, aquí estaban Colin a tres veces. En primer lugar, para
que hagas uno luego por ID3 y luego por un defecto. Y es precisamente por eso que necesitamos recursión aquí. Echemos
un vistazo a esto. Tiempo para cargar en la página. Revisemos nuestra lista anidada. Y como pueden ver, ahora
tenemos hijos. Y dentro del elemento uno, solo
tenemos un niño con ad3, y también tenemos una propiedad
infantil dentro y tenemos
un niño más aquí, nivel tres, ítem cuatro, y tenemos hijos vacíos porque en realidad nuestra recursión terminó y simplemente llegamos aquí niños
vacíos y los
asignamos aquí. Entonces, una vez más, antes que nada, debemos conseguir todos
nuestros elementos viales. En segundo lugar, debemos crear
una función que
podamos llamar recursivamente
a cualquier elemento. Y estos son nuestros hijos. Ahora, por dentro, los niños
estaban, en primer lugar,
tratando de encontrar a todos
los hijos del artículo, y en segundo lugar, pollo oso. Si necesitamos hacer recursión por nuestros hijos,
si tenemos alguna. En caso afirmativo, entonces somos Colin
en niños recursivamente. Si no, simplemente hacemos un objeto asignar y el regreso
aquí nuestros hijos. Entonces así es como lo
haces típicamente en el proyecto real.
51. Proyecto: Terminaste con éxito mi curso cuanto a la preparación para la entrevista de
JavaScript. Y creo que eres impresionante si lo
terminaste juntos, implementamos 59 preguntas de
entrevista de JavaScript. Y en realidad muchas
de ellas no fueron fáciles si no lo
probaste tú mismo, pero simplemente sigue el préstamo. Todavía se puede hacer eso. Puedes simplemente escoger aleatoriamente algún video e intentar
implementarlo tú mismo, aunque lo hayas visto una vez, tiene mucho sentido
intentarlo y hacerlo. Además, solo quería recordarte que no
te deprimieran. Si fracasas la entrevista, vendrá con el tiempo y seguro
encontrarás tu chuleta. Solo necesitas
reunir más conocimientos, entender qué pregunta
te están haciendo en las entrevistas y
prepararte mejor. Espero que hayas
aprendido mucho y te
veré en
mi próximo curso.