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;
}
// 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;
}
}
// 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
]);
