Análisis y Desarrollo de Software

Ficha: 2627052

Evidencia de conocimiento: GA3-220501093-AA3-EV01 bases teóricas de estructuras

de almacenamiento en memoria

Aprendices

Carlos Andrés Ortiz Galeano

Leehinder Alfonso Sánchez Durán
Catherine Ardmirola Mendoza.

Instructor
Betsy Arguello Ayala

Servicio Nacional de Aprendizaje (SENA)

Bucaramanga Abril 2023
Santander

1
Contenido
INTRODUCCION ............................................................................................................................... 3
BASES TEÓRICAS DE ESTRUCTURAS DE ALMACENAMIENTO EN MEMORIA ....................................... 4
1. Principales diferencias entre los lenguajes compilados e interpretados ................................ 4
2. Características principales de JavaScript................................................................................. 5
3. Tipos de datos primitivos y uso en JavaScript ......................................................................... 6
4. Operadores en JavaScript........................................................................................................ 7
• Operadores aritméticos ...................................................................................................... 7
• Operadores lógicos.............................................................................................................. 8
• Operadores de comparación ............................................................................................. 11
• Operadores Binarios.......................................................................................................... 12
• Operadores de asignación................................................................................................. 12
• Unos operadores atípicos.................................................................................................. 13
Referencias ........................................................................................................................................ 14

2
INTRODUCCION

El siguiente desarrollo de actividad se basa en consolidar los conceptos básicos relacionados con los
lenguajes de programación, entornos de codificación e instalación y la sintaxis del lenguaje de
JavaScript los cuales serán desarrollados para tener claro los conceptos.

3
BASES TEÓRICAS DE ESTRUCTURAS DE
ALMACENAMIENTO EN MEMORIA

1. Principales diferencias entre los lenguajes compilados e

interpretados

Lenguajes compilados Lenguajes interpretados

Un lenguaje compilado genera un file Un lenguaje interpretado es escrito en un
binario no modificable lenguaje de programación definido y
modificable en cada momento

Las instrucciones vienen enviadas Las instrucciones deben traducirse antes de

directamente al procesador llegar al procesador

Se requieren dos pasos separados para El código fuente se ejecuta a través de un

ejecutar el programa desde el código fuente solo comando

Dado que el programa ya se ha traducido, El programa debe traducirse cada vez

la ejecución es más rápida aumentando el tiempo de ejecución.

El programa solo se puede ejecutar en El programa funciona en todas las

ciertas máquinas y sistemas operativos máquinas y sistemas

Los errores de compilación impiden que se Los errores de compilación son visibles
compile el código sólo si se inicia el programa

4
Ejemplos de lenguajes compilados son C, Ejemplos de lenguajes interpretados son
C++, Delphi Python, Javascript, Perl, PHP

2. Características principales de JavaScript

• Simplicidad. Posee una estructura sencilla que lo vuelve más fácil de aprender e
implementar.
• Velocidad. Se ejecuta más rápido que otros lenguajes y favorece la detección de los
errores.
• Versatilidad. Es compatible con otros lenguajes, como: PHP, Perl y Java. Además,
hace que la ciencia de datos y el aprendizaje automático sean accesibles.
• Popularidad. Existen numerosos recursos y foros disponibles para ayudar a los
principiantes con habilidades y conocimientos limitados.
• Carga del servidor. La validación de datos puede realizarse a través del navegador
web y las actualizaciones solo se aplican a ciertas secciones de la página web.

5
 • Actualizaciones. Se actualiza de forma continua con nuevos frameworks y librerías,
esto le asegura relevancia dentro del sector.

3. Tipos de datos primitivos y uso en JavaScript

6
 4. Operadores en JavaScript

En JavaScript encontramos cinco tipos de operadores:

• Aritméticos
• Lógicos
• De comparación
• Binarios
• De asignación

• Operadores aritméticos

Suma (+). Suma dos números: 3 + 2 = 5 . Si en lugar de números se suman cadenas, como por ejemplo
"A" + "B" = "AB" se produce una concatenación. Si alguno de los elementos a concatenar no es una
cadena de texto, queda convertido a cadena: "AB" + 123 = "AB123" .
Resta (-). Halla la diferencia entre dos números. Ejemplo A: 3-2 = 1 . Ejemplo B: (-1)-(-2) = 1 .
Negativo (-). Indica el signo negativo de un número o una expresión: -3.
División (/). Divide dos números, obteniendo un cociente de coma flotante: 5 / 2 = 2.5 . Fíjate en que
el separador decimal es el punto.
Módulo aritmético %. Divide dos números, obteniendo un resto entero: 5 % 2 = 1 .
Multiplicación (*). Multiplica dos números: 3 * 2 = 6 .
Incrementos y decrementos (++ --). Incrementa o decrementa el valor de una variable numérica en
una unidad. No puede aplicarse a un literal. Pueden darse dos casos:
var A, B; B = 2;
A = ++B
A = B++
En el primer caso, A = 3 Es decir, que el incremento de B ha sido el correcto, pero no así el segundo,
en el que A = 2. Esto se debe a que, en el primer caso, el incremento se efectúa antes de que la
expresión sea evaluada, y en el segundo, se incrementa después de la evaluación según indica el orden
de precedencia de los operadores (ver tabla al final de esta página). De igual forma, para decrementos:
var A, B; B = 2;
A = --B
A = B--
En el primer caso resulta: A = 1 y en el segundo: A = 2

7
 • Operadores lógicos

Estos operadores tienen unas aplicaciones un tanto especiales, ya que no funcionan como los
aritméticos, conocidos por todos. Para comprender el funcionamiento de los operadores lógicos,
primero hay que saber qué son los estados lógicos de una expresión. Y te preguntarás que es eso de
"estados lógicos"... Esta es una cuestión un tanto filosófica, ya que el estado lógico de algo depende
de respecto a qué establecemos ese estado, y por tanto no siempre será el mismo. Dependerá del
entorno o contexto en el que se define y utiliza la expresión. En JavaScript hay tres posibles estados
lógicos: True (verdadero), False (falso) y Null (nulo, es decir que no se ha establecido estado alguno
por la razón que sea)
Por ejemplo, supongamos que hay que establecer el estado lógico de un material: El hierro.
Evidentemente, para establecer un estado lógico primero tenemos que decidir respecto a qué se
establece ese estado, ya que no podemos decir simplemente que el hierro es verdadero o falso. Nos
tendremos que referir a alguna cualidad del material y compararla con algo para establecer si el estado
es verdadero o falso.
Sea la expresión El hierro es un metal . Si tenemos que establecer el estado lógico de esta expresión,
la respuesta inmediata es Verdadero (True) y si la expresión fuese El hierro no es un metal ,
inmediatamente pensarímos que el estado adecuado es Falso (False)
Una vez establecido el estado lógico de la expresión, los operadores lógicos nos permitirán tomar
decisiones mediante la verificación de ese estado, bien tomando uno solo, o agrupando varios de ellos.
Al igual que los operadores aritméticos, los operadores lógicos tienen un orden preestablecido de
evaluación que debe ser tenido en cuenta. Los estados lógicos, o mejor dicho, el resultado que dan
los operadores lógicos, pueden tratarse también como números booleanos, siendo True equivalente a
1 y False equivalente a 0.
Negación lógica ! (Not). Establece una negación lógica en una expresión, es decir, que ante una
expresión, cuyo estado lógico es True (verdadero), el operador hará que devuelva False (falso).

El hierro es un metal = True.

! El hierro es un metal = False.

Hay tres posibles resultados aplicando este operador a una expresión:

Si la expresión = True el operador devuelve False.

Si la expresión = False el operador devuelve True.
Si la expresión = Null el operador devuelve Null.

Conjunción lógica && (And). Establece una conjunción lógica de dos expresiones, es decir, que han
de resultar True (verdadero) las dos expresiones para que el resultado final también lo sea.

8
El hierro es un metal = True.
El hierro es duro = True.
El hierro es un metal && El hierro es duro = True.

Hay 9 posibles resultados aplicando este operador a dos expresiones, aunque es posible incluir cuantas
sean necesarias:

Si la Expresión 1 = True && Expresión 2 = True el resultado es True.

Si la Expresión 1 = True && Expresión 2 = False el resultado es False.
Si la Expresión 1 = True && Expresión 2 = Null el resultado es Null.
Si la Expresión 1 = False && Expresión 2 = True el resultado es False.
Si la Expresión 1 = False && Expresión 2 = False el resultado es False.
Si la Expresión 1 = False && Expresión 2 = Null el resultado es False.
Si la Expresión 1 = Null && Expresión 2 = True el resultado es Null.
Si la Expresión 1 = Null && Expresión 2 = False el resultado es False.
Si la Expresión 1 = Null && Expresión 2 = Null el resultado es Null.
Como puedes ver, si, y sólo si, ambas expresiones se evalúan como True, el resultado es True. Si
cualquiera de las expresiones es False, el resultado es False.

Disyunción lógica || (Or). Establece una disyunción lógica de dos expresiones, es decir, que el
resultado se dará evaluando una expresión u otra.

El hierro es un metal = True.

El hierro es duro = True.
El hierro es un metal || El hierro es duro = True.

Hay 9 posibles resultados aplicando este operador a dos expresiones, aunque es posible incluir cuantas
sean necesarias:

Si la Expresión 1 = True || Expresión 2 = True el resultado es True.

9
Si la Expresión 1 = True || Expresión 2 = False el resultado es True.
Si la Expresión 1 = True || Expresión 2 = Null el resultado es True.
Si la Expresión 1 = False || Expresión 2 = True el resultado es True.
Si la Expresión 1 = False || Expresión 2 = False el resultado es False.
Si la Expresión 1 = False || Expresión 2 = Null el resultado es Null.
Si la Expresión 1 = Null || Expresión 2 = True el resultado es True.
Si la Expresión 1 = Null || Expresión 2 = False el resultado es Null.
Si la Expresión 1 = Null || Expresión 2 = Null el resultado es Null.
Como puedes ver, si cualquiera de las expresiones, o ambas, son True, el resultado es True.

Exclusión lógica ^ (Xor). Establece una exclusión lógica de dos expresiones, es decir, que el resultado
se dará evaluando una expresión u otra, y dará True si solamente una de ellas es True, lo que implica
la exclusión de la otra.

El hierro es un metal = True.

El hierro es duro = True.
El hierro es un metal ^ El hierro es duro = False.

Hay 4 posibles resultados aplicando este operador a dos expresiones:

Si la Expresión 1 = True ^ Expresión 2 = True el resultado es False.

Si la Expresión 1 = True ^ Expresión 2 = False el resultado es True.
Si la Expresión 1 = False ^ Expresión 2 = True el resultado es True.
Si la Expresión 1 = False ^ Expresión 2 = False el resultado es False.
Como puedes ver, si una y sólo una de las expresiones es True, el resultado es True. Si cualquiera de
las expresiones es Null, el resultado también será Null.

10
 • Operadores de comparación

Igualdad (==) Verifica la igualdad de dos expresiones sin tener en cuenta el tipo de dato.
Por ejemplo: 2 == "2" devuelve True
Igualdad estricta (===) Hace lo mismo que el anterior, pero verificando también que coincidan los
tipos de datos.
Por ejemplo: 2 === "2" devuelve False
Desigualdad (!=) Funciona de la misma forma que la igualdad, pero negándola.
Por ejemplo: 2 != "2" devuelve False
Desigualdad estricta (!==) Lo mismo que la igualdad estricta, pero negándola.
Por ejemplo: 2 !== "2" devuelve True

Y estos cuatro, seguro que ya sabes cómo funcionan:

Mayor que (>)
Mayor o igual que (>=)
Menor que (<)
Menor o igual que (<=)
Operadores que trabajan con bits
Existen algunos operadores que funcionan bit a bit, convirtiendo previamente los valores a binario.
Son los siguientes: << >> >>> & | ^
Para comprender como trabajan estos complicados operadores lo mejor son los ejemplos:
Bitwise shift operators
9 << 2 = 36 con valor negativo: -9 << 2 = -36
Primero convierte a binario el primer operando 9 = 1001 A continuación añade a su derecha el
número de bits cero que indique el segundo operando (2). Resulta: 1001 00 = 36
9 >> 2 = 2 con valor negativo: -9 >> 2 = -3
Primero convierte a binario el primer operando 9 = 1001 A continuación, y comenzando de derecha
a izquierda, elimina el número de bits que indique el segundo operando (2). Resulta: 10 = 2
9 >>> 2 = 2 con valor negativo: -9 >>> 2 = 1073741821
Funciona igual que el anterior con números positivos. Con números negativos no está muy claro lo
que hace.

11
 • Operadores Binarios

Al igual que los anteriores, estos operadores trabajan convirtiendo previamente a binario los
operandos, en la base de enteros de 32 bits. Para operar emparejan cada bit del primer operando con
su correspondiente del segundo operando, aplicando el operador uno a uno hasta obtener el resultado
final. Por ejemplo, el número 15 en binario es 1111 y el 9 1001. Si aplicamos los tres operadores
lógicos a esta pareja de valores, se obtiene:
15 & 9 = 9 (1111 AND 1001 = 1001)
15 | 9 = 15 (1111 OR 1001 = 1111)
15 ^ 9 = 6 (1111 XOR 1001 = 0110)
Y seguramente te estarás diciendo que no entiendes nada... Analicemos uno.
Sea, por ejemplo, el último de ellos: 15 ^ 9 = 6. Más arriba se ha descrito este mismo operador, que
es Xor. Recordemos que establece una exclusión lógica de dos expresiones, es decir, que el resultado
se dará evaluando ambos valores, y dará True si solamente una de ellas es True. Recordemos también
que en binario 1 = True y 0 = False. Por tanto

15 = 1 1 1 1
9= 1 0 0 1
------------------------------
False True True False o lo que es igual, 0110
No hay que confundir estos tres operadores con sus homólogos lógicos vistos más arriba, que se
representan con el mismo símbolo pero doble (excepto este).

• Operadores de asignación

Asignación simple (=) Asigna un contenido a una variable o a un objeto.

Por ejemplo: mivariable = "Saludos"
En JavaScript el operador de asignación tiene la particularidad de que puede combinarse con algunos
de los operadores aritméticos, dando lugar a toda una familia de nuevos operadores:

A += B Ejemplo equivalente: A = A + B

12
A -= B Ejemplo equivalente: A = A - B

A /= B Ejemplo equivalente: A = A / B

A *= B Ejemplo equivalente: A = A * B

A %= B Ejemplo equivalente: A = A % B

A &= B Ejemplo equivalente: A = A & B

A ^= B Ejemplo equivalente: A = A ^ B

A |= B Ejemplo equivalente: A = A | B

• Unos operadores atípicos

typeof Este operador nos indica el tipo de dato contenido en un variable, un literal o el resultado de
una expresión. Puede devolver seis valores diferentes: number, string, object, function, boolean o
undefined . Por ejemplo:
typeof 2 devuelve number
void Este es un curioso operador que se limita a impedir que todo funcione normalmente, es decir,
que una vez evaluadas la instrucciones, sus efectos o presentación de resultados serán anulados. En
principio podemos dudar de su utilidad, pero puede resultar muy útil en las ocasiones en que,
dependiendo de una evaluación previa, haya que deshabilitar algun objeto o impedir alguna acción.
Por ejemplo, bloqueando un formulario donde no se han cumplimentado algunos campos
obligatorios, o si algun valor es erróneo. El siguiente ejemplo genera un link que no funciona: Este
link no funciona
Y se escribe: <A HREF="javascript:void(0)">Este link no funciona</A>
new Sirve para crear una instancia de un objeto definido por el usuario, o también, para crear alguno
de los objetos intrínsecos de javaScript:, como son: Array, Boolean, Date, Function, Math, Number
o String. Lo veremos con más detalle en la página dedicada a los objetos.

13
Referencias
(2022). Centro Europeo de empresa e inovacion de valencia,
https://ceeivalencia.emprenemjunts.es/?op=8&n=28660. Obtenido de
https://ceeivalencia.emprenemjunts.es/?op=8&n=28660

hackademy, a. (s.f.). aulab hackademy. Obtenido de https://aulab.es/noticia/18/diferencia-entre-

lenguajes-de-programacion-compilados-e-interpretados

https://www.uv.es/jac/guia/jscript/javascr04.htm. (s.f.). Obtenido de

https://www.uv.es/jac/guia/jscript/javascr04.htm:
https://www.uv.es/jac/guia/jscript/javascr04.htm

14