Documentación sobre JavaScript
// Utilizando la función println() se imprimirá el texto y se creará un salto de línea
// Ejemplo de uso de println()
println("Hola");
println("mundo");
// Resultado:
// Hola
// mundo.
// El uso de la sentencia print() NO crea un salto de línea
// Ejemplo de uso de print()
print("Hola mundo. ");
print("¿Cómo estás?");
// Resultado:
// Hola mundo. ¿Cómo estás?
// También puedes imprimir en la consola utilizando console.log() (incluye salto de línea)
// Ejemplo:
console.log("¡Hola mundo!");
// Declarar una variable
var myVarName;
// Inicializar una variable
var myVarName = 5;
// Asignar a una variable existente
myVarName = 10;
// Imprimir una variable
println(myVarName);
println("El valor es: " + myValue);
// Las variables también se pueden declarar e inicializar utilizando la palabra clave "let
let myVarName;
let myVarName = 5;
// Si una variable no va a cambiar de valor, es mejor utilizar la palabra clave 'const'.
/*
* Las variables definidas con const no se pueden volver a declarar.
* Las variables definidas con const no se pueden reasignar.
* A las variables definidas con const se les debe asignar un valor cuando se declaran
*/
// Ejemplo:
const PI = 3.141592653589793;
PI = 5; // Esto dará un error
// Leer una cadena
// Las cadenas son una serie de caracteres - ej: Hola Mundo
var str = readLine(prompt);
// Leer un número entero
// Los enteros son números sin punto decimal - ej: 3
var num = readInt(prompt);
// Leer un flotante
// Los flotantes son números con punto decimal - ej: 3,14
var cost = readFloat(prompt);
// Leer un booleano
// Los booleanos son verdadero/falso
var bool = readBoolean(prompt);
// Debes sustituir la palabra prompt por
// la pregunta que quieras hacer. Por ejemplo
var name = readLine("¿Cuál es tu nombre? ");
var age = readInt("¿Cuál es tu edad? ");
var finishedWork = readBoolean("¿Has terminado tu trabajo? ");
/* Además de los métodos de entrada bloqueantes que reciben la entrada mediante
popup, hay métodos de entrada asíncronos adicionales. readLineAsync,
readIntAsync, readFloatAsync y readBooleanAsync son funciones no bloqueantes
que se pueden utilizar en combinación con la palabra clave `await
recibir información de forma asíncrona.
*/
let name = await readLineAsync("¿Cómo te llamas? ");
console.log("Encantado de conocerte, " + name);
Para saber más sobre las entradas del usuario asíncronas, consulta
este tutorial.
// Operadores:
+ Suma
- Sustracción
* Multiplicación
/ División
** Exponenciación
% Modulus (Resto)
() Paréntesis (Para el orden de las operaciones)
// Ejemplos
var z = x + y
var w = x * y;
// Incrementa (añade uno)
x++
// Disminuye (resta uno)
x--
// Atajos
x = x + y; x += y;
x = x - y; x -= y;
x = x * y; x *= y;
x = x / y; x /= y;
// Exponenciación
var squared = 5 ** 2;
println(squared); // imprime 25
// Modulus
var z = 10 % 4 // 2 * 4 = 8; 10 - 8 = 2
println(z) // imprime 2
// Valor absoluto
var abs = Math.abs(x);
// Raíz cuadrada
var sqrt = Math.sqrt(x);
// Redondeo
// Math.round() se puede utilizar para redondear números
var PI = 3.14
var roundedPi = Math.round(pi);
println(roundedPi); // imprime: 3
var goldenRatio = 1.618
var roundedGoldenRatio = Math.round(goldenRatio);
println(roundedGoldenRatio); // se imprime: 2
// División por el suelo
// Math.floor() se puede utilizar para realizar la división por el suelo
// división por el suelo. Con la división por el suelo, sólo se devuelve
// la parte entera del cociente.
// Por ejemplo, 5/2 es 2.5, pero con la división por el suelo,
// el resultado es 2 y se descarta el 0.5.
var result = Math.floor(5/2);
println(result); // imprime: 2
// Geometría
// Ten en cuenta que la entrada está en radianes, no en grados
Math.sin(radians); // Devuelve un valor entre -1 y 1
Math.cos(radians); // Devuelve un valor entre -1 y 1
Math.tan(radians); // Devuelve el valor
Números aleatorios
// Número entero aleatorio entre bajo y alto
Randomizer.nextInt(low, high);
Randomizer.nextBoolean();
Randomizer.nextFloat(low, high);
Randomizer.nextColor();
var roll = Randomizer.nextInt(1,6);
var color = Randomizer.nextColor();
// str.length
// devuelve la longitud de una cadena
// Ejemplo
var str = "hello";
var len = str.length; // igual a 4
// str.indexOf(búsqueda)
// devuelve el primer índice de la búsqueda
// o -1 si no se encuentra. Distingue entre mayúsculas y minúsculas.
//Ejemplos
var str = "hello";
var pos1 = str.indexOf("l"); // devuelve 2
var pos2 = str.indexOf("H"); // devuelve -1
// str.substring(start);
// devuelve una subcadena que incluye
// carácter de inicio hasta el final de la
// cadena
//Ejemplos
var str = "hello";
var sub1 = str.substring(1); // equivale a "ello"
var sub2 = str.substring(3); // igual a "lo"
// str.substring(inicio, fin);
// devuelve una subcadena que incluye el carácter
// el carácter del principio, pero sin incluir
// el carácter del final
//Ejemplos
var str = "hello";
var sub1 = str.substring(0,2); // equivale a "he"
var sub2 = str.substring(1,4); // equivale a "ell"
// Las funciones pueden tomar valores, llamados parámetros.
// La siguiente función recibe un parámetro llamado
// 'entrada' y lo imprime.
function printText(input) {
println(input);
}
// Las funciones también pueden devolver un valor.
// La siguiente función toma un valor,
// le suma dos y lo devuelve.
function addTwo(number) {
return number + 2;
}
Echa un vistazo a nuestro
¡documentación completa de la Biblioteca Gráfica CodeHS!
// devuelve la anchura del lienzo
getWidth();
// devuelve la altura del lienzo
getHeight();
// Ejemplo devuelve la coordenada y del
// centro del lienzo
var CENTER_Y = getHeight() / 2;
// El ejemplo devuelve la coordenada x del
// centro del lienzo
var CENTER_X = getWidth() / 2;
// Elimina todos los objetos del lienzo
removeAll();
// Para hacer un círculo
var circle = new Circle(radius);
// Para establecer la posición del centro del círculo
circle.setPosition(x, y);
// Ejemplo, círculo rojo de 50px de radio con centro en (100, 200)
var circle = new Circle(50);
circle.setPosition(100, 200);
circle.setColor(Color.red);
// Obtener el radio
circle.getRadius(); // devuelve 50
var curRadius = circle.getRadius(); // guardar en variable
// Cambia el radio
circle.setRadius(100);
// Obtener la posición del centro del círculo
var x = circle.getX(); // x es 100
var y = circle.getY(); // y es 200
// Cambia la posición del círculo
var x = getWidth() / 2;
var y = getHeight() / 2;
circle.setPosition(x, y); // el centro del círculo está en el centro de la pantalla
// Añadir y quitar de la pantalla
add(circle); // Añadir a la pantalla
remove(circle); // Eliminar de la pantalla
// Mueve el círculo dx horizontalmente y dy verticalmente
circle.move(dx, dy);
// Para hacer un rectángulo
var rect = new Rectangle(width, height);
// Para establecer la posición de la esquina superior izquierda del rectángulo
rect.setPosition(x, y);
// Ejemplo, rectángulo azul de 200x50 con la esquina superior izquierda en (100, 200)
var rect = new Rectangle(200, 50);
rect.setPosition(100, 200);
rect.setColor(Color.blue);
// Obtén la posición de la esquina superior izquierda del rectángulo
var x = rect.getX(); // x es 100
var y = rect.getY(); // y es 200
// Cambia la ubicación del rectángulo
var x = getWidth() / 2;
var y = getHeight() / 2;
rect.setPosition(x, y) // la esquina superior izquierda está en el centro de la pantalla
// Añadir y quitar de la pantalla
add(rect); // Añadir rectángulo
remove(rect); // Eliminar rectángulo
// Mueve el rect dx horizontalmente y dy verticalmente
rect.move(dx, dy);
// Para hacer un arco
var myArc = new Arc(radius, start, end, unit);
// Más concretamente, los parámetros son:
// 1. radio del arco
// 2. ángulo inicial del arco
// 3. ángulo final del arco
// 4. unidad del ángulo (0 para grados, 1 para radianes)
// Para establecer la posición del centro del arco
myArc.setPosition(x, y);
// Ejemplo, un arco de 90 grados con
// radio de 50 y color rojo:
var myArc = new Arc(50, 0, 90, 0);
myArc.setPosition(100, 200);
myArc.setColor(Color.red);
// Obtén la posición del centro del arco
var x = myArc.getX(); // x es 100
var y = myArc.getY(); // y es 200
// Cambia la posición del centro del arco
var x = getWidth() / 2;
var y = getHeight() / 2;
myArc.setPosition(x, y); // el centro del arco está en el centro de la pantalla
// Añadir y quitar de la pantalla
add(myArc); // Añadir arco
remove(myArc); // Eliminar arco
// Dibujar una línea desde (x1, y1) hasta (x2, y2)
var line = new Line(x1, y1, x2, y2);
// Establece el color de la línea en verde
line.setColor(Color.green);
// Establece la anchura de la línea en 10 píxeles
line.setLineWidth(10);
// Añadir y quitar de la pantalla
add(line);
remove(line);
// Mueve la línea dx horizontalmente y dy verticalmente
line.move(dx, dy);
// Cambia el punto inicial de la línea a (x1, y1)
line.setPosition(x1, y1);
// Cambia el punto final de la línea a (x2, y2)
line.setEndpoint(x2, y2);
//Obtén el punto inicial de la línea
var x = line.getX(); // x tiene el mismo valor que x1
var y = line.getY(); // y tiene el mismo valor que y1
// Para hacer un Óvalo
var oval = new Oval(width, height);
// Para establecer la posición del centro del óvalo
oval.setPosition(x, y);
// Ejemplo, óvalo azul de 200x50 con centro en (100, 200)
var oval = new Oval(200, 50);
oval.setPosition(100, 200);
oval.setColor(Color.blue);
// Obtén la posición del centro del óvalo
var x = oval.getX(); // x es 100
var y = oval.getY(); // y es 200
// Cambia la ubicación del óvalo
var x = getWidth() / 2;
var y = getHeight() / 2;
oval.setPosition(x, y) // El centro del óvalo está en el centro de la pantalla
// Añadir y quitar de la pantalla
add(oval); // Añadir óvalo
remove(oval); // Eliminar óvalo
// Mueve el óvalo dx horizontalmente y dy verticalmente
oval.move(dx, dy);
// Para hacer un polígono
var polygon = new Polygon();
// Para añadir puntos al polígono
polygon.addPoint(x, y);
// Ejemplo, polígono verde de 4 lados
// NOTA: El orden en que añades los puntos determina cómo se dibuja el polígono
var polygon = new Polygon();
polygon.addPoint(20, 20);
polygon.addPoint(10, 50);
polygon.addPoint(100, 80);
polygon.addPoint(60, 10);
polygon.setColor(Color.green);
// Comprueba si el polígono contiene un punto
polygon.containsPoint(x, y); // devuelve booleano
// Añadir y quitar de la pantalla
add(polygon); // Añadir polígono
remove(polygon); // Eliminar polígono
// Mueve el polígono dx horizontalmente y dy verticalmente
polygon.move(dx, dy);
// Para crear un objeto de texto gráfico
var txt = new Text(label, font);
// Para establecer la posición de la esquina inferior izquierda del texto
txt.setPosition(x, y);
// Ejemplo
var txt = new Text("¡Hola, mundo!", "30pt Arial");
txt.setPosition(100, 200);
txt.setColor(Color.blue);
// Cambia lo que dice el texto
txt.setText("¡Adiós!");
// Obtener la ubicación de la esquina inferior izquierda del texto
var x = txt.getX(); // x es 100
var y = txt.getY(); // y es 200
// Cambia la ubicación del texto
var x = getWidth() / 2;
var y = getHeight() / 2;
txt.setPosition(x, y) // la esquina inferior izquierda del texto está
// en el centro de la pantalla
// Añadir y quitar de la pantalla
add(txt); // Añadir texto
remove(txt); // Eliminar texto
// Mueve el texto dx horizontalmente y dy verticalmente
txt.move(dx, dy);
// Se puede añadir una imagen web al lienzo de gráficos
// como una WebImage. Las WebImages se crean, se dimensionan
// y se posicionan como otros objetos gráficos.
// Para crear una nueva WebImage, utiliza una URL que enlace
// directamente a la imagen en Internet.
// Utiliza la pestaña Subir del editor para subir y crear
// una URL válida para tu propia imagen.
var copter = new WebImage("https://upload.wikimedia.org/" +
"wikipedia/commons/4/41/" +
"Bell_206L3_%28D-HASA%29.jpg");
copter.setSize(300, 150);
copter.setPosition(getWidth()/4, getHeight()/2);
add(copter); // Añadir el copter a la pantalla
remove(copter); // Quitar el copter de la pantalla
// Ten en cuenta que la URL de la imagen debe ser directamente
// al propio archivo de imagen. Por lo general, debe terminar con
// algo como .png, .jpg u otro tipo de archivo de imagen.
- https://static.codehs.com/img/library/characters/penguin.png
- https://static.codehs.com/img/library/characters/monkey.jpg
- https://static.codehs.com/img/library/characters/leopard.jpg
- https://static.codehs.com/img/library/characters/chameleon.jpg
- https://static.codehs.com/img/library/characters/lizard.jpg
- https://static.codehs.com/img/library/characters/butterfly.jpg
- https://static.codehs.com/img/library/objects/icicle.png
- https://static.codehs.com/img/library/objects/helicopter.png
- https://static.codehs.com/img/library/objects/asteroid.png
- https://static.codehs.com/img/library/objects/soccerBall.png
- https://static.codehs.com/img/library/landscapes/flowers.jpg
Puedes visitar la página
W3Schools CSS Colors para obtener una lista de colores.
// Puedes utilizar el método setColor() para dar un color a tus objetos.
// así:
obj.setColor(color);
// Puedes pasar a setColor() cualquier nombre de color css como cadena.
// Consulta el enlace anterior para ver una lista de posibles nombres de colores
// Por ejemplo, así es como establecemos que un círculo sea verde azulado:
circle.setColor("teal");
// También puedes crear tu propio color dándole un componente rojo, verde
// y azul como
var color = new Color(r, g, b);
// Los valores están entre 0-255 para cada componente. Después de crear
// un nuevo color, puedes utilizarlo para establecer el color de un objeto.
// Por ejemplo, para que un rectángulo existente llamado
// rect para que sea marrón:
var brown = new Color(139, 69, 19);
rect.setColor(brown);
// Otra forma de establecer el color de un objeto es utilizar una
// cadena con el valor hexadecimal del color con setColor.
// Por ejemplo, para establecer el color rosa de un objeto rect:
rect.setColor("#FF66CC");
// También hay muchas constantes de color. Puedes establecer un objeto
// color como
obj.setColor(Color.RED);
// Lista de colores disponibles:
Color.RED
Color.GREEN
Color.BLUE
Color.YELLOW
Color.CYAN
Color.ORANGE
Color.WHITE
Color.BLACK
Color.GRAY
Color.PURPLE
// Otras funciones divertidas
// Devuelve un color aleatorio
var color = Color.randomRed();
var color = Color.randomGreen();
var color = Color.randomBlue();
// Obtener un color aleatorio del aleatorizador
var color = Randomizer.nextColor();
/**
* Se pueden rotar los siguientes objetos gráficos:
* - Rectángulo
* - Arco
* - Línea
* - Óvalo
* - Texto
* - Imagen Web
*/
// Establece la rotación del rectángulo con estos parámetros:
// 1. ángulo a rotar
// 2. unidad del ángulo (0 para grados, 1 para radianes)
// Por defecto será grados.
// Establece la rotación del rectángulo en 45 grados
rect.setRotation(45, 0);
rect.setRotation(45); // Hace lo mismo.
// Establece la rotación del rectángulo en radianes Math.PI/2
rect.setRotation(Math.PI / 2, 1);
// Añade la rotación con estos parámetros:
// 1. ángulo a rotar
// 2. unidad del ángulo (0 para grados, 1 para radianes)
// Por defecto será grados.
// Rota el rectángulo 45 grados
rect.rotate(45, 0);
rect.rotate(45); // Hace lo mismo.
// Gira el rectángulo 2 radianes Math.PI
rect.rotate(Math.PI / 2, 1);
// Obtener el tipo del objeto:
var type = obj.getType();
// podría devolver: 'Círculo', 'Rectángulo', 'Texto', 'Línea', o 'ImagenWeb'
/* Puedes cambiar el orden de tus gráficos
* utilizando la propiedad capa. Si estableces la capa
* a 0 envía el gráfico al fondo del lienzo.
* El gráfico con un número de capa más alto se
* dibujado encima de los objetos con un número de capa inferior.
* La capa por defecto de un gráfico es 1.
*/
obj.layer = 1; // adelanta el gráfico a 1 capa
obj2.layer = 5; // se dibujará encima de las capas 0 - 4
/*
* El método de depuración se puede utilizar para ver dónde
* se encuentra el punto de anclaje de un objeto
* Por defecto, el punto de anclaje de un círculo está
* en su centro y el punto de anclaje de un rectángulo
* de un rectángulo se encuentra en su esquina superior izquierda.
* El método de depuración evalúa un booleano y puede
* establecer el valor "true" para cualquier objeto.
*/
// Por defecto, el método de depuración está en "false
// Así es como puedes activarlo para un objeto círculo:
var circle = new Circle(50);
circle.debug = true;
/*
* También puedes cambiar el punto de anclaje de un objeto
* utilizando setAnchor()
* Un ancla de 0, 0 hará que la forma se
dibuje con su posición en la esquina superior izquierda
* Un ancla de 0,5, 0,5 hará que la forma
se dibuje con su posición en el centro
* Un ancla de 1, 1 hará que la forma se
dibuje con su posición en la esquina inferior derecha
*/
// Así es como puedes cambiar el punto de anclaje de
// un rectángulo para que esté en la esquina inferior derecha:
var rect = new Rectangle(50, 25);
rect.setAnchor({vertical: 1, horizontal: 1});
// Nota: es mejor cambiar el punto de anclaje mientras el modo de depuración está activado
// Un booleano es verdadero o falso
var myBoolean = true;
var anotherBoolean = false;
var result = readBoolean("¿Pregunta? ");
// Operador Not
var x = !y; // x obtiene lo contrario de y
// Operador And
var andExp = x && y;
// Operador or
var orExp = x || y;
// ¡Puedes combinar muchos booleanos!
var boolExp = x && (y || z);
// Los operadores lógicos devuelven booleanos (valores true/false)
x && y // Operador AND -- verdadero si AMBOS x e y son verdaderos
x | y // Operador OR -- verdadero si x O y son verdaderos
! x // Operador NOT -- verdadero si x es false
// Operadores lógicos en declaraciones if
if(x && y){
println("x e y son ambos true");
}
if(x || y){
println("x y/o y son true");
}
if(!x && y){
println("x es false e y es true");
}
// Los operadores de comparación devuelven booleanos (valores true/false)
x == y // ¿es x igual a y?
x != y // x no es igual a y
x > y // x es mayor que y
x >= y // si x es mayor o igual que y
x < y // es x menor que y
x <= y // es x menor o igual que y
// Operadores de comparación en declaraciones if
if(x == y){
println("x e y son iguales");
}
if(x > 5){
println("x es mayor que 5");
}
if(BOOLEAN_EXPRESSION){
// código a ejecutar if true
}
if(BOOLEAN_EXPRESSION){
// código si es true
} else {
// código if false
}
if(x < 0){
println("x es negativo");
}
if(color == "red" || color == "blue" || color == "yellow"){
println("Color primario");
} else {
println("No es un color primario.");
}
// Puedes utilizar else if si tienes varias
// condiciones, pero sólo debe ocurrir una.
if(condition_1){
} else if(condition_2) {
} else if(condition_3) {
} else {
}
// Siempre puedes escribirlos usando anidados
// if/else. Por ejemplo
if(condition_1){
// el código se ejecuta si la condición 1 es true
} else {
if(condition_2){
// si la condición 2 es true
} else {
// y aquí si la condición 2 es false
}
}
var COUNT = 5;
for(var i = 0; i < COUNT; i++){
/* Repite el código entre los corchetes 5 veces,
* ya que la variable COUNT es 5. */
}
// Imprime los números del 0 al 9
for(var i = 0; i < 10; i++){
println(i);
}
while(boolean expression){
/* Repite el código entre paréntesis while
* 'expresión booleana' es true */
}
// Cuenta atrás de 15 a 10
var i = 15
while(i > 9){
println(i);
i--;
}
// Este es un formato de bucle y medio
while(true){
// código
if(condition){
break;
}
}
setTimer(fn, delay); // Crear un temporizador
stopTimer(fn); // Detener un temporizador
// Ejemplo: llamar a moverBola cada 40 milisegundos
function start() {
setTimer(moveBall, 40);
}
function moveBall() {
ball.move(x, y);
}
// Los eventos del ratón se utilizan para crear programas
// que responden a los clics, arrastres // y movimientos del ratón de los usuarios,
// y movimientos.
// Cuando se produce el evento del ratón, la función
// registrada con el evento será llamada. Ten en cuenta
// que omites los paréntesis () cuando
// al pasar el nombre de la función.
// Aquí tienes una lista de eventos de ratón que se pueden utilizar:
mouseMoveMethod(functionToCall); // al mover el ratón
mouseClickMethod(functionToCall); // al hacer clic con el ratón
mouseDragMethod(functionToCall); // al arrastrar el ratón
mouseDownMethod(functionToCall); // al pulsar el botón del ratón
mouseUpMethod(functionToCall); // al soltar el botón del ratón
// Programa de ejemplo que utiliza eventos del ratón
function start() {
// Configura las llamadas de retorno del ratón
mouseMoveMethod(onMouseMove);
mouseClickMethod(addBall);
mouseDragMethod(updateLine);
}
function onMouseMove(e) {
println("El ratón está en (" +
e.getX() + ", " +
e.getY() + ").");
}
function addBall(e) {
var ball = new Circle(20);
ball.setPosition(e.getX(), e.getY());
add(ball);
}
function updateLine(e) {
line.setEndpoint(e.getX(), e.getY());
}
// La función getElementAt(x, y) puede utilizarse para coger
// un objeto, si existe, en las coordenadas
// (x, y). Si no hay ninguno, devuelve null
// Ejemplo
function start() {
mouseClickMethod(turnRed);
}
// Si haces clic en un objeto, vuélvelo rojo.
function turnRed(e) {
var elem = getElementAt(e.getX(), e.getY());
if (elem != null) {
elem.setColor("red");
}
}
function start() {
// Configura las llamadas de retorno del teclado
keyDownMethod(keyDown);
keyUpMethod(keyUp);
}
function keyDown(e) {
if (e.keyCode == Keyboard.LEFT) {
ball.move(-5, 0);
}
if(e.keyCode == Keyboard.letter('K')){
println("Has pulsado K");
}
}
function keyUp(e) {
println("Has pulsado una tecla");
}
// Para añadir un archivo de sonido a un programa, primero crea una variable
// para almacenar el sonido que desees. Asegúrate de utilizar un enlace
// directo al propio archivo de sonido (por ejemplo,
// si es un mp3, el enlace debe terminar en .mp3).
// El enlace debe ser una URL completa a un archivo de sonido que
// esté disponible en Internet.
var mySong = new Audio("enlace_a_archivo_de_sonido.mp3");
// Para reproducir el archivo, utiliza .play()
mySong.play();
// Para pausar un archivo, utiliza .pause()
mySong.pause();
// Para reproducir un archivo en bucle, primero reproduce el archivo,
// y luego pon .loop en true:
mySong.play()
mySong.loop = true;
/*
* ¡Crea tus propias ondas sonoras!
*/
// Construye un nuevo Sonido con una nota y un tipo de onda sonora dados
var sound = new Sound("C4", "square");
var sound2 = new Sound("C1", "sawtooth");
// Establece el tono en un valor de frecuencia o de nota
sound.setFrequency(440); // 440 Hz
sound.setFrequency("C4"); // Nota Do central
sound.setFrequency("A2"); // Nota La grave
sound.setFrequency("A#8"); // Nota La sostenido agudo
/*
* Establece el tipo de oscilador para la onda de sonido. Las opciones son:
*
* Ondas básicas: "square", "sine", "triangle", or "sawtooth"
* Ondas gordas: "fatsquare", "fatsine", "fattriangle", or "fatsawtooth"
* Ondas AM: "amsquare", "amsine", "amtriangle", or "amsawtooth"
* Ondas FM: "fmsquare", "fmsine", "fmtriangle", or "fmsawtooth"
* Ondas especiales: "pwm", or "pulse"
* Sonido de tambor: "drum"
* Sonido de platillos: "metal"
*/
sound.setOscillatorType("sine");
sound.setOscillatorType("square");
// Establece el volumen (en decibelios)
sound.setVolume(2);
/*
* Obtener información sobre el sonido
*/
var currentVolume = sound.getVolume();
var currentNote = sound.getFrequency();
var currentOscillatorType = sound.getOscillatorType();
/*
* Añadir efectos al sonido
* Las opciones son: "distortion", "reverb",
* "tremolo", "vibrato", or "chebyshev"
*/
// Añade un efecto de distorsión al máximo
sound.setEffect("distortion", 1);
// Añade un efecto trémolo a media capacidad
sound.setEffect("tremolo", 0,5);
// Añade un efecto vibrato a capacidad 0
sound.setEffect("vibrato", 0);
/*
* Iniciar y detener el sonido
*/
// Reproduce el sonido continuamente
sound.play();
// Reproduce el sonido durante 3 segundos
sound.playFor(3);
// Deja de reproducir el sonido inmediatamente
sound.stop();
function start() {
mouseClickMethod(turnRed);
}
// Si haces clic en un objeto, vuélvelo rojo.
function turnRed(e) {
var elem = getElementAt(e.getX(), e.getY());
if (elem != null) {
elem.setColor(Color.red);
}
}
// Crear un array vacío
var arr = [];
// Crear un array con valores
var arr = [1, 2, 4];
// Un array puede tener cualquier tipo
var arr = [4, "hola", x];
// Accede a un elemento de un array
var elem = arr[i];
var firstElem = arr[0];
// Establecer un elemento en un array
arr[4] = 9;
// Recorrer un array en bucle
for(var i = 0; i < arr.length; i++){
var cur = arr[i];
// procesa cur
}
// longitud de un array
var length = arr.length;
// Añadir a un array
arr.push(elem);
// Eliminar el último elemento del array
var last = arr.pop();
// Encontrar el índice de un elemento en una lista
var index = arr.indexOf(5);
// Eliminar un elemento de una lista en el índice i
arr.remove(i)
// Literal de objeto
var obj = {
name: "Jeremy"
color: "blue"
};
// Los objetos/mapas tienen una colección de pares clave, valor
// Establece un valor
obj["Jeremy"] = "123-4567";
// Obtener un valor para una clave
var phone = obj["Jeremy"];
// Haz un bucle sobre un objeto
for(var key in obj){
var val = obj[key];
// procesar clave y val
}
// Crea un nuevo conjunto llamado "newSet".
var newSet = new Set();
// Añadir a un conjunto
newSet.add(5);
// ¿Contiene un valor un conjunto?
newSet.contains(5); // devuelve un booleano
// Número de elementos del conjunto
var count = newSet.size; // devuelve un entero
// Crea un nuevo conjunto llamado "conjuntoA
var setA = new Set();
// Añade 2 números al conjunto
setA.add(1);
setA.add(2);
// Crea un nuevo conjunto llamado "conjuntoB".
var setB = new Set();
// Añade 2 números al conjunto
setB.add(2);
setB.add(3);
// Llama a la función intersecar en "conjuntoA" y pásale "conjuntoB", almacena el
// resultante en una nueva variable llamada "conjuntomutuo".
var mutualSet = setA.intersect(setB);
// Crear una cuadrícula llamada "nuevaCuadrícula
var newGrid = new Grid(rows, columns);
// Obtener un valor en una cuadrícula
var elem = newGrid.get(row, col);
// Establecer un valor en una cuadrícula
newGrid.set(row, col, val);
// Obtener dimensiones
var rows = newGrid.numRows();
var cols = newGrid.numCols();
// Es un par de filas y columnas dentro de los límites
newGrid.inBounds(row, col);
// Establece todos los valores de la cuadrícula al valor inicial
newGrid.init(0); // establece todos los valores de la cuadrícula en 0
// Inicializa una cuadrícula a partir de un array
newGrid.initFromArray([
[6, 3, 2], // fila 0
[2, 5, 1], // 1ª fila
[4, 3, 9], // 2ª fila
[1, 5, 1] // 3ª fila
]);
