Secuencias JavaFX

En esta ocasión hablaremos de las secuencias, estas son una adicción a los tipos básicos de JavaFX, el lenguaje nos provee de una estructura llamada secuencias la cual representa una lista ordenada de objetos (Aunque no sean solamente objetos), cada objeto dentro de la secuencia es llamado ítem. Para declarar una secuencia debemos usar [] y dentro introducir cada ítem separado por comas.

Contenido

• Creating Sequences
• Using Predicates
• Accessing Sequence Items
• Inserting Items into a Sequence
• Deleting Items from a Sequence
• Reversing the Items in a Sequence
• Comparing Sequences
• Using Sequences Slices
  

Creating Sequences
Tenemos varias formas de declarar una secuencia por ejemplo podríamos encerrar los ítem entre [] separados por coma.

def weekDays1 = ["Lunes","Martes"];    // Aquí no definimos el tipo de Dato
def weekDays2: String[] = ["Miercoles","Jueves","Viernes"];   // Aquí informamos el tipo de los Items

Una cualidad importante de las secuencias es que pueden ser construidas en base a otras secuencias, para el ejemplo anterior podríamos hacer realizado la siguiente combinación

// Aquí obtendríamos una secuencia con todos los días
def days = [weekDays1, weekDays2, ["Sabado", "Domingo"]];
println(days) // Print [ Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo ]
tipo de los Items

Aquí en realidad el compilador aplana las secuencias anteriores para generar la nueva secuencia. JavaFX script también nos provee una forma más simple de trabajar con secuencias aritméticas.
Ejemplo

def nums = [1..100];

Esto crearía una secuencia la cual poseería los números del 1 al 100

Using Predicates
Nos referimos a predicados cuando usamos una expresión booleana para generar una nueva secuencia que sea formada por un sub conjunto de la secuencia original.
Ejemplo:

def nums = [1,2,3,4,5];
def numsGreater = nums[n | n > 2];
println(numsGreater); // Esto imprimiría [3, 4, 5]

Aquí estamos creando una nueva secuencia en base a una existente y un predicado, analicemos mejor este ejemplo, para esto desglosáremos la siguiente sentencia
nums[n | n > 2]

nums // Selecciono la secuencia previa
[ // Abro [ para marcar mi predicado
n // Defino la variable n
| // Se encarga de separar la variable del predicado
n // Indico un criterio de filtrado, que sería propiamente el predicado
] // Cierro el predicado

Accessing Sequence Items
Muchas veces nos vemos en la necesidad de acceder a los ítem que están almacenados en nuestras secuencias y para esto podemos usar los indexes de la secuencia.

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
println(days[0]);
println(days[1]);
println(days[2]);
println(days[3]);
println(days[4]);
println(days[5]);
println(days[6]);

En este caso no habría problemas porque nosotros conocemos la cantidad de ítems, que hay en nuestra secuencia si nosotros quisiéramos conocer la cantidad de ítems que hay deberíamos usar la palabra reservada sizeof

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
println(sizeof days);  // Esto imprimiría el numero 7

Inserting Items into a Sequence
Otra palabra reservada del lenguaje es la palabra insert, esta es usada para lograr insertar elemento en una secuencia. Aquí debemos tener en cuenta un dato que no es menor y es que las secuencias realmente son inmutables(Inmutables quiere decir que después de estar creadas nunca se modifican), entonces nosotros en realidad al insertar un ítem en una secuencia en verdad por debajo se crea una nueva secuencia y se reasigna automáticamente, dando la impresión que modificamos la secuencia existente.

// Inicializamos la secuencia con un solo ítem
var days = ["Lunes"];
// Insertamos dos ítem al final de la secuencia
insert "Martes" into days;
insert "Jueves" into days;
// Insertamos un ítem antes que el ítem de la posición 2
insert "Miercoles" before days[2];
// Insertamos un ítem después que el ítem de la posición 3
insert "Viernes" after days[3];

Si usamos posiciones invalidas no sucede nada y los ítem son insertado al final o al comienzo dependiendo el caso, por ejemplo si insertáramos un ítem after days[24] veríamos que realmente se inserta al final de la secuencia o un ítem before days[-1]
este se inserta al comienzo.

Deleting Items from a Sequence
Como ya hemos insertado ítem también debe existir la posibilidad de borrarlos y esto se puede realizar por medio del keyword delete usando en distintas formas

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// Borramos el ítem "Lunes"
delete "Lunes" from days;
// Borramos el ítem de la posición 0
delete days[0];
// Borramos todos los ítem, pero la secuencia sigue siendo útil
delete days;

Esto es muy similar a lo anterior, cabe destacar que si elemento marcado o la posición seleccionada para borrar no existen, no se realiza ninguna acción de borrado.

Reversing the Items in a Sequence
Esta técnica nos permite invertir una secuencia en su totalidad usando tan solo la keyword reverse. Veamos un ejemplo para aclarar esto

// Iniciamos la secuencia con los números del 1 al 5
var nums = [1..5];
// Damos vuelta la secuencia
reverse nums;
// Esto imprime [ 1, 2, 3, 4, 5 ]
println(nums);
// Invertimos la secuencia pero ahora si asignamos su resultado
nums = reverse nums;
// Esto imprime [ 5, 4, 3, 2, 1 ]
println(nums);

El ejemplo de arriba nos muestra como las secuencia no se auto asignan su reverse y en este caso debe ser explicito por el programador, no funciona como los delete o insert donde se hace automáticamente.

Comparing Sequences
Para comparar las secuencias se tienen en cuenta dos puntos, el primero su longitud y el segundo la correspondencia entre sus ítem. Al cumplirse estos dos hitos podemos asegurar que las secuencias son iguales.

// Creamos dos secuencias iguales
def seq1 = [1,2,3,4,5];
def seq2 = [1,2,3,4,5];
// Comparamos y esta comparación retorna true
println (seq1 == seq2);

Ahora insertaremos un ítem a la seq2 para lograr que sea diferente que la otra y poder volver a ejecutar la comparación.

// Creamos dos secuencias iguales
var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5];
// Insertamos un elemento en la seq
insert 6 into seq2;
// Imprimimos la seq2 para comprobar que cambio
println(seq2);
// Comparamos y esta comparación retorna false
println (seq1 == seq2);

Hasta aquí vimos el caso de igualdad y el caso donde la longitud es mayor, ahora nos queda pendiente ver cuando sus ítems tienen otra posición y esto también genera una desigualdad entre secuencias.

// Creamos dos secuencias iguales
var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5];
// Insertamos un elemento en la seq
seq2 = reverse seq2;
// Imprimimos la seq2 para comprobar que cambio su orden
println(seq2);
// Comparamos y esta comparación retorna false
println (seq1 == seq2);

Aquí cubrimos los 3 casos de comparación entre secuencias, ahora vallamos al último punto

Using Sequences Slices
Antes proceder a explicar las distintas formas de conseguir un slice, deberíamos entender que es un slice, un slice básicamente consiste en una porción de alguna secuencia en base a un criterio o selección, se podría definir un slice como un subconjunto de la secuencia, un slice es una secuencia.
Podemos definir slice de las siguientes maneras
seq[a..b]
seq[a..<b]
seq[a..]
seq[a..<]

En las definiciones de arriba seq seria la secuencia que queremos obtener un slice y a y b los indexes de comienzo y fin, expliquemos cada uno

seq[a..b]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría los ítem "Sabado" y "Domingo"
def weekend = days[5..6];

Esta forma de crear un slice incluye ambos indexes

seq[a..<b]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría todos los ítem menos "Sabado" y "Domingo"
def weekdays = days[0..<5];

En este caso solo la primer posición es incluida y el otro no.

seq[a..]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría los ítem "Sabado" y "Domingo"
def weekend = days[5..];

Aquí estamos definiendo un slice que comience en la posición 5 y que incluya dicha posición hasta el final de la secuencia inclusive.

seq[a..<]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría todos los ítem menos el "Domingo"
def days2 = days[0..<]; 

Este tipo de slice es similar al anterior ya que comienza en la primera posición inclusive y va hasta el final de la secuencia pero sin incluir el último elemento

Hasta aquí hemos analizados las distintas acciones y tipos referido a las secuencias ya en el próximo post estaremos analizando el binding y los trigger en JavaFX, me voy despidiendo y espero el post les sea de utilidad

Saludos