Perl: Switch Statement

Sentencia Switch

Las versiones antiguas de Perl (la vieja escuela o "perl old school") no tienen sentencia switch. O sea que la sentencia switch no es propia del lenguaje, pero se puede simular o hacer construcciones que cumplan el mismo propósito.
A continuación algunos ejemplos:

Ejemplo usando diferentes maneras de switch

#This is perl 5, version 14, subversion 2 (v5.14.2)
#File: UingSwitch.pm
package UsingSwitch;

    use Moose;
    use strict;
    use warnings;
    #use namespace::autoclean;
    use Switch; #Usado en switch_modo_1_

#Switch using 'use Switch' (usando el módulo Switch)
sub switch_modo_1_(){
  my ($self, $i) = @_;
  #use Switch
  switch ($i) {
case 0  { return 'uno' }
        case 2  { return 'dos' }
        case 3  { return 'tres' }
        case [4..9]  { return 'entre 4 y 9' }
        else {return 'Default...'}
        }
     
  return;
}

(Nota: Ojo... Que usar la librería Switch de Perl, impacta negativamente en el rendimiento aumentando el tiempo de ejecución. Si es importante el rendimiento puede ser preferible no usar la librería Switch.)

#Switch using bare block (usando estructura de bloques)
sub switch_modo_2_(){
  my ($self, $i) = @_;
  SWITCH: {
     $i == 1 && do { return "1";};
     $i == 2 && do { return "2";};
     $i == 3 && do { return "3";};
     return "Default...";
  }
=pod
  #Otra forma:
  $var = 2;
  SWITCH: {
    $var == 1 && do { print "1\n"; last SWITCH; };
    $var == 2 && do { print "2\n"; last SWITCH; };
    $var == 3 && do { print "3\n"; last SWITCH; };
    print "\$var is not equal with 1 or 2 or 3\n";
}
=cut
  return;
}

#Switch using hash (usando los valores de un hash)
sub switch_modo_3_(){
  my ($self, $i) = @_;
  my %my_switch = (
     1 => "1",
     2 => "2",
     3 => "3",
  );
  return $my_switch{$i};
}

#Switch using hash with functions (usando un hash con valores funciones)
sub switch_modo_4_(){
  my ($self, $i) = @_;
  my %my_switch = (
     1 => sub {return "uno";},
     2 => sub {return "dos";},
     3 => sub {return "tres";}
  );
  my $res = $my_switch{$i}->();
  return $res;
}

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#...............................................................................................

#test_UsingSwitch
#!/usr/bin/perl
#use strict;
use warnings;

use UsingSwitch;

my $ex = UsingSwitch->new();

#Switch using 'use Switch'
print $ex->switch_modo_1_(2); #imprime 'dos'
#Switch using bare block
print $ex->switch_modo_2_(1000); #Default
#Switch using hash
print $ex->switch_modo_3_(3); #Default
#Switch using hash with functions
print $ex->switch_modo_4_(1); #Default
print "...end \n";
#............................................................................................end

dario:~/examples$ perl test_UingSwitch.pl 
Esto imprime:
dosDefault...3uno...end 

Referencia:
-http://perldoc.perl.org/5.8.8/Switch.html.
-Writing a Switch Statement.
-Perl Switch statement.
-Older versions of Perl have no switch statement. How do I avoid a long if-else-if pattern?

Perl: POO con Moose, paso de parámetros

En perl todos los objetos son una referencia. Es decir, cuando tenes un $obj es una variable scalar que simplemente mantiene la referencia al objeto.

Ejemplo de paso de objetos

#This is perl 5, version 14, subversion 2 (v5.14.2)
#File: Example.pm
package Example;

    use Moose;
    use strict;
    use warnings;
    #use namespace::autoclean;

    has 'c' => (
                is         => 'rw', #Lectura-Escritura
                isa        => 'Maybe[Str]', #Tipo String
                reader => 'getValor', #getter
                writer => 'setValor', #setter
    );  

sub metodo1{
  my ($self) = @_;

  my $obj = Example->new(obj=>"Primer valor.");
  #$obj = $self->metodo2($obj);
  $self->metodo2($obj);
  print $obj->getValor() . "\n";#Modificado
  return;
}

sub metodo2{
  my ($self, $obj) = @_;

  $obj->setValor("Modificado..."); #usa el objeto pasado como argumento
  return $obj;
}

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#test_example.pl
#Main.......................................................................

#!/usr/bin/perl

#use strict;

use warnings;

use Example;

my $ex = Example->new();

print $ex->metodo1();

print "\n";

#...........................................................................end

Resultado:

~/examples$ perl test_example.pl
Modificado...

Perl: HTML y UTF8 encoding

HTML y UTF8 encoding

Ejemplo de utf8 encoding:

#This is perl 5, version 14, subversion 2 (v5.14.2)
#File: ExampleEncoder.pm
package ExampleEncoder;

    use Moose;
    use strict;
    use warnings;
    #use namespace::autoclean;
    use HTML::Entities;
    use Encode::Encoder;
 
sub encodeHTMLtoUTF8{
  my ($self, $parametro) = @_;

  my $s = HTML::Entities::decode($parametro);
  $s = Encode::Encoder::encoder($s)->utf8;

  return $s;
}

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#!/usr/bin/perl
#use strict;
use warnings;
use ExampleEncoder;

my $ex = Example->new();
my $str = "Córdoba";
print $ex->encodeHTMLtoUTF8($str);

Perl: POO con Moose, Herencia

Herencia con Moose

Uso de herencia en Programación Orientada a Objetos con Perl Moose (perl 5).

1) Herencia simple (INHERITANCE)

#This is perl 5, version 14, subversion 2 (v5.14.2)
#File: Person.pm
package Person; #Super-Class: Es la super-clase

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw',
  isa        => 'Str',
                reader => 'getName',
                writer => 'setName',
    );

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#File: Developer.pm
package Developer;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    extends 'Person'; #SUBCLASSING, hereda de Person

    has 'skill' => (
                is         => 'rw',
               isa        => 'Str',
                reader => 'getSkill',
                writer => 'setSkill',
    );
 
no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#.............................................................................................................................

#File: script_subclassing.pl

#!/usr/bin/perl

use strict;

use warnings;

use Moose;

use Developer; #Nuestra clase

my $instancia = Developer->new(name=>'Daro',skill=>'Perl developer');

print "Nombre: " . $instancia->getName() . "\n"; #return 'Daro'

print "Skill: " . $instancia->getSkill() . "\n"; #return 'Perl developer'

#..........................................................................................................................end

2) Herencia Múltiple (multiple inheritance)

#File: WriterMonkey.pm
package WriterMonkey;

    use Moose;
    use strict;
    use warnings;
    use namespace::autoclean;
 
    has 'keyBySeconds' => (
                is         => 'rw',
  isa        => 'Int',
                reader => 'getKeyBySeconds',
                writer => 'setKeyBySeconds',
    );

    sub writerCode {
        my ( $self ) = @_;
        print "Coding...     \n";
    }
 
no Moose;
__PACKAGE__->meta->make_immutable;
1;

#File: Developer.pm
package Developer;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;
 
    extends 'Person', 'WriterMonkey'; #multiple inheritance

    has 'skill' => (
                is         => 'rw',
  isa        => 'Str',
                reader => 'getSkill',
                writer => 'setSkill',
    );
 
no Moose;
__PACKAGE__->meta->make_immutable;
1;

#.........................................................................................................
#File: script_multiple_inheritance.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use Developer; #Nuestra clase

my $instancia = Developer->new(name=>'Daro',skill=>'Perl developer', keyBySeconds=>60);
print "Nombre: " . $instancia->getName() . "\n"; #return 'Daro'
print "Skill: " . $instancia->getSkill() . "\n"; #return 'Perl developer'
$instancia->writerCode(); #print 'Coding...'
#..........................................................................................................................end

3) Clases Abstractas o Interfaces con métodos abstractos

Hay que tener en cuenta que ni Perl ni Moose ofrecen clases abstractas. Con Moose se puede definir una clase "interfaz única" con role (Moose::Role), que contiene solo una lista de los métodos requeridos (requires). Cualquier clase que consuma este role debe implementar todos los métodos necesarios, ya sea directamente o a través de la herencia. No se puede retrasar la implementación de los métodos requeridos para que puedan ser implementadas por subclases futuras.

#File: Printable.pm
package Printable; #Clase Interface/Abstracta
    use strict;
    use warnings;
    use Moose::Role;

    requires 'doPrint', 'doPrint2'; #Métodos abstractos
    #requires must be implemented by a subclass or consumer class

no Moose;
1;

#File: Paper.pm

package Paper;

    use Moose;

    with 'Printable'; #Implement la clase Printable

    has 'text' => (

  isa        => 'Str', #Tipo String

                reader => 'getText',

                writer => 'setText'

    );

    sub doPrint {

        my ( $self ) = @_;

        print "Doing 1 ... " . $self->getText() . "    \n";

    };

    sub doPrint2 {

        my ( $self ) = @_;

        print "Doing 2 ... " . $self->getText() . "    \n";

    };

    

    

no Moose;

1;

#File: script_test_interface.pl

#!/usr/bin/perl

use strict;

use warnings;

use Moose;

use Paper; #Nuestra clase que implementa la interface Printable

my $instancia = Paper->new(text=>'texto a immprimir.');

$instancia->doPrint();

$instancia->doPrint2();

Referencias:
-Blog: Getting Started with Moose.
-Moose::Manual::Classes.
-Roles_Versus_Abstract_Base_Classes.
-Moose Manual.

Perl: POO con Moose, Estructura de datos

Estructura de datos con Moose

Las clases en Moose (con perl 5) pueden tener estructuras de datos como atributos usando Types en la definición del isa.

1) Clase con Atributos Hash

#This is perl 5, version 14, subversion 2 (v5.14.2)
#File: MyHash.pm
package MyHash;

    use Moose;
    use strict;
    use warnings;
    use namespace::autoclean;

    has 'myHashRef' => (
is => 'rw',
isa => 'HashRef',
reader  => 'getMyHashRef',
writer  => 'setMyHashRef',
default => sub {
return {
'0' => "first",
'1' => "second"
}
                                    }
                     );

    sub printOptions {
        my ( $self ) = @_;
        my $str = $self->getMyHashRef->{'0'};
        $str .= "\n";
        $str .= $self->getMyHashRef->{'1'};
        $str .= "\n";
        print $str;
    }

no Moose;
__PACKAGE__->meta->make_immutable;
1;

#................................................................................................
#File: script_test_MyHash.pl
#!/usr/bin/perl
use strict;
use warnings;
use MyHash;

my $instancia = MyHash->new();
$instancia->printOptions();
$instancia->setMyHashRef({'0' => "primero", '1' => "segundo"});
$instancia->printOptions();
#.............................................................................................end

Referencias:
-Types in Moose.
-Attribute Native.

Perl: POO con Moose, Básico

Programación Orientada a Objetos en Perl con Moose

Para programar OO con Perl se puede usar la vieja escuela con perlobj (mediante un mecanismo conocido como bendición) o usar algo más moderno como uno de los sistemas de POO para Perl: Moose, Moo (Minimalist Object Orientation Moose compatible), Class::Accessor, Class::Tiny, Role::Tiny o Perl 6 OO (en el futuro). Aquí vamos a usar Moose. Moose es un "postmodern object system for Perl 5" que hace más amigable la POO que la vieja escuela de perlobj.  En la vieja escuela era necesario crear el método new de las clases, en cambio con Moose no es necesario porque las clases heredan de Moose::Object quien ya implementa el new. O sea que prescindimos de la creación de constructores new.

Instalar Moose

Se debe por lo menos tener instalado Perl 5.8, pero es preferible 5.10 o 5.12. Moose se instala fácilmente con CPAN:

cpan Moose

#o se puede usar: sudo perl -MCPAN -e 'install Moose'
#o también: sudo apt-get install libmoose-perl

Ejemplos de Clases Moose:

1) Una Clase con Atributo String

#File: NameStr.pm
package NameStr;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw', #Lectura-Escritura. También se puede usar 'ro' = read-only
  isa        => 'Str', #Tipo String (es obligatorio el valor string)
    );

    sub myNameIs
    {
        my $self = shift;
        my $myname = $self->name();
        print "My name: $myname \n";
    }


no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1; # Don't forget "1;" at end to return a true value from the file.
=pod
Nota 1: el  "isa  => 'Str'" hace que sea obligatorio que cuando se setea el valor el mismo sea string. Si se quiere que acepte un Undef lo que se debe poner es "isa => 'Maybe[Str]'".
Nota 2: Poner make_immutable junto con autoclean es una buena práctica Moose.
=cut

#...........................................................
#File: script_NameStr.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use NameStr; #Nuestra clase

my $instancia = NameStr->new();
$instancia->name('Daro');
$instancia->myNameIs();
#......................................................End

2) Una Clase con Atributo String y getter-setter

#Se puede usar getter and setter estilo Java

#File: NameStr.pm
package NameStr;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw', #Lectura-Escritura
  isa        => 'Str', #Tipo String
                reader => 'getName', #getter
                writer => 'setName', #setter
    );

    sub myNameIs
    {
        my $self = shift;
        my $myname = $self->getName(); #getter
        print "My name: $myname \n";
    }


no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#...........................................................
#File: script_NameStr.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use NameStr; #Nuestra clase

my $instancia = NameStr->new();
$instancia->setName('Daro'); #setter
$instancia->myNameIs();
#......................................................End

3) Una clase con atributo Integer

#File: AgeInt.pm
package AgeInt;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'age' => (
                is         => 'rw', #Lectura-Escritura
  isa        => 'Int', #Tipo Integer
                default =>  37            
    );


no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#...........................................................

#File: script_AgeInt.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use AgeInt;  #Nuestra clase

my $instancia = AgeInt->new();
print $instancia->age() . "\n";
$instancia->age(19);
print $instancia->age() . "\n";
#......................................................End

4) Propiedades de atributos

#File: NameStrAtr.pm
package NameStrAtr;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw', #Lectura/Escritura
  isa        => 'Str', #Tipo String
                reader => 'getName',
                writer => 'setName',
                required => 1, #Es requerido y no permite el valor 'undef'
                clearer   => 'clearName', #permite limpiar el valor, provoca que hasName devuelva false
                predicate => 'hasName', #devuelve true si tiene un valor
                lazy    => 1, #no se inicializa hasta que se llama al método lector
                default => '',
                init_arg => 'elNombre' #Nombre con el cual se referencia desde el constructor
    );

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#.............................................................................................................

#File: script_NameStrAtr.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use NameStrAtr; #Nuestra clase

my $instancia = NameStrAtr->new(elNombre=>'Daro'); #required
print "Nombre: " . $instancia->getName() . "\n"; #return 'Daro'
$instancia->setName('Daro Andres');
print "Nombre: " . $instancia->getName() . "\n"; #return 'Daro Andres'
print "Has value?: " . $instancia->hasName() . "\n"; #return 1 (true)
$instancia->clearName(); #Limpia el valor
print "Has value?: " . $instancia->hasName() . "\n"; #return (false)
#........................................................................................................End

5) Inicializadores de atributos con Builder   

#File: NameStrBuilt.pm
package NameStrBuilt;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw', #Lectura/Escritura
  isa        => 'Str', #Tipo String
                reader => 'getName',
                writer => 'setName',
                builder   => 'buildName'

    );

    #Constructor inicializador del atributo name
    sub buildName {
        my $self = shift;
        $self->setName('Built Name (Nombre construido)'); #Inicializa
    }

no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#.............................................................................................................

#File: script_NameStr.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use NameStrBuilt; #Nuestra clase

my $instancia = NameStrBuilt->new();
print "Nombre: " . $instancia->getName() . "\n"; #return 'Built Name (Nombre construido)'
#........................................................................................................End

6) Disparadores trigger en atributos

Un disparador es una función que es llamada cada vez que se cambia el atributo.

#File: NameStrTrigged .pm
package NameStrTrigged;

    use Moose;
    use strict; #Obliga a la programación segura y definición de variables
    use warnings; #Ayudará a encontrar errores de sintaxis
    use namespace::autoclean;

    has 'name' => (
                is         => 'rw', #Lectura/Escritura
  isa        => 'Str', #Tipo String
                reader => 'getName',
                writer => 'setName',
                trigger => \&triggerForSetName, #referencia a la función que se va a disparar cuando se setea el valor

    );

    #El trigger se dispara despues que se setea el atributo
    sub triggerForSetName {
        my ( $self, $name, $old_name ) = @_;
        if ($old_name){
            print "Trigger executed... new: ".$name." old: ".$old_name."\n";
        }
    }
 
no Moose;
__PACKAGE__->meta->make_immutable; #no voy a cambiar mi clase
1;

#.............................................................................................................
#File: script_NameStr.pl
#!/usr/bin/perl
use strict;
use warnings;
use Moose;
use NameStrTrigged; #Nuestra clase

my $instancia = NameStrTrigged->new(name=>'Nombre inicial');
print "Nombre: " . $instancia->getName() . "\n"; #return 'Built Name (Nombre construido)'
$instancia->setName('Segundo nombre');
print "Nombre: " . $instancia->getName() . "\n"; #return 'Built Name (Nombre construido)'
=pod
Se imprime en pantalla:
Nombre: Nombre inicial
Trigger executed... new: Segundo nombre old: Nombre inicial
Nombre: Segundo nombre
Presione una tecla para continuar . . .
=cut
#........................................................................................................End


Bueno, así vimos un resumen general del uso de clases con Moose.


Referencias:
http://en.wikibooks.org/wiki/Programming_with_Moose
https://dl.dropboxusercontent.com/u/45670449/Moose_Manual.pdf
http://modernperlbooks.com/books/modern_perl/chapter_07.html
https://www.perl.org/about/whitepapers/perl-object-oriented.html
https://metacpan.org/pod/Moose::Manual
http://perlmaven.com/object-oriented-perl-using-moose
https://metacpan.org/pod/Moo
http://perldoc.perl.org/perlootut.html#Role%3a%3aTiny

Java: Evolución de Java

Listas de novedades y cambios en la evolución de Java.

• Java 8, JSE 8 (2014):

8)a) Eliminación del espacio de memoria (remove PermGen).
8)b) Compact Profiles (Small VM).
8)c) Expresiones Lambda (Explicación, programación funcional con funciones anónimas y clausuras)
8)d) Métodos predeterminados en interfaces (Default Methods).
8)e) API Stream (java.util.stream) con estilo funcional y paralelismo.
8)f) Nuevo API para Fechas (java.time).
8)g) Nuevo motor Javascript (Nashorn).
8)h) Soporte estándar de codificación Base64.
8)i) Anotaciones en cualquier uso de tipos.
8)j) Java HotSpot más Mission Control.
8)k) Mejoras en JDBC (JDBC 4.2).
Ver novedades: Lista completa de novedades,
Tutorial:  Oracle Java Tutorial.
Download: JDK 8.

• Java 7, JSE 7 (2011), Dolphin:

7)a) Project coin. (JSR334 Mejoras para la productividad)
7)b) Strings en switchs.
7)c) Gestión automática de recursos en sentencias try-catch.
7)d) Multicatch.
7)e) Rethrow de excepciones más precisos.
7)f) Operador diamante <>.
7)g) Literales binarios.
7)h) Guiones bajos en literales numéricos.
7)i) Fork/Join y utilidades de concurrencia.
7)j) Mejoras en trabajo con archivos y carpetas.

Ver novedades:
Tutorial:
Download:
Java EE: API Java EE7, Java EE7 Specification, Oracle Announces Availability of Java Platform Enterprise Edition 7.

• Java 6, JSE 6 (2006), Mustang: 

Estuvo en desarrollo bajo la JSR 270.

6)a) Lenguajes de scripting.
6)b) API para el compilador.
6)c) Nuevas anotaciones.
6)d) Nueva API para XML (StaX).

Ver novedades:
Tutorial:
Download:
Java EE: API Java EE6, Java EE6 Specification.

• Java 5, J2SE 1.5 (2004), Tiger: 

Desarrollado bajo JSR 176.

5)a) Generics.
5)b) Bucle for mejorado.
5)c) Autoboxing/unboxing.
5)d) Enums.
5)e) Varargs.
5)f) Static import.
5)g) Anotaciones.

Ver novedades:
Tutorial: Free Java Certification Training & Java Core Training.
Download:
Java EE: API Java EE5, Java EE5 Specification.

• Java 4, J2SE 1.4 (2002), Merlin: 

Primer lanzamiento de la plataforma Java desarrollado bajo el Proceso de la Comunidad Java como JSR 59.

• Java 3, J2SE 1.3 (2000), Kestrel: 

• Java 2,  J2SE 1.2 (1998), Playground:

• Java 1 (1996-1997): 

- JDK 1.1 (1997) — modelo de eventos AWT, clases internas (inner classes), JavaBeans, JDBC (Java Database Connectivity), RMI (Remote Method Invocation).

- JDK 1.0 (1996) — Primer lanzamiento.

Java online test:

Java beginner (11 questions).

Java part 1 (39 questions).

Java part 2 (40 questions).

Java part 3 (22 questions).

Java part 4 (30 questions).

Java part 5 (25 questions).

Core Java part 1 (10 questions).

Core Java  (72 questions).

Java  (20 questions).

Java programming.

Java Exception handling.

Java object class.

Java Wrapper classes.

Java I/O Package.

Java Threads.

EJB (20 questions).

J2EE (10 questions).

Online practice test - free practice test - practice exam.

Free Java Online Practice Tests.

SCJP mock test online.