forked from argenisosorio/GuiasLenguajes
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathJavaScript.html
More file actions
5187 lines (4677 loc) · 203 KB
/
Copy pathJavaScript.html
File metadata and controls
5187 lines (4677 loc) · 203 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!-- Guía JavaScript by dM -->
La sintaxis de JavaScript es muy similar a la de otros lenguajes de programación como Java y C.
Las normas básicas que definen la sintaxis de JavaScript son las siguientes:
-No se tienen en cuenta los espacios en blanco y las nuevas líneas: como sucede con XHTML, el intérprete de JavaScript
ignora cualquier espacio en blanco sobrante, por lo que el código se puede ordenar de forma adecuada para entenderlo mejor
(tabulando las líneas, añadiendo espacios, creando nuevas líneas, etc.)
-Se distinguen las mayúsculas y minúsculas: al igual que sucede con la sintaxis de las etiquetas y elementos XHTML.
Sin embargo, si en una página XHTML se utilizan indistintamente mayúsculas y minúsculas, la página se visualiza
correctamente, siendo el único problema la no validación de la página. En cambio, si en JavaScript se
intercambian mayúsculas y minúsculas el script no funciona.
-No se define el tipo de las variables: al crear una variable, no es necesario indicar el tipo de dato que almacenará.
De esta forma, una misma variable puede almacenar diferentes tipos de datos durante la ejecución del script.
-No es necesario terminar cada sentencia con el carácter de punto y coma (;): en la mayoría de lenguajes de
programación, es obligatorio terminar cada sentencia con el carácter ;. Aunque JavaScript no obliga a hacerlo, es
conveniente seguir la tradición de terminar cada sentencia con el carácter del punto y coma (;).
<script type="text/javascript">
-------------------------------------
//Comentarios de línea
/* Comentarios de
multiple línea*/
-------------------------------------
// Saber el largo de una cadena
"cadena".length
6
-------------------------------------
// Se pueden realizar operaciones aritmeticas en la consola de js
//El resultado es mostrado en la consola
2 + 2
3 + 7
8 * 4
10 / 3
-------------------------------------
//Estas cajas de diálogos pueden usarse para que los usuarios confirmen acciones.
//En la consola js se vera si es true o false la confirmacion, util para alertar
confirm("Estoy listo para continuar.");
confirm("El contenido será borrado")
confirm("Los cambios no han sido guardados")
-------------------------------------
//Pedir al usuario que ingrese datos mediante un prompt.
//Los datos introducidos se mostraran en la consola
prompt("Cual es su país");
prompt("Cual es su nombre?");
-------------------------------------
//Compara si la cadena es mayor que un numero
"Cadena de texto larga".length > 10
true
"Cadena".length > 10
false
-------------------------------------
//El comando console.log() toma lo que está entre paréntesis y lo registra en la pantalla debajo de tu código; ¡por eso es que se llama console.log() (registro de pantalla)!
//Realiza operaciones sin mostrar ninguna alerta o mensaje
console.log(2 * 5)
console.log("Hola")
-------------------------------------
var miPais="Venezuela" // Declará una variable en la línea 2 que se llame miPais y dale un valor de cadena.
console.log(miPais.length); //Usá console.log para mostrar el largo de la variable miPais
console.log(miPais.substring(0,3)); //Usá console.log para mostrar las tres primeras letras de miPais
-------------------------------------
##### Sintaxis básica #####
Declaración simple de variable:
var foo = 'Hola Mundo';
Los espacios en blanco no tienen valor fuera de las comillas:
var foo = 'hello world';
Los paréntesis indican prioridad:
2 * 3 + 5; // es igual a 11; la multiplicación ocurre primero
2 * (3 + 5); // es igual a 16; por lo paréntesis, la suma ocurre primero
La tabulación mejora la lectura del código, pero no posee ningún significado especial:
var foo = function() {
console.log('hello');
};
-------------------------------------
######################
##### Operadores #####
######################
Los operadores básicos permiten manipular valores.
##### Concatenación #####
var foo = 'hello';
var bar = 'world';
console.log(foo + ' ' + bar); // la consola de depuración muestra 'hello world'
##### Multiplicación y división #####
2 * 3; 2 / 3;
##### Incrementación y decrementación #####
var i = 1;
var j = ++i; // incrementación previa: j es igual a 2; i es igual a 2
var k = i++; // incrementación posterior: k es igual a 2; i es igual a 3
##### Operaciones con números y cadenas de caracteres #####
En JavaScript, las operaciones con números y cadenas de caracteres (en inglés strings) pueden ocasionar resultados no esperados.
##### Suma vs concatenación #####
var foo = 1;
var bar = '2';
console.log(foo + bar); // error: La consola de depuración muestra 12
Forzar a una cadena de caracteres actuar como un número
var foo = 1;
var bar = '2';
// el constructor 'Number' obliga a la cadena comportarse como un número
console.log(foo + Number(bar)); // la consola de depuración muestra 3
El constructor Number, cuando es llamado como una función (como se muestra en el ejemplo) obliga a su argumento a comportarse como un número. También es posible utilizar el operador de suma unaria, entregando el mismo resultado:
Forzar a una cadena de caracteres actuar como un número (utilizando el operador de suma unaria)
console.log(foo + +bar);
2.3.3. Operadores lógicos
Los operadores lógicos permiten evaluar una serie de operandos utilizando operaciones AND y OR.
##### Operadores lógicos AND y OR #####
var foo = 1;
var bar = 0;
var baz = 2;
foo || bar; // devuelve 1, el cual es verdadero (true)
bar || foo; // devuelve 1, el cual es verdadero (true)
foo && bar; // devuelve 0, el cual es falso (false)
foo && baz; // devuelve 2, el cual es verdadero (true)
baz && foo; // devuelve 1, el cual es verdadero (true)
El operador || (OR lógico) devuelve el valor del primer operando, si éste es verdadero; caso contrario devuelve el segundo
operando. Si ambos operandos son falsos devuelve falso (false). El operador && (AND lógico) devuelve el valor del primer operando
si éste es falso; caso contrario devuelve el segundo operando. Cuando ambos valores son verdaderos devuelve verdadero (true),
sino devuelve falso.
Puede consultar la sección "Elementos Verdaderos y Falsos" para más detalles sobre que valores se evalúan como true y cuales se
evalúan como false.
**Nota:
Puede que a veces note que algunos desarrolladores utilizan esta lógica en flujos de control en lugar de utilizar la declaración
if. Por ejemplo:
// realizar algo con foo si foo es verdadero
foo && doSomething(foo);
// establecer bar igual a baz si baz es verdadero;
// caso contrario, establecer a bar igual al
// valor de createBar()
var bar = baz || createBar();
Este estilo de declaración es muy elegante y conciso; pero puede ser difícil para leer (sobretodo para principiantes). Por eso se explícita, para reconocerlo cuando este leyendo código. Sin embargo su utilización no es recomendable a menos que esté cómodo con el concepto y su comportamiento.
2.3.4. Operadores de comparación
Los operadores de comparación permiten comprobar si determinados valores son equivalentes o idénticos.
Operadores de Comparación
var foo = 1;
var bar = 0;
var baz = '1';
var bim = 2;
foo == bar; // devuelve falso (false)
foo != bar; // devuelve verdadero (true)
foo == baz; // devuelve verdadero (true); tenga cuidado
foo === baz; // devuelve falso (false)
foo !== baz; // devuelve verdadero (true)
foo === parseInt(baz); // devuelve verdadero (true)
foo > bim; // devuelve falso (false)
bim > baz; // devuelve verdadero (true)
foo <= baz; // devuelve verdadero (true)
Código condicional
A veces se desea ejecutar un bloque de código bajo ciertas condiciones. Las estructuras de control de flujo — a través de la utilización de las declaraciones if y else permiten hacerlo.
Control del flujo
var foo = true;
var bar = false;
if (bar) {
// este código nunca se ejecutará
console.log('hello!');
}
if (bar) {
// este código no se ejecutará
} else {
if (foo) {
// este código se ejecutará
} else {
// este código se ejecutará si foo y bar son falsos (false)
}
}
##### Elementos verdaderos y falsos #####
Para controlar el flujo adecuadamente, es importante entender qué tipos de valores son "verdaderos" y cuales "falsos". A veces, algunos valores pueden parecer una cosa pero al final terminan siendo otra.
Valores que devuelven verdadero (true)
'0'; // una cadena de texto cuyo valor sea 0
'any string'; // cualquier cadena
[]; // un array vacío
{}; // un objeto vacío
1; // cualquier número distinto a cero
Valores que devuelven falso (false)
0;
''; // una cadena vacía
NaN; // la variable JavaScript "not-a-number" (No es un número)
null; // un valor nulo
undefined; // tenga cuidado -- indefinido (undefined) puede ser redefinido
Variables condicionales utilizando el operador ternario
A veces se desea establecer el valor de una variable dependiendo de cierta condición. Para hacerlo se puede utilizar una declaración if/else, sin embargo en muchos casos es más conveniente utilizar el operador ternario. [Definición: El operador ternario evalúa una condición; si la condición es verdadera, devuelve cierto valor, caso contrario devuelve un valor diferente.]
##### El operador ternario #####
// establecer a foo igual a 1 si bar es verdadero;
// caso contrario, establecer a foo igual a 0
var foo = bar ? 1 : 0;
El operador ternario puede ser utilizado sin devolver un valor a la variable, sin embargo este uso generalmente es desaprobado.
Declaración switch
En lugar de utilizar una serie de declaraciones if/else/else if/else, a veces puede ser útil la utilización de la declaración switch. [Definición: La declaración Switch evalúa el valor de una variable o expresión, y ejecuta diferentes bloques de código dependiendo de ese valor.]
Una declaración switch
switch (foo) {
case 'bar':
alert('el valor es bar');
break;
case 'baz':
alert('el valor es baz');
break;
default:
alert('de forma predeterminada se ejecutará este código');
break;
}
Las declaraciones switch son poco utilizadas en JavaScript, debido a que el mismo comportamiento es posible obtenerlo creando un
objeto, el cual posee más potencial ya que es posible reutilizarlo, usarlo para realizar pruebas, etc. Por ejemplo:
var stuffToDo = {
'bar' : function() {
alert('el valor es bar');
},
'baz' : function() {
alert('el valor es baz');
},
'default' : function() {
alert('de forma predeterminada se ejecutará este código');
}
};
if (stuffToDo[foo]) {
stuffToDo[foo]();
} else {
stuffToDo['default']();
}
##################
##### Bucles #####
##################
Los bucles (en inglés loops) permiten ejecutar un bloque de código un determinado número de veces.
// muestra en la consola 'intento 0', 'intento 1', ..., 'intento 4'
for (var i=0; i<5; i++) {
console.log('intento ' + i);
}
Note que en el ejemplo se utiliza la palabra var antes de la variable i, esto hace que dicha variable quede
dentro del "alcance" (en inglés *scope) del bucle. Más adelante en este capítulo se examinará en profundidad
el concepto dealcance.*
##### Bucles utilizando for #####
Un bucle utilizando for se compone de cuatro estados y posee la siguiente estructura:
for ([expresiónInicial]; [condición]; [incrementoDeLaExpresión])
[cuerpo]
El estado expresiónInicial es ejecutado una sola vez, antes que el bucle comience. Éste otorga la oportunidad de preparar o declarar variables.
El estado condición es ejecutado antes de cada repetición, y retorna un valor que decide si el bucle debe continuar ejecutándose o no. Si el estado condicional evalúa un valor falso el bucle se detiene.
El estado incrementoDeLaExpresión es ejecutado al final de cada repetición y otorga la oportunidad de cambiar el estado de importantes variables. Por lo general, este estado implica la incrementación o decrementación de un contador.
El cuerpo es el código a ejecutar en cada repetición del bucle.
Un típico bucle utilizando for
for (var i = 0, limit = 100; i < limit; i++) {
// Este bloque de código será ejecutado 100 veces
console.log('Currently at ' + i);
// Nota: el último registro que se mostrará
// en la consola será "Actualmente en 99"
}
##### Bucles utilizando while #####
Un bucle utilizando while es similar a una declaración condicional if, excepto que el cuerpo va a continuar ejecutándose hasta que la condición a evaluar sea falsa.
while ([condición]) [cuerpo]
Un típico bucle utilizando while
var i = 0;
while (i < 100) {
// Este bloque de código se ejecutará 100 veces
console.log('Actualmente en ' + i);
i++; // incrementa la variable i
}
Puede notar que en el ejemplo se incrementa el contador dentro del cuerpo del bucle, pero también es
posible combinar la condición y la incrementación, como se muestra a continuación:
Bucle utilizando while con la combinación de la condición y la incrementación
var i = -1;
while (++i < 100) {
// Este bloque de código se ejecutará 100 veces
console.log('Actualmente en ' + i);
}
Se comienza en -1 y luego se utiliza la incrementación previa (++i).
##### Bucles utilizando do-while #####
Este bucle es exactamente igual que el bucle utilizando while excepto que el cuerpo es ejecutado al menos una vez antes que la condición sea evaluada.
do [cuerpo] while ([condición])
Un bucle utilizando do-while
do {
// Incluso cuando la condición sea falsa
// el cuerpo del bucle se ejecutará al menos una vez.
alert('Hello');
} while (false);
Este tipo de bucles son bastantes atípicos ya que en pocas ocasiones de necesita un bucle que se ejecute al menos una vez. De cualquier forma debe estar al tanto de ellos.
break y continue
Usualmente, el fin de la ejecución de un bucle resultará cuando la condición no siga evaluando un valor verdadero, sin embargo también es posible parar un bucle utilizando la declaración break dentro del cuerpo.
Detener un bucle con break
for (var i = 0; i < 10; i++) {
if (something) {
break;
}
}
También puede suceder que quiera continuar con el bucle sin tener que ejecutar más sentencias del cuerpo del mismo bucle. Esto puede realizarse utilizando la declaración continue.
Saltar a la siguiente iteración de un bucle
for (var i = 0; i < 10; i++) {
if (something) {
continue;
}
// La siguiente declaración será ejecutada
// si la condición 'something' no se cumple
console.log('Hello');
}
#############################################
##### Acceder a elementos del árbol DOM #####
#############################################
Seleccionar un nodo de elemento individual
getElementById(): utiliza el valor del atributo id de un elemento.
querySelector(): Utiliza un selector CSS, y regresa el primer elemento coincidente.
Selecciona un multiples elementos (lista de nodos)
getElementsByClassName(): Selecciona todos los elementos que tienen un valor especifico por su atributo de clase CSS.
getElementsByTagName(): Selecciona todos los elementos que tengan un nombre de etiqueta específica.
querySelectorAll(): Usa un selector CSS para seleccionar todos los elementos que hagan match.
##################
##### Arrays #####
##################
Los arrays (en inglés arrays) son listas de valores con índice-cero (en inglés zero-index), es decir, que
el primer elemento del array está en el índice 0. éstos son una forma práctica de almacenar un conjunto de
datos relacionados (como cadenas de caracteres aunque en realidad, un array puede incluir múltiples tipos
de datos, incluso otros arrays.
Un array simple
var myArray = [ 'hello', 'world' ];
Acceder a los ítems del array a través de su índice
var myArray = [ 'hello', 'world', 'foo', 'bar' ];
console.log(myArray[3]); // muestra en la consola 'bar'
Obtener la cantidad de ítems del array
var myArray = [ 'hello', 'world' ];
console.log(myArray.length); // muestra en la consola 2
Cambiar el valor de un ítem de un array
var myArray = [ 'hello', 'world' ];
myArray[1] = 'changed';
Como se muestra en el ejemplo Cambiar el valor de un ítem de un array es posible cambiar el valor de un ítem de un array, sin embargo, por lo general, no es aconsejable.
Añadir elementos a un array
var myArray = [ 'hello', 'world' ];
myArray.push('new');
Trabajar con arrays
var myArray = [ 'h', 'e', 'l', 'l', 'o' ];
var myString = myArray.join(''); // 'hello'
var mySplit = myString.split(''); // [ 'h', 'e', 'l', 'l', 'o' ]
###################
##### Objetos #####
###################
Los objetos son elementos que pueden contener cero o más conjuntos de pares de nombres claves y valores asociados a dicho objeto. Los nombres claves pueden ser cualquier palabra o número válido. El valor puede ser cualquier tipo de valor: un número, una cadena, un array, una función, incluso otro objeto.
[Definición: Cuando uno de los valores de un objeto es una función, ésta es nombrada como un método del objeto.] De lo contrario, se los llama propiedades.
Curiosamente, en JavaScript, casi todo es un objeto — arrays, funciones, números, incluso cadenas — y todos poseen propiedades y métodos.
Creación de un "objeto literal"
var myObject = {
sayHello : function() {
console.log('hello');
},
myName : 'Rebecca'
};
// se llama al método sayHello, el cual muestra en la consola 'hello'
myObject.sayHello();
// se llama a la propiedad myName, la cual muestra en la consola 'Rebecca'
console.log(myObject.myName);
Nota:
Notar que cuando se crean objetos literales, el nombre de la propiedad puede ser cualquier identificador JavaScript, una cadena de caracteres (encerrada entre comillas) o un número:
var myObject = {
validIdentifier: 123,
'some string': 456,
99999: 789
};
#####################
##### Funciones #####
#####################
Las funciones contienen bloques de código que se ejecutaran repetidamente. A las mismas se le pueden
pasar argumentos, y opcionalmente la función puede devolver un valor.
Las funciones pueden ser creadas de varias formas:
Declaración de una función
function foo() { /* hacer algo */ }
Declaración de una función nombrada
var foo = function() { /* hacer algo */ }
Es preferible el método de función nombrada debido a algunas profundas razones técnicas. Igualmente, es probable encontrar a los dos métodos cuando se revise código JavaScript.
Utilización de funciones
Una función simple
var greet = function(person, greeting) {
var text = greeting + ', ' + person;
console.log(text);
};
greet('Rebecca', 'Hello'); // muestra en la consola 'Hello, Rebecca'
Una función que devuelve un valor
var greet = function(person, greeting) {
var text = greeting + ', ' + person;
return text;
};
console.log(greet('Rebecca','hello'));
Una función que devuelve otra función
// la función devuelve 'Hello, Rebecca',
// la cual se muestra en la consola
var greet = function(person, greeting) {
var text = greeting + ', ' + person;
return function() { console.log(text); };
};
var greeting = greet('Rebecca', 'Hello');
greeting(); // se muestra en la consola 'Hello, Rebecca'
Funciones anónimas autoejecutables
Un patrón común en JavaScript son las funciones anónimas autoejecutables. Este patrón consiste en crear una expresión de función e inmediatamente ejecutarla. El mismo es muy útil para casos en que no se desea intervenir espacios de nombres globales, debido a que ninguna variable declarada dentro de la función es visible desde afuera.
Función anónima autoejecutable
(function(){
var foo = 'Hello world';
})();
console.log(foo); // indefinido (undefined)
Funciones como argumentos
En JavaScript, las funciones son ciudadanos de primera clase — pueden ser asignadas a variables o pasadas a otras funciones como argumentos. En jQuery, pasar funciones como argumentos es una práctica muy común.
Pasar una función anónima como un argumento
var myFn = function(fn) {
var result = fn();
console.log(result);
};
myFn(function() { return 'hello world'; }); // muestra en la consola 'hello world'
Pasar una función nombrada como un argumento
var myFn = function(fn) {
var result = fn();
console.log(result);
};
var myOtherFn = function() {
return 'hello world';
};
myFn(myOtherFn); // muestra en la consola 'hello world'
</script>
-------------------------------------
<!-- Declaracion de variables, asignacion y reasignacion de valor -->
<html>
<meta charset="utf-8"/>
<body>
<script type="text/javascript">
var nombre; //declaramos la variable
nombre="David"; //asignamos el valor Morris a la variable
document.write(nombre); //imprimimos la variable
document.write("<br />");
nombre="Rafael"; //asignamos otro valor a la variable
document.write(nombre); //imprimimos la variable
</script>
</body>
</html>
-------------------------------------
<!-- Escribir html en un documento a traves de js -->
<html>
<body>
<script type="text/javascript">
document.write("<h1>Encabezado</h1>");
document.write("<p>Parrafo 1</p>");
document.write("<p>Parrafo 2</p>");
document.write("<h3>Encabezado</h3>");
</script>
<script type="text/javascript">
document.write("hola mundo");
</script>
</body>
</html>
-------------------------------------
<!-- Escribir un enlace o link al documento pidiendo la dirección al usuario -->
<html>
<head>
<title>XXX</title>
<script src="jquery-1.12.4.min.js" type="text/javascript"></script>
<meta charset="UTF-8">
</head>
<script type="text/javascript">
$("document").ready(function () {
$("#boton1").click(function() {
//link=prompt("");
//document.write("<a href='http://www.as.com'>"+link+"</a>");
link=prompt("Por favor escriba el enlace","enlace");
document.write("<a href="+link+">Aquí</a>");
});
});
</script>
<body>
<button id="boton1">Enlace</button>
<p />
<div id="x"></div>
</body>
</html>
-------------------------------------
<!-- Mostrar alerta en la pagina, se muestra al cargar la pagina -->
<script type="text/javascript">
alert("Ejemplo de alerta con JavaScript");
</script>
-------------------------------------
<!-- Activar una funcion mostrando una alerta -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
function miFuncion() {
alert("Activaste la funcion miFuncion()");
}
</script>
</head>
<body>
<form>
<input type="button" onclick="miFuncion()" value="Activar Función">
</form>
<p>Presiona el botón y saldra una alerta contenida dentro de una función.</p>
</body>
</html>
-------------------------------------
<!-- Llamada de dos funciones diferentes -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
function miFuncion1() {
alert("Activaste la funcion 1");
}
function miFuncion2() {
alert("Activaste la funcion 2");
}
</script>
</head>
<body>
<form>
<input type="button" onclick="miFuncion1()" value="Activar Función 1">
<input type="button" onclick="miFuncion2()" value="Activar Función 2">
</form>
</body>
</html>
-------------------------------------
<!-- Activar 2 o mas funciones con un boton -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
function Funcion1() {
alert("Activaste la funcion 1");
}
function Funcion2() {
alert("Activaste la funcion Funcion 2");
}
function Funcion3() {
alert("Activaste la funcion Funcion 3");
}
</script>
</head>
<body>
<form>
<input type="button" onclick="Funcion1(),Funcion2(),Funcion3()" value="Activar Función">
</form>
<p>Presiona el botón y saldra una alerta contenida dentro de una función.</p>
</body>
</html>
-------------------------------------
<!-- Pasar parametros a una funcion -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
function sumar(a,b) {
var suma;
suma = a + b;
return suma;
}
function restar(a,b) {
var resta;
resta = a - b;
return resta;
}
//var operacion;
operacion = sumar(6,4); // Variable que le asignamos la llamada de la funcion y parametros
alert(operacion); // Mostramos el resultado en una alerta
operacion = restar(20,18);
alert(operacion);
</script>
</head>
<body>
</body>
</html>
-------------------------------------
<!-- Recoger un dato por teclado y visualizarlo -->
<!doctype html>
<html>
<head>
<title></title>
</head>
<body>
<script type="text/javascript">
//var nom;
nom=prompt("Por favor escriba su nombre","nombre");
alert("Mucho gusto "+nom);
</script>
</body>
</html>
-------------------------------------
<!-- Pedir datos y guardarlo en una variable -->
<html>
<head>
<title>XXX</title>
<meta charset="UTF-8">
</head>
<script type = "text/javascript" language = "javascript">
var nombre=prompt("Nombre de Usuario:");
alert(nombre);
</script>
<body>
</body>
</html>
-------------------------------------
<!-- Recoger un dato por teclado y escribirlo en el documento -->
<!doctype html>
<html>
<head>
<title></title>
</head>
<body>
<script type="text/javascript">
nom=prompt("Por favor escriba su nombre","nombre");
document.write(nom);
</script>
</body>
</html>
-------------------------------------
<!-- ciclo while con js -->
<html>
<meta charset="utf-8">
<body>
<script type="text/javascript">
var i= 0;
while (i<=5){
document.write("El número es " + i + "<br />");
i=i+1;
}
</script>
</body>
</html>
-------------------------------------
<!-- if en JS -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
if (1 < 2) {
alert("Verdadero");
}
else {
alert("Falso");
}
</script>
</head>
<body>
</body>
</html>
-------------------------------------
<!-- Ejempo de if pidiendo un dato -->
<html>
<meta charset="utf-8"/>
<body>
<script type="text/javascript">
confirm("Estoy listo para continuar.");
var edad;
edad = prompt("¡Cuántos años tienes?");
if (edad <= 13) {
//console.log("Juega! con cuidado...");
alert("Juega! con cuidado...");
}
else {
//console.log("Juega!!!");
alert("Juega!!!");
}
</script>
</body>
</html>
-------------------------------------
<!-- Ejempo de if -->
<html>
<meta charset="utf-8"/>
<body>
<script type="text/javascript">
var nombre; //declaramos la variable
var a = 3
function miFuncion(e) {
//alert("Activaste la funcion miFuncion()");
//if (1 > 2) {
if (a > 2) {
alert("Verdadero");
nombre="David";
document.write(nombre);
}
else {
alert("Falso");
e.preventDefault();
}
}
</script>
<input type="button" onclick="miFuncion()" value="Activar Función 1">
</body>
</html>
-------------------------------------
<!-- Ejempo de if anidados -->
<html>
<head>
<meta charset="utf-8"/>
<script type="text/javascript">
idioma=prompt("Por favor escriba su idioma");
var a="castellano", b="ingles", c="frances", d="alemán";
if (idioma === a) {
alert("Castellano!")
alert("Que bueno! "+idioma);
}
else
{
if (idioma === b) {
alert("Ingles!");
alert("Que bueno! "+idioma);
}
else
{
if (idioma === c) {
alert("Frances!")
alert("Que bueno! "+idioma);
}
else
{
if (idioma === d){
alert("Alemán")
alert("Que bueno! "+idioma);
}
else
{
//error('idioma no presente');
alert("idioma no presente")
alert("no conozco! el "+idioma);
}
}
}
}
</script>
</head>
<body>
</body>
</html>
-------------------------------------
<!-- Ejempo de if y else if -->
<html>
<meta charset="utf-8"/>
<body>
<script type="text/javascript">
respuestaUsuario = prompt("¿Guardar los datos? s/n");
if (respuestaUsuario === "s") {
alert("Datos guardados!");
}
else if (respuestaUsuario === "n") {
alert("Datos no guardados!")
}
else {
alert("Respuesta no valida!")
}
</script>
</body>
</html>
-------------------------------------
<!-- switch en JS -->
<!DOCTYPE html>
<html>
<body>
<script>
idioma=prompt("Por favor escriba su idioma");
switch (idioma) {
case 'castellano' :
alert("1")
break;
case 'ingles' :
alert("2")
break;
case 'frances' :
alert("3")
break;
case 'alemán' :
alert("4")
break;
default :
error ('Idioma no presente');
}
</script>
</body>
</html>
-------------------------------------
<!DOCTYPE html>