Your SlideShare is downloading. ×
0
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Javascript 1
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Javascript 1

7,829

Published on

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
7,829
On Slideshare
0
From Embeds
0
Number of Embeds
6
Actions
Shares
0
Downloads
125
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. CONCEPTOS Y EJERCICIOS DE JAVASCRIPT YA Presentado por: JUAN CAMILO CARVAJAL
  • 2. Contenido  Conceptos de Algoritmo, Programa y Lenguaje de Programación  Qué es JavaScript? Ejercicio  Variables Ejercicio  Entrada de datos por teclado Ejercicio  Estructuras secuenciales de programación Ejercicio  Estructuras condicionales simples Ejercicio  Estructuras condicionales compuestas Ejercicio  Estructuras condicionales anidadas Ejercicio
  • 3.  Operadores lógicos && (y) en las estructuras condicionales Ejercicio  Operadores lógicos || (o) en las estructuras condicionales Ejercicio  Estructuras switch Ejercicio  Estructura repetitiva (while) Ejercicio  Concepto de acumulador Ejercicio  Estructura repetitiva (do/while) Ejercicio  Estructura repetitiva (for) Ejercicio
  • 4. Conceptos de Algoritmo, Programa y Lenguaje de Programación Un algoritmo son los pasos a seguir para resolver un problema. Un programa es un conjunto de instrucciones que entiende un ordenador para realizar una actividad. Tiene un objetivo bien definido. Lo necesario por el programador es la solución empleando el ordenador como fundamento. Es necesario plantear un algoritmo. El lenguaje de programación son las instrucciones entendidas por la PC para obtener operaciones, mostrar datos por pantalla, sacar listados por impresora, etc. Utilizaremos el lenguaje de programación JavaScript.
  • 5. Qué es JavaScript? Es una de las maneras de extender el lenguaje HTML. Es un lenguaje script u orientado a documento. No se puede desarrollar un programa con JavaScript que se ejecute fuera de un Navegador. JavaScript es un lenguaje interpretado significa que a las instrucciones las analiza y procesa el navegador en el momento que deben ser ejecutadas. El programa en JavaScript debe ir encerrado entre la marca script e inicializada la propiedad languaje con la cadena javascript: <script language="javascript"> </script> Llammos write para imprimir caracteres. La informacion va en comillas y en parentesis. ES IMPORTANTISIMO TENER EN CUENTA QUE JavaScript es SENSIBLE A MAYUSCULAS Y MINUSCULAS
  • 6. Ejercicio <html> <head> <title>Problema</title> </head> <body> <script language="javascript"> document.write('Carlos'); document.write("<br>"); document.write('17 años'); </script> </body> </html>
  • 7. Variables Una variable es un depósito donde hay un valor. Consta de un nombre y pertenece a un tipo (numérico, cadena de caracteres, etc.). Una variable puede almacenar: Valores Enteros (100, 260, etc.) Valores Reales (1.24, 2.90, 5.00, etc.) Cadenas de caracteres ("Juan", "Compras", "Listado", etc.) Valores lógicos (true,false) Una variable no puede ser la misma palabra que un palabra clave del lenguaje, se define anteponiéndole la palabra clave var, Debemos elegir nombres de variables representativos, Para mostrar el contenido de una variable en una página utilizamos el objeto document y llamamos a la función write. Los valores de las variables que almacenan nombres deben ir encerradas entre comillas simples y Los valores de las variables enteras y reales no deben ir encerradas entre comillas. Cada instrucción finaliza con un punto y coma.
  • 8. Ejercicio <html> <head> <title>Problema</title> </head> <body> <script language="javascript"> var nombre='manuel' var sueldo=400000 document.write('el operario '+nombre); document.write(' tiene un sueldo de '+sueldo); </script> </body> </html>
  • 9. Entrada de datos por teclado Para la entrada de datos por teclado esta la función prompt. Hay otras formas más sofisticadas para la entrada de datos en una página HTML, La sintaxis de la función prompt es: <variable que recibe el dato>=prompt(<mensaje a mostrar en la ventana>,<valor inicial a mostrar en la ventana>); La función prompt tiene dos parámetros: uno es el mensaje y el otro el valor incial a mostrar.
  • 10. Ejercicio <html> <head> </head> <body> <script language="JavaScript"> var nombre; var correo; nombre=prompt('Ingrese su nombre:',''); correo=prompt('Ingrese su correo electronico:',''); document.write('Hola '); document.write(nombre); document.write(' asi que tu correo electronico es '); document.write(correo); </script> </body> </html>
  • 11. Estructuras secuenciales de programación se la denomina estructura secuencial cuando en un problema sólo participan operaciones, entradas y salidas. Para que el operador + sume los valores numéricos ingresados, llamamos la función parseInt. asi suma las variables como enteros. Cuando se emplea el operador * para el producto, ya no es obligatorio utilizar la función parseInt (es decir, sólo para el operador + debemos utilizarla). En JavaScript, como no podemos indicarle de qué tipo es la variable, requiere mucho más cuidado cuando operamos con sus contenidos.
  • 12. Ejercicio <html> <head> <script language="JavaScript"> var valor1; valor1=prompt('Ingrese el valor del lado:',''); var producto=valor1*4; document.write('El perimetro es '); document.write(producto); </script> </head> <body> </body> </html>
  • 13. Estructuras condicionales simples Cuando hay que tomar una decisión aparecen las estructuras condicionales y ya no se resuelve copmo secuencial. En un problema se combinan estructuras secuenciales y condicionales. Cuando se presenta la elección tenemos la opción de realizar una actividad o no realizarla. En una estructura CONDICIONAL SIMPLE por la parte verdadera hay actividades, existen varias operaciones, entradas y salidas y por parte falsa no hay actividades. Aparece la instrucción if. Debe ir entre paréntesis. Si se verifica verdadera se ejecuta todas las instrucciones que se encuentran encerradas entre las llaves de apertura y cerrado seguidas al if. La condición del if deben intervenir una variable, un operador relacional y otra variable o valor fijo.
  • 14. Ejercicio <html> <head> </head> <body> <script language="javascript"> var nombre; var clave; var clave2; nombre=prompt('Ingrese nombre:',''); clave=prompt('Ingrese su clave:',''); clave2=prompt('Ingrese su clave nuevamente:',''); if (clave==clave2) { document.write(nombre+' la calve es correcta ');} </script> </body> </html>
  • 15. Estructuras condicionales compuestas Tenemos actividades por la parte verdadera y por la falsa de la condición. Hay que tener en cuenta es que se realizan las actividades de parte del verdadero o las del falso, NUNCA se realizan las actividades de las dos partes. La función prompt retorna un string por lo que debemos convertirlo a entero cuando queremos saber cual de los dos valores es mayor numéricamente. En el lenguaje JavaScript una variable puede ir cambiando el tipo de dato que almacena a lo largo de la ejecución del programa. Más adelante veremos qué sucede cuando preguntamos cuál de dos string es mayor. Es igual que la estructura condicional simple salvo que aparece la palabra clave “else” y posteriormente un bloque { } con una o varias instrucciones.
  • 16. Ejercicio <html> <head> </head> <body> <script language="javascript"> var num1,num2; num1=prompt('Ingrese el primer número:',''); num2=prompt('Ingrese el segundo número:',''); num1=parseInt(num1); num2=parseInt(num2); var suma=num1+num2 var resta=num1-num2 var producto=num2*num1 var division=num1/num2 if (num1>num2) { document.write('La suma es '+suma); documen.write(' y su resta es '+resta);} else {document.write('el producto es '+producto); document.write(' y su division es '+division);} </script> </body> </html>
  • 17. Estructuras condicionales anidadas Una estructura condicional es anidada cuando por la rama del verdadero o el falso de una estructura condicional hay otra estructura condicional.
  • 18. Ejercicio <html> <head> </head> <body> <script language="javascript"> var num1,num2; num1=prompt('Ingrese el primer número:',''); num2=prompt('Ingrese el segundo número:',''); num1=parseInt(num1); num2=parseInt(num2); var suma=num1+num2 var resta=num1-num2 var producto=num2*num1 var division=num1/num2 if (num1>num2) {document.write('La suma es '+suma); documen.write(' y su resta es '+resta);} else {document.write('el producto es '+producto); document.write(' y su division es '+division);} </script> </body> </html>
  • 19. Operadores lógicos && (y) en las estructuras condicionales El operador &&, traducido se lo lee como "Y". Se emplea cuando en una estructura condicional se disponen dos condiciones. Cuando vinculamos dos o más condiciones con el operador "&&" las dos condiciones deben ser verdaderas para que el resultado de la condición compuesta de Verdadero y continúe por la rama del verdadero de la estructura condicional. La utilización de operadores lógicos permiten en muchos casos, plantear algoritmos más cortos y comprensibles.
  • 20. Ejercicio <html> <head> </head> <body> <script language="javascript"> var num1,num2,num3; num1=prompt('Ingrese primer número:',''); num2=prompt('Ingrese segundo número:',''); num3=prompt('Ingrese tercer número:',''); num1=parseInt(num1); num2=parseInt(num2); num3=parseInt(num3); if (num1<10 && num2<10 && num3<10) { document.write('todos los numeros son menores a 10'); } else { if (num1>10 && num2<10 && num3>10) { document.write('el segundo numero es menor que 10'); } else { if (num1>10 && num2>10 && num3<10) { document.write('el tercer numero es menor que 10'); } else { document.write('todos los numeros son mayores que 10'); } } </script> </body> </html>
  • 21. Operadores lógicos || (o) en las estructuras condicionales Traducido se lo lee como "O". Si la condición 1 es Verdadera o la condición 2 es Verdadera, luego ejecutar la rama del Verdadero. Cuando vinculamos dos o más condiciones con el operador "O", con que una de las dos condiciones sea Verdadera alcanza para que el resultado de la condición compuesta sea Verdadero.
  • 22. Ejercicio <html> <head> </head> <body> <script language="javascript"> var num1,num2,num3; num1=prompt('Ingrese numero 1:',''); num2=prompt('Ingrese numero 2:',''); num3=prompt('Ingrese numero 3:',''); num1=parseInt(num1); num2=parseInt(num2); num3=parseInt(num3); if (num<10 || num2<10 || num3<10) { document.write('todos los numeros son menores a diez.'); } </script> </body> </html>
  • 23. Estructuras switch La instrucción switch sirve para remplazar los if/else if. Se puede aplicar en ciertas situaciones donde la condición se verifica si es igual a cierto valor. No podemos preguntar por mayor o menor. La variable que analizamos debe ir después de la instrucción switch entre paréntesis. Cada valor que se analiza debe ir luego de la palabra clave 'case' y seguido a los dos puntos, las instrucciones a ejecutar, en caso de verificar dicho valor la variable que analiza el switch. Es importante disponer la palabra clave 'break' al finalizar cada caso. La instrucciones que hay después de la palabra clave 'default' se ejecutan en caso que la variable no se verifique en algún case.
  • 24. Ejercicio <html> <head> <title>Problema</title> </head> <body> <script language="javascript"> alert("digite 1. casa 2. mesa 3. perro 4. gato") var op = prompt("entre la opcion:", " "); var op = parseInt (op); switch(op) { case 1: alert("home"); break; case 2: alert("table"); break; case 3: alert("dog"); break; case 4: alert("cat"); break; default:alert("numero no valido, ingrese un numero de 1 a 4"); } </script> </body> </html>
  • 25. Estructura repetitiva (while) Una estructura repetitiva permite ejecutar una instrucción o un conjunto de instrucciones varias veces. Se caracteriza por: - La o las sentencias que se repiten. - El test o prueba de condición antes de cada repetición, que motivará que se repitan o no las sentencias. Se verifica la condición, si resulta verdadera se ejecutan las operaciones que indicamos entre las llaves que le siguen al while. Si la condición es Falsa continua con la instrucción siguiente al bloque de llaves. El bloque se repite MI ENTRAS la condición sea Verdadera. Si la condición siempre retorna verdadero estamos en presencia de un ciclo repetitivo infinito. Dicha situación es un error de programación, nunca finalizará el programa.
  • 26. Ejercicio <html> <head> <title>Problema</title> </head> <body> <script language="javascript"> var num; num=0; while (num<=500) { document.write(num); document.write('<br>'); num=num+11; } </script> </body> </html>
  • 27. Concepto de acumulador ACUMULADOR (un acumulador es un tipo especial de variable que se incrementa o decrementa con valores variables durante la ejecución del programa). Un ejemplo seria cuando se le da nombre de suma al acumulador. Cada ciclo que se repita la estructura repetitiva, la variable suma se incrementa con el contenido ingresado en la variable valor.
  • 28. Ejercicio <html> <head> </head> <body> <script language="javascript"> var cont=1; var suma=0; var altura; while (cont<=5) { altura=prompt('Ingrese su altura:',''); altura=parseInt(altura); suma=suma+altura; cont=cont+1; } promedio=suma/2; document.write("El promedio de las alturas es de: "+promedio+"<br>"); </script> </body> </html>
  • 29. Estructura repetitiva (do/while) La sentencia do/while es otra estructura repetitiva, la cual ejecuta al menos una vez su bloque repetitivo, a diferencia del while que puede no ejecutar el bloque. Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se ejecutará el bloque repetitivo. La condición de la estructura está abajo del bloque a repetir, a diferencia del while que está en la parte superior. Finaliza la ejecución del bloque repetitivo cuando la condición retorna falso, es decir igual que el while.
  • 30. Ejercicio <html> <head> </head> <body> <script language="javascript"> var valor; var suma=0; do { valor=prompt('Ingrese un valor___ 9999 para terminar:',''); valor=parseInt(valor); suma=suma+valor; document.write('<br>'); } while(valor != 9999); total=suma-9999; if(total==0) { document.write( total + " es igual a cero"); } else { if (valor>0) { document.write(total + " es mayor que cero") ; } else { if (valor<0) { document.write("Valor igual a cero") ; } } } </script> </body> </html>
  • 31. Estructura repetitiva (for) Esta estructura se emplea en aquellas situaciones en las cuales CONOCEMOS la cantidad de veces que queremos que se ejecute el bloque de instrucciones. Este tipo de estructura repetitiva se utiliza generalmente cuando sabemos la cantidad de veces que deseamos que se repita el bloque. Tener en cuenta que no lleva punto y coma al final de los tres argumentos del for. El disponer un punto y coma provoca un error lógico y no sintáctico, por lo que el navegador no avisará.
  • 32. Ejercicio <html> <head> <title>Problema</title> </head> <body> <script language="javascript"> var c; for(c=1;c<=10;c++) { tabla=c*5; document.write("5 * "+ c + " = " + tabla + "<br>"); } </script> </body> </html>

×