Skip to content

Commit b1f9143

Browse files
author
llonardo798
committed
#1 - JavaScript
1 parent c774819 commit b1f9143

File tree

1 file changed

+299
-0
lines changed
  • Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript

1 file changed

+299
-0
lines changed

‎Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/llonardo798.js

+299
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,299 @@
1+
/*
2+
* EJERCICIO:
3+
* - Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje:
4+
* Aritméticos, lógicos, de comparación, asignación, identidad, pertenencia, bits...
5+
* (Ten en cuenta que cada lenguaje puede poseer unos diferentes)
6+
* - Utilizando las operaciones con operadores que tú quieras, crea ejemplos
7+
* que representen todos los tipos de estructuras de control que existan
8+
* en tu lenguaje:
9+
* Condicionales, iterativas, excepciones...
10+
* - Debes hacer print por consola del resultado de todos los ejemplos.
11+
*
12+
* DIFICULTAD EXTRA (opcional):
13+
* Crea un programa que imprima por consola todos los números comprendidos
14+
* entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
15+
*
16+
* Seguro que al revisar detenidamente las posibilidades has descubierto algo nuevo.
17+
*/
18+
19+
// Tipos de operadores en JavaScript
20+
21+
// 1. Operadores Aritméticos
22+
console.log("1. Operadores Aritméticos");
23+
24+
let suma = 5 + 5; // Operador de suma (+)
25+
console.log("Suma: " + suma); // 10
26+
27+
let resta = suma - 5; // Operador de resta (-)
28+
console.log("Resta:" + resta); // 5
29+
30+
let multiplicacion = suma * 5; // Operador de multiplicación (*)
31+
console.log("Multiplicación: " + multiplicacion); // 50
32+
33+
let division = suma / 5 // Operador de división (/)
34+
console.log("División: " + division); // 2
35+
36+
let modulo = suma % 3; // Operador de módulo (%) - Módulo (resto o sobrante de la división) 10 % 3 = 1 se puede considerar como 10/3 = 3 y sobra 1
37+
console.log("Modulo: " + modulo); // 1
38+
39+
let incremento = suma++; // Operador de incremento (++)
40+
console.log("Incremento: " + incremento); // 6
41+
42+
let decremento = suma--; // Operador de decremento (--)
43+
console.log("Decremento: " + decremento); // 5
44+
45+
let exponenciacion = 2 ** 3; // Operador de exponenciación (**)
46+
console.log("Exponenciación" + exponenciacion); // 8
47+
48+
// Ejemplo de uso de operadores aritméticos
49+
let numero1 = 5;
50+
let numero2 = 3;
51+
let resultado = (((numero1 + numero2) * (numero1 - numero2)) / numero2) % numero2 + numero1++ - --numero2 + numero1 ** numero2
52+
console.log("Uso de todos los operadores aritmeticos: " + resultado); // 41.333....
53+
54+
55+
56+
// 2. Operadores Bit a Bit
57+
console.log("2. Operadores Bit a Bit");
58+
59+
let operadorA = 60; // 60 = 0011 1100
60+
let operadorB = 13; // 13 = 0000 1101
61+
let operadorC = -10; // -10 = 1111 1111 1111 1111 1111 1111 1111 0110
62+
63+
let operadorAnd = operadorA & operadorB; // Operador de AND bit a bit (&)
64+
console.log("AND: " + operadorAnd); // 12
65+
// Explicación con binarios:
66+
// 0011 1100 -> 60
67+
// 0000 1101 -> 13
68+
// ------------ & (AND)
69+
// 0000 1100 -> 12
70+
71+
let operadorOr = operadorA | operadorB; // Operador de OR bit a bit (|)
72+
console.log("OR: " + operadorOr); // 61
73+
// Explicación con binarios:
74+
// 0011 1100 -> 60
75+
// 0000 1101 -> 13
76+
// ------------ | (OR)
77+
// 0011 1101 -> 61
78+
79+
let operadorXor = operadorA ^ operadorB; // Operador de XOR bit a bit (^)
80+
console.log("XOR: " + operadorXor); // 49
81+
// Explicación con binarios:
82+
// 0011 1100 -> 60
83+
// 0000 1101 -> 13
84+
// ------------ ^ (XOR)
85+
// 0011 0001 -> 49
86+
87+
let operadorNot = ~operadorA; // Operador de NOT bit a bit (~)
88+
console.log("NOT: " + operadorNot); // -61
89+
// Explicación con binarios:
90+
// 0011 1100 -> 60
91+
// ------------ ~ (NOT)
92+
// 1100 0011 -> -61
93+
94+
let operadorDesplazamientoIzquierda = operadorA << 2; // Operador de desplazamiento a la izquierda (<<)
95+
console.log("Desplazamiento a la izquierda: " + operadorDesplazamientoIzquierda); // 240
96+
// Explicación con binarios:
97+
// 0011 1100 -> 60
98+
// --------- << (Desplazamiento a la izquierda de 2 bits)
99+
// 1111 0000 -> 240
100+
101+
let operadorDesplazamientoDerecha = operadorA >> 2; // Operador de desplazamiento a la derecha (>>)
102+
console.log("Desplazamiento a la derecha: " + operadorDesplazamientoDerecha); // 15
103+
// Explicación con binarios:
104+
// 0011 1100 -> 60
105+
// --------- >> (Desplazamiento a la derecha de 2 bits)
106+
// 0000 1111 -> 15
107+
108+
let operadorDesplazamientoDerechaSinSigno = operadorC >>> 2; // Operador de desplazamiento a la derecha sin signo (>>>)
109+
console.log("Desplazamiento a la derecha sin signo: " + operadorDesplazamientoDerechaSinSigno); // 1073741821
110+
// Explicación con binarios:
111+
// 1111 1111 1111 1111 1111 1111 1111 0110 -> -10
112+
// --------- >>> (Desplazamiento a la derecha sin signo de 2 bits)
113+
// 0011 1111 1111 1111 1111 1111 1111 1101 -> 1073741821
114+
115+
116+
117+
// 3. Operadores de Asignación.
118+
console.log("3. Operadores de Asignación");
119+
120+
let asignacion = 5; // Operador de asignación (=)
121+
console.log("Asignación: " + asignacion); // 5
122+
123+
asignacion += 5; // Operador de suma y asignación (+=)
124+
console.log("Suma y asignación: " + asignacion); // 10
125+
126+
asignacion -= 5; // Operador de resta y asignación (-=)
127+
console.log("Resta y asignación: " + asignacion); // 5
128+
129+
asignacion *= 5; // Operador de multiplicación y asignación (*=)
130+
console.log("Multiplicación y asignación: " + asignacion); // 25
131+
132+
asignacion /= 5; // Operador de división y asignación (/=)
133+
console.log("División y asignación" + asignacion); // 5
134+
135+
asignacion %= 3; // Operador de módulo y asignación (%=)
136+
console.log("Modulo y asignación: " + asignacion); // 2
137+
138+
asignacion **= 3; // Operador de exponenciación y asignación (**=)
139+
console.log("Exponenciación y asignación: " + asignacion); // 8
140+
141+
asignacion <<= 5; // Operador de desplazamiento a la izquierda y asignación (<<=)
142+
console.log("Desplazamiento a izquierda: " + asignacion); // 256
143+
// Explicación con binarios:
144+
// 0000 0000 1000 -> 8
145+
// --------- <<= (Desplazamiento a la izquierda de 5 bits)
146+
// 0001 0000 0000 -> 256
147+
148+
// let desplazamient = suma >> resta;
149+
150+
asignacion >>= 2; // Operador de desplazamiento a la derecha y asignación (>>=)
151+
console.log("Desplazamiento a derecha: " + asignacion); // 64
152+
// Explicación con binarios:
153+
// 0001 0000 0000 -> 256
154+
// --------- >>= (Desplazamiento a la derecha de 2 bits)
155+
// 0000 0100 0000 -> 64
156+
157+
// Operador de desplazamiento a la derecha sin signo y asignación (>>>=) desplaza los bits a la derecha
158+
// sin importar si el numero es positivo o negativo para lo cual agrerga 0 a la izquierda
159+
let a = -10;
160+
a >>>= 2; // Operador de desplazamiento a la derecha sin signo y asignación (>>>=)
161+
console.log("Despolazamient a derecha sin signo: " + a); // 1073741821
162+
// Explicación con binarios:
163+
// 1111 1111 1111 1111 1111 1111 1111 0110 -> -10
164+
// --------- >>>= (Desplazamiento a la derecha sin signo de 2 bits)
165+
// 0011 1111 1111 1111 1111 1111 1111 1101 -> 1073741821
166+
167+
let num1 = 60;
168+
num1 &= 13; // Operador de AND bit a bit y asignación (&=)
169+
console.log("Operador de AND bit a bit y asignación: " + num1); // 12
170+
// Explicación con binarios:
171+
// 0011 1100 -> 60
172+
// 0000 1101 -> 13
173+
// ------------ & (AND)
174+
// 0000 1100 -> 12
175+
176+
num1 = 60;
177+
num1 |= 13; // Operador de OR bit a bit y asignación (|=)
178+
console.log("Operador de OR bit a bit y asignación: " + num1); // 61
179+
// Explicación con binarios:
180+
// 0011 1100 -> 60
181+
// 0000 1101 -> 13
182+
// ------------ | (OR)
183+
// 0011 1101 -> 61
184+
185+
num1 = 60;
186+
num1 ^= 13; // Operador de XOR bit a bit y asignación (^=)
187+
console.log("Operador de XOR bit a bit y asignación" + num1); // 49
188+
// Explicación con binarios:
189+
// 0011 1100 -> 60
190+
// 0000 1101 -> 13
191+
// ------------ ^ (XOR)
192+
// 0011 0001 -> 49
193+
194+
195+
196+
// 4. Operadores de Comparación
197+
console.log("4. Operadores de Comparación");
198+
199+
let comparacionIgual = 5 == 5; // Operador de igualdad (==)
200+
console.log("Igualdad: " + comparacionIgual); // true
201+
202+
let comparacionEstrictamenteIgual = 5 === 5; // Operador de igualdad estricta (===), no solo compara el valor sino también el tipo de dato
203+
console.log("Igualdad estricta: " + comparacionEstrictamenteIgual); // true
204+
205+
let comparacionDistinto = 5 != 5; // Operador de distinto (!=)
206+
console.log("Distinto: " + comparacionDistinto); // false
207+
208+
let comparacionEstrictamenteDistinto = 5 !== 5; // Operador de distinto estricto (!==), no solo compara el valor sino también el tipo de dato
209+
console.log("Distinto estricto: " + comparacionEstrictamenteDistinto); // false
210+
211+
let comparacionMayorQue = 5 > 3; // Operador de mayor que (>)
212+
console.log("Mayor que: " + comparacionMayorQue); // true
213+
214+
let comparacionMenorQue = 5 < 3; // Operador de menor que (<)
215+
console.log("Menor que: " + comparacionMenorQue); // false
216+
217+
let comparacionMayorIgualQue = 5 >= 5; // Operador de mayor o igual que (>=)
218+
console.log("Mayor o igual que: " + comparacionMayorIgualQue); // true
219+
220+
let comparacionMenorIgualQue = 5 <= 3; // Operador de menor o igual que (<=)
221+
console.log("Menor o igual que: " + comparacionMenorIgualQue); // false
222+
223+
224+
225+
// 5. Operadores Lógicos
226+
227+
let logicoAnd = true && false; // Operador AND lógico (&&) - Devuelve true si ambos operandos son true
228+
console.log("AND lógico: " + logicoAnd); // false
229+
230+
let logicoOr = true || false; // Operador OR lógico (||) - Devuelve true si al menos uno de los operandos es true
231+
console.log("OR lógico: " + logicoOr); // true
232+
233+
let logicoNot = !true; // Operador NOT lógico (!) - Devuelve true si el operando es false y viceversa
234+
console.log("NOT lógico: " + logicoNot); // false
235+
236+
// Ejemplo de uso de operadores lógicos
237+
238+
let edad = 16;
239+
let estaAcompanado = false;
240+
241+
let puedeVerPelicula = edad >= 18 || (edad >= 16 && estaAcompanado);
242+
console.log(puedeVerPelicula);
243+
// Cambiamos el valor de la variable estaAcompanado a valor contrario por diversión.
244+
if (!puedeVerPelicula) {
245+
console.log("Puedes ver la película");
246+
} else {
247+
console.log("No puedes ver la película");
248+
}
249+
250+
251+
252+
// 6. Operadores de Cadena
253+
console.log("6. Operadores de Cadena");
254+
255+
let cadena1 = "Hola, la suma de: " + suma + " y " + resta + " es " + (suma + resta); // Concatenación (+)
256+
console.log(cadena1); // Hola, la suma de: 5 y 5 es 10
257+
258+
259+
// 7. Operador Condicional (Ternario)
260+
console.log("7. Operador Condicional (Ternario)");
261+
262+
let puedeVerPelicula2 = edad >= 18 ? "Puede ver la película" : "No puede ver la película"; // Operador condicional (Ternario)
263+
console.log(puedeVerPelicula2); // No puede ver la película
264+
265+
// 8. Otros Operadores
266+
console.log("8. Otros Operadores");
267+
268+
// Se crea el objeto persona
269+
let persona = {
270+
nombre: "Leonardo",
271+
edad: 26
272+
};
273+
274+
let operadorTypeof = typeof persona; // Operador typeof - Devuelve el tipo de dato de una variable
275+
console.log("Tipo de dato de suma: " + operadorTypeof); // object
276+
277+
let operadorDelete = delete persona.edad; // Operador delete - Elimina una propiedad de un objeto
278+
console.log("Propiedad eliminada: " + operadorDelete); // true
279+
280+
let operadorIn = "nombre" in persona; // Operador in - Devuelve true si una propiedad existe en un objeto
281+
console.log("Propiedad en el objeto: " + operadorIn); // true
282+
283+
let operadorInstanceOf = persona instanceof Object; // Operador instanceof - Devuelve true si un objeto es una instancia de otro
284+
console.log("Es una instancia de Object: " + operadorInstanceOf); // true
285+
286+
let operadorNew = new Date(); // Operador new - Crea una nueva instancia de un objeto
287+
console.log("Nueva instancia de Date: " + operadorNew); // Fecha actual
288+
289+
290+
// DIFICULTAD EXTRA - Crea un programa que imprima por consola todos los números comprendidos entre 10 y 55 (incluidos)
291+
// pares, y que no son ni el 16 ni múltiplos de 3.
292+
293+
console.log("DIFICULTAD EXTRA");
294+
295+
for (let i = 10; i < 56; i++) {
296+
if (i % 2 === 0 && i !== 16 && i % 3 !== 0) {
297+
console.log(i);
298+
}
299+
}

0 commit comments

Comments
 (0)