Código Fuente

Como saber la versión de ubuntu por línea de comandos

2011-11-02T07:56:00.001-03:00

Para saber que versión de Ubuntu estamos utilizando sólo valiéndonos de la línea de comandos podemos revisar el contenido de /etc/lsb-release. Por ejemplo:

user@host-name:/var/www/$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=10.04
DISTRIB_CODENAME=lucid
DISTRIB_DESCRIPTION="Ubuntu 10.04.3 LTS"

Muestra la salida de un Ubuntu LTS (el 10.04.3)

El tipo boolean y el objeto Boolean en Java

2011-06-08T18:43:00.002-03:00

En Java tenemos dos maneras de representar el concepto de booleano, una forma es con el tipo primitivo boolean y la otra es utilizando el objeto de la clase Boolean. En el siguiente ejemplo se ve como crearlos y como pasar de uno a otro y como se comportan en las comparaciones:

class EjemploBoolean  {
    public static void log(String s) {
        System.out.println(s);
    }
    public static void main(String args[]) {
        Boolean objetoTrue = new Boolean("true");
        Boolean objetoFalse = new Boolean("false");
        boolean valorPrimitivoTrue = objetoTrue.booleanValue(); // pasando del objeto al valor primitivo.
        log("valorPrimitivoTrue: " + valorPrimitivoTrue);
        log("objetoTrue: " + objetoTrue);
        log("objetoFalse: " + objetoFalse);
        if(objetoTrue) {
            log("Rama de true");
        }
        if(objetoFalse) {
            log("Rama de true no debería pasar.");
        }
        log("Comparando objetoTrue == valorPrimitivoTrue: " + (objetoTrue == valorPrimitivoTrue) );
    }
}

La salida del anterio programa es la siguiente:

#javac EjemploBoolean.java && java EjemploBoolean
valorPrimitivoTrue: true
objetoTrue: true
objetoFalse: false
Rama de true
Comparando objetoTrue == valorPrimitivoTrue: true

Ejemplo de foreach en Java

2011-06-07T23:05:00.002-03:00

Quienes vengan del mundo de PHP conocerán que la forma más sencilla de iterar un array en ese lenguaje es utilizar la estructura de control foreach. Java no posee esa palabra reservada, pero si puede lograrse una forma de iteración equivalente mediante el uso de for y una sintáxis como la que se aprecia en el siguiente ejemplo:

class ForeachEjemplo  {
    public static void main(String args[]) {
        String [] arrStr = {"1", "2", "3", "4", "5"};
        for(String elemento : arrStr) {
            System.out.println(elemento);
        }
    }
}

Como pasar de int a un String en Java

2011-06-07T22:53:00.002-03:00

A continuación un ejemplo de como pasar desde un String a un valor int en Java utilizando el método estático de la clase String.parseInt

class StringAInt  {
    public static void main(String args[]) {
        String valorStr1 = "1";
        String valorStr2 = "1";
        String valorStr3 = "     1 ";
        int valorInt1 = Integer.parseInt(valorStr1);
        int valorInt2 = Integer.parseInt(valorStr2);
        int valorInt3 = Integer.parseInt(valorStr3.trim());
        System.out.println(valorInt1 + valorInt2 + valorInt3);
    }
}

Los primeros dos valores se parsearon directamente porque venían en un formato adecuado. En cambio el valor contenido en la variable valorStr3 fue primero trimeado porque contenía espacios.

Como leer un archivo de texto en Java

2011-06-07T22:16:00.002-03:00

En el siguiente ejemplo se muestra como leer un archivo de texto utilizando Java. El archivo se lee línea por línea, y a medida que avanza la lectura se imprimen la líneas por pantalla.

import java.io.*;
class LeerArchivo  {
    public static void main(String args[]) {
        try{
            // Abrimos el archivo
            FileInputStream fstream = new FileInputStream("LeerArchivo.java");
            // Creamos el objeto de entrada
            DataInputStream entrada = new DataInputStream(fstream);
            // Creamos el Buffer de Lectura
            BufferedReader buffer = new BufferedReader(new InputStreamReader(entrada));
            String strLinea;
            // Leer el archivo linea por linea
            while ((strLinea = buffer.readLine()) != null)   {
                // Imprimimos la línea por pantalla
                System.out.println (strLinea);
            }
            // Cerramos el archivo
            entrada.close();
        }catch (Exception e){ //Catch de excepciones
            System.err.println("Ocurrio un error: " + e.getMessage());
        }
    }
}

Ejemplo de String indexOf de Java

2011-06-07T22:02:00.003-03:00

El método indexOf de la clase String de Java, nos permite obtener el índice de comienzo de una subcadena dentro de otra.

public class indexOfEjemplo {
  public static void main(String[] args) throws Exception{
    String cadena = "Codigo Fuente en Java";
    int index = cadena.indexOf("Java"); 
    System.out.println(index);
  }
}

Cuando queremos conocer sucesivas apariciones de una subcadena, podemos llamar la función repetidamente, pero con un segundo parametro que incluíra el índice de la última posición encontrada más 1. Por ejemplo:

public class indexOfEjemplo01 {
  public static void main(String[] args) throws Exception{
    String cadena = "Codigo Fuente en Java y aca aparece otra vez Java";
    int index = cadena.indexOf("Java"); 
    System.out.println(index);
    index = cadena.indexOf("Java",index+1); 
    System.out.println(index); // imprime segunda aparicion de Java
  }
}

El método SPLIT en Java

2011-06-07T21:41:00.003-03:00

Veamos un ejemplo sencillo de como utilizar el método split en Java. En este ejemplo convertiremos una cadena a un array de cadenas.


public class EjemploSplit {
    public static void  main (String args[]) {
        String numeros = "1,2,3,4,5,6";
        String[] numerosComoArray = numeros.split(",");
        for (int i = 0; i < numerosComoArray.length; i++) {
            System.out.println(numerosComoArray[i]);
        }
    }
}

Ejemplo de Herencia en Java

2011-06-07T21:36:00.003-03:00

Acá tenemos el ejemplo básico de herencia en Java. En este caso la clase Ciudadano hereda desde la clase Persona, para tomar funcionalidad y extenderla.

class Humano {
    protected String nombre;
    protected String apellido;
    public Humano(String nombre,String apellido) {
        this.nombre = nombre;
        this.apellido = apellido;
    }
    public String nombreCompleto() {
        return this.apellido + ", " + this.nombre;
    }
    public String identificacion() {
        return this.nombreCompleto();
    }
    
}

class Ciudadano extends Humano {
    protected String documento;

    public Ciudadano(String nombre,String apellido, String documento) {
        super(nombre,apellido);
        this.documento = documento;
    }

    public String identificacion() {
        return super.identificacion() + ", documento: " + this.documento;
    }
}


public class Herencia {
    public static void  main (String args[]) {
        Humano a = new Humano("Emilio","Rosso");
        Ciudadano b = new Ciudadano("Emilio","Rosso","3052454545");
        Humano [] arregloDeHumanos;
        arregloDeHumanos.push(a);
        arregloDeHumanos.push(b);
        identificarPolimorfico(arregloDeHumanos);
    }

    public static void identificarPolimorfico(Humano [] arregloDeHumanos) {
        for(int i = 0; i < arregloDeHumanos.length ; i++) {
            System.out.println("Identificando: " + arregloDeHumanos[i].identificacion());
        }
    }

}

Todo sobre jQuery y los checkbox

2011-06-04T17:52:00.004-03:00

Aquí una serie de ejemplos para aprender a utilizar jQuery y los checkbox de formulario.

Saber si un checkbox está checkeado o no

Checkbox 1 Checkbox 2

Estos checkbox abmos tienen la clase checkbox1, veamos como ejecutar un código que nos diga en que estado está cada uno (para ejecutar algo con cada uno utilizaremos el método each de jQuery.)

  $('.ejemploCheckbox1').each(function(){
     var checkbox = $(this);
     log('El checkbox ' + checkbox.attr('name') + ' está checkeado? ' + checkbox.is(':checked')  );
  });

Como ven la cuestión se reduce a utilizar el método is con el prédicado checked.

Setear el valor de un checkbox:

Checkbox 1 Checkbox 2

Los anteriores checkbox tienen la clase ejemploCheckbox2, setear el valor de cada uno de ellos con jQuery es muy fácil utilizando el método attr:

  $('[name="checkbox1"].ejemploCheckbox2').attr('checked',false);
  $('[name="checkbox2"].ejemploCheckbox2').attr('checked',true);

En el código anterior utilizamos un selector por el atributo name, y luego al elemento matcheado le seteamos la propiedad checked, utilizando un valor true o false.

Ejecutar código cuando se checkea un checkbox:

Como último ejemplo veamos como realizar una acción cuando se checkea o se descheckea un checkbox. Para eso utilizaremos el evento click del checkbox, y el predicado :checked como vimos en el primer ejemplo.

Checkbox 1

  $('[name="checkbox1"].ejemploCheckbox3').click(function() {
    if($(this).is(':checked')) {
      log('Se hizo check en el checkbox.');
    } else {
      log('Se destildo el checkbox');
    }
  });

Si hacen click en ejecutar en el código anterior. Pueden probar lo que sucede cada vez que se tilda o se destilda el checkbox del ejemplo.

El método indexOf de javascript

2011-06-04T17:27:00.003-03:00

El método o función indexOf de los arrays de javascript, sirve para obtener el índice o posición de un elemento dado en un array.

Algunos navegadores como Internet Explorer 8 no cuentan con la definición de la función nativamente por lo que antes de utilizarla la debemos definir. Tomaremos la definición que se encuentra en la documentación de Javascript de la fundación Mozilla y luego veremos algunos ejemplos de su uso:

  if (!Array.prototype.indexOf)
  {
    Array.prototype.indexOf = function(searchElement /*, fromIndex */)
    {
      "use strict";
      if (this === void 0 || this === null)
        throw new TypeError();
      var t = Object(this);
      var len = t.length >>> 0;
      if (len === 0)
        return -1;
      var n = 0;
      if (arguments.length > 0)
      {
        n = Number(arguments[1]);
        if (n !== n) 
          n = 0;
        else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
          n = (n > 0 || -1) * Math.floor(Math.abs(n));
      }
      if (n >= len)
        return -1;
      var k = n >= 0
            ? n
            : Math.max(len - Math.abs(n), 0);
      for (; k < len; k++)
      {
        if (k in t && t[k] === searchElement)
          return k;
      }
      return -1;
    };
  }
  
  var array = [1,2,3,4];
  log('En array el elemento 2 se encuentra en la posición: ' +  array.indexOf(2));
  log('En array el elemento 4 se encuentra en la posición: ' +  array.indexOf(4));
  log('En array el elemento 1 se encuentra en la posición: ' +  array.indexOf(1));
  log('En array el elemento 0 no se encuentra, indexOf devuelve: ' +  array.indexOf(0)); // -1

Hay que tener en cuenta que como se ve en la definición de indexOf anterior, el operador que se utiliza para saber si un elemento está incluído o no es: === y no ==, por lo que la comparación de tipos también se realiza y por ejemplo la búsqueda de false como elemento no dará como resultado el índice de un 0 o un string vacío, algo que si ocurriría si se utilizara == como operador de comparación de igualdad.

Función trim en javascript y en jQuery

2011-06-04T17:17:00.002-03:00

Javascript no cuenta con ningún método nativo para hacer trim de un string. Por lo que debemos escribir nuestra propia función trim. Hay varias maneras de hacerlo, una de las más sencillas utiliza expresiones regulares:

Ejemplo de `trim`

    function trim(str) {
      return str.replace(/^\s+|\s+$/g,"");
    }
    log(trim("      soy un ejemplo "));

Utilizando trim de jQuery

Si nuestra página se encuentra utilizando jQuery podemos utilizar la función que trae jQuery llamada de igual manera pero que es un método del objeto jQuery.

    log(jQuery.trim("      soy un ejemplo "));
    log($.trim("      soy un segundo ejemplo   "));

Explicación de SWITCH y CASE en javascript

2011-06-04T17:06:00.001-03:00

La estructura switch/case de Javascript nos permite evaluar el valor de una expresión para tomar una decisión en el flujo del ejecución. Es muy parecida a la estructura de control if/else pero con switch/case podemos evaluar más de dos casos.

Ejemplo de switch/case evaluando una variable cadena

  var variableAevaluar = "tres";
  switch (variableAevaluar) { 
    case "uno":
      log("Viene 1");
      break;
    case "dos":
      log("Viene 2");
      break;
    case "tres":
      log("Viene 3");
      break;
  }

En el ejemplo, como variableAevaluar tenía asignado el valor tres, el flujo de ejecución siguió por el case "tres":. Hay que tener especial atención en el uso de la sentencia break. Cuando esta se omite, la ejecución continuará por el resto de los case que tenga por debajo, hasta que alguno finalice con break, en general este no suele ser el comportamiento deseado.

Ejemplo de switch/case utilizando el label `default`

Análogamente a else, la sentencia switch puede utilizarse en conjunto con default:, etiqueta a la cual se entrará si la expresión evaluada no coincide con los case anteriores (o para ser más rigurosos, se entrará siempre a menos que un case haya hecho terminar prematuramente la ejecución del switch utilizando break;)

  var variableAevaluar = "NINGUNO";
  switch (variableAevaluar) { 
    case "uno":
      log("Viene 1");
      break;
    case "dos":
      log("Viene 2");
      break;
    case "tres":
      log("Viene 3");
      break;
    default: 
      error("El valor de variable es desconocido.");
      break;
  }

En la etiqueta default: suele ponerse código para el manejo de errores (valores insesperados del usuarios por ejemplo). El break en el último case o default (como en este caso), es opcional ya que no hay etiquetas que puedan seguir la ejecución, pero es buena práctica utilizarlo para dar uniformidad al código.

Hacer un redirect con Javascript

2011-06-03T18:03:00.003-03:00

Para realizar un redirect mediante javascript podemos utilizar la propiedad window.location:

Redirect normal utilizando Javascript

  window.location.href = "http://codigomaldito.blogspot.com/2011/06/hacer-un-redirect-con-javascript.html";

Si estuviesemos adentro de un iframe y queremos hacer un redirect en la ventana principal podemos hacer un redirect refiriendonos a la propiedad top del objeto window

Redirect al top desde adentro de un iframe

  window.top.location.href = "http://codigomaldito.blogspot.com/2011/06/hacer-un-redirect-con-javascript.html";

Ejemplos de setTimeout en Javascript

2011-06-03T17:17:00.003-03:00

La función setTimeout permite registrar un callback o códgo para que se ejecute dentro de un período de tiempo determinado (o sugerido) por el segundo parametro delay (en milisegundos)

var timeoutID = setTimeout(func, delay, [param1, param2, ...]);
var timeoutID = setTimeout(code, delay);

Veamos algunos ejemplos:

Ejecutando un callback luego de 2 segundos

  var timeoutId = setTimeout(function(){
    log('Pasaron 2 segundos desde el click');
  },2000);

Ejecutando código luego de 2 segundos

  var timeoutId = setTimeout("alert('Pasaron 2 segundos desde el click');",2000);

Ejecutando un callback con parametros luego de 2 segundos

En este caso pasaremos parametros a la función anónima que estamos registrando:

  var timeoutId = setTimeout(function(msg){
    log(msg);
  },2000,'Pasaron 2 segundos desde el click');

Cancelando el timeout con clearTimeout

En este ejemplo registraremos un callback pero no dejaremos que se ejecute. Esto se puede lograr con el uso de la función clearTimeout, a la cual podemos pasarle el id devuelto por setTimeout.

  var timeoutId = setTimeout(function(msg){
    log(msg);
  },2000,'Pasaron 2 segundos desde el click');
  clearTimeout(timeoutId); // "de-registramos" el callback
  // nada debería ejecutarse.

case en java

2011-06-01T21:46:00.004-03:00

ejemplos de for en javascript

La estructura de control for en javascript sirve para iterar por un array o un objeto.

Usando for para iterar un array:

Este es uno de los usos clásicos de for conocido muchas veces como una expresión idiomática común en lenguajes como C o C++.

      var arr = [1,2,3,4,5,6];
      var arrLen = arr.length;
      for(var i = 0; i < arrLen; i++) {
        log('El valor de arr['+i+'] = ' + arr[i]);
      }

El cuerpo de la sentencia for que está entre llaves se ejecutará mientras sea la condición i < arrLen sea verdadera. La primera expresión que inicializa var i = 0 se ejecuta una sola vez, y la última expresión i++ es ejecutada por cada iteración.

ATENCIÓN NO SE RECOMIENDA USAR ESTA FORMA. Otra forma problemática que puede tomar la expresión for para iterar un array es:

      var arr = [1,2,3,4,5,6];
      for(var i in arr) {
        log('El valor de arr['+i+'] = ' + arr[i]);
      }

El operador in hace que la variable i tome el valor de los índices del array, pero esto no siempre sucedera como esperamos. Veamos algunos ejemplos en los que los resultados con el uso de for in y sin in varían.

      var arr = []; // declaramos un array vacío.
      arr[5] = 'Valor del indice 5'; // asignamos en el elemento 5 un valor.
      log('El length del array es: ' + arr.length);
      for(var i ; i < arr.legnth ; i++) { // se ejecutan 5 iteraciones
        log('[POR for normal] El valor de arr['+i+'] = ' + arr[i]);
      }      
      for(var i in arr) { // sólo ejecuta una iteración
        log('[POR for in] El valor de arr['+i+'] = ' + arr[i]);
      }

Otro problema que puede surgir por el uso de for in es que itere sobre propiedades inesperadas. Esto sucede porque los prototipos de arrays en Javascript pueden ser modificados (pueden agregarse propiedades). Este problema se ilustra en el siguiente ejemplo:

  // se modifica el prototipo de array
  // para que incluya un métodos llamado `ultimo`
  Array.prototype.ultimo = function () { 
    return this[this.length-1]; 
  };
  
  for (var i in []) { // en un array vacio
    // nos va a listar la propiedad `ultimo`
    // en nuestro array vacio
    log(i);
  }
  
  // Una forma de evitar este problema es utilizar
  // el método hasOwnProperty que verifica si una 
  // propiedad es propia del objeto y no heredada
  // por su prototipo.
  var arr = [];
  for (var i in arr) {
    if (arr.hasOwnProperty(i)) {
      log(i); // en este caso no se ejecuta.
    }
  }

for en javascript y for in

2011-06-01T13:12:00.002-03:00

ejemplos de for en javascript

La estructura de control for en javascript sirve para iterar por un array o un objeto.

Usando for para iterar un array:

Este es uno de los usos clásicos de for conocido muchas veces como una expresión idiomática común en lenguajes como C o C++.

      var arr = [1,2,3,4,5,6];
      var arrLen = arr.length;
      for(var i = 0; i < arrLen; i++) {
        log('El valor de arr['+i+'] = ' + arr[i]);
      }

ATENCIÓN NO SE RECOMIENDA USAR ESTA FORMA. Otra forma problemática que puede tomar la expresión for para iterar un array es:

      var arr = [1,2,3,4,5,6];
      for(var i in arr) {
        log('El valor de arr['+i+'] = ' + arr[i]);
      }

      var arr = []; // declaramos un array vacío.
      arr[5] = 'Valor del indice 5'; // asignamos en el elemento 5 un valor.
      log('El length del array es: ' + arr.length);
      for(var i ; i < arr.legnth ; i++) { // se ejecutan 5 iteraciones
        log([POR for normal] 'El valor de arr['+i+'] = ' + arr[i]);
      }      
      for(var i in arr) { // sólo ejecuta una iteración
        log('[POR for in] El valor de arr['+i+'] = ' + arr[i]);
      }

  // se modifica el prototipo de array
  // para que incluya un métodos llamado `ultimo`
  Array.prototype.ultimo = function () { 
    return this[this.length-1]; 
  };
  
  for (var i in []) { // en un array vacio
    // nos va a listar la propiedad `ultimo`
    // en nuestro array vacio
    log(i);
  }
  
  // Una forma de evitar este problema es utilizar
  // el método hasOwnProperty que verifica si una 
  // propiedad es propia del objeto y no heredada
  // por su prototipo.
  var arr = [];
  for (var i in arr) {
    if (arr.hasOwnProperty(i)) {
      log(i); // en este caso no se ejecuta.
    }
  }

jquery each ejemplos

2011-05-31T21:42:00.005-03:00

La función each de jQuery

La función each de jQuery nos sirve para iterar uno por uno los elementos de una colección, usualmente estos son el resultado de un selector jQuery, pero también pueden ser otras colecciones de Javascript como un array o un objeto.

La forma de la función es:

      jQuery.each( coleccion, callback(indiceEnElArray, valorDelElemento) )

Para entender su funcionamiento lo mejor es ver algunos ejemplos de su uso.

Utilizando jQuery.each con un array

      $.each([1,2,3],function(indice,valor) {
        log('Indice es ' + indice + ' y valor es: ' + valor);
      });

La función pasada como argumento se ejecutará tantas veces como elementos tenga el array, además en cada ejecución recibirá como argumentos el índice del elemento sobre el cual está ejecutando y el elemento mismo (en nuestro código llamado valor).

Utilizando jQuery.each con un objeto

      var objeto = {'ojos': 'rojos', 'pelo': 'castaño', 'mirada': 'enigmatica' };
      $.each(objeto,function(clave,valor) {
        log('Clave es ' + clave + ' y valor es: ' + valor);
      });

En este caso hicimos algo parecido, pero al tratarse de un objeto tiene más sentido llamar a indice como clave en el nombre de parametro de la función que se pasa como argumento.

Utilizando jQuery.each con una colección del DOM

Este es quizá el uso más común de each, y es cuando lo utilizamos con una colección de elementos de jQuery. En este caso podemos utilizar una sintáxis más cómoda omitiendo el primer argumento de each, ya que ejecutaremos each como método de la colección:

un li
otro li

      $('li.example').each(function(indice,valor) {
         log(indice,valor);
         $(valor).html('Soy el li número: ' + indice + ' del DOM.');
      });

Esta vez operamos sobre todos los li del documento html, y reemplazamos el contenido por un texto específico en cada caso.

javascript split

2011-05-31T20:51:00.004-03:00

La función split de Javascript

La función split de javascript es un método de las cadenas utilizado para obtener array cuyos valores son componentes de la cadena.

El prototipo de la función es:

      string.split([separador][, limite])

Separador puede ser o bien una cadena o bien una expresión regular, y es el patrón por el cual se va a cortar la cadena en los componentes que serán del array. La función siempre devuelve un array. Cuando se llama sin argumentos, se devolverá un array vacío.

Ejemplos de split

Podemos utilizar split con una expresión regular como muestra el siguiente ejemplo:

      var t = "Programando en Javascript".split(/ /); // devuelve el array ["Programando", "en", "Javascript"];
      log(t);

En vez de usar una expresión regular podríamos utilizar una cadena y en el ejemplo anterior obtendríamos el mismo resultado:

      var t = "Programando en Javascript".split(" "); // devuelve el array ["Programando", "en", "Javascript"];
      log(t);

Utilizando limit como segundo arguemento, podemos delimitar la cantidad de componentes máximos que tendremos en el array resultante:

      var t = "Programando en Javascript".split(" ",2); // devuelve el array ["Programando", "en"];
      log(t);

El uso clásico del método split es separar una lista de cadenas serpados por coma por ejemplo:

      var t = "1,2,3,4,5,6,7,8,9,10".split(','); // devuelve el array: ["1","2","3","4","5","6","7","8","9","10"];
      log(t);

Javascript replace

2011-05-31T20:29:00.005-03:00

La función replace de Javascript

La función replace de javascript es un método de las cadenas utilizado para obtener una nueva cadena copia de la original con una porción reemplazada.

El prototipo de la función es:

      string.replace(regexp|substr, newSubStr|function[, Non-standard flags]);

Ejemplos de replace

Podemos utilizar replace con una expresión regular como muestra el siguiente ejemplo:

      var t = "Programando en Javascript".replace(/Programando/,"Hablando"); // devuelve "Hablando en Javascript";
      log(t);

En vez de usar una expresión regular podríamos utilizar una cadena para el caso anterior:

      var t = "Programando en Javascript".replace("Programando","Hablando"); // devuelve "Hablando en Javascript";
      log(t);

Las expresiones regulares podrían utilizarse para reemplazar patrones más complejos o específicos, por ejemplo:

      // en este ejemplo matecheamos un dígito mediante una expresión regular.
      var t = "Tengo 5 libros de Javascript".replace(/\d/,10); // devuelve "Tengo 10 libros de Javasript";
      log(t);

Podría darse el caso que con el resultado del matcheo quisieramos tomar algún tipo de decisión para realizar el reemplazo. Por ejemplo el siguiente ejemplo sirve para incrementar el patrón capturado:

 
      function reemplazador(coincidencia1) {
        return parseInt(coincidencia1) + 1;
      } 
      var t = "Tengo 5 libros de Javascript".replace(/\d/,reemplazador); // devuelve "Tengo 6 libros de Javasript" ;
      log(t);
      var s = "Tengo 6 libros de Javascript".replace(/\d/,reemplazador); // devuelve "Tengo 7 libros de Javasript" ;
      log(s);
      var r = "Tengo 7 libros de Javascript".replace(/\d/,reemplazador); // devuelve "Tengo 8 libros de Javasript" ;
      log(r);

Javascript substring

2011-05-31T20:19:00.005-03:00

La función substring

La función substring de javascript es un método que pertenece a las cadenas, y sirve para obtener una porción de la cadena

El prototipo de la función es:

      string.substring(indice1[, indice2])

Dónde string es una cadena, indice1 un entero e indice2 otro entero opcional.

Ejemplos de substring

Sí indice1 e indice2 son iguales, substring devuelve una cadena vacía.

      "Programando en Javascript".substring(5,5); // devuelve ""

Sí indice2 se omite, se devuelve una cadena desde la posición indice1 hasta el final de la cadena..

      "Programando en Javascript".substring(12); // devuelve "en Javascript"

Si queremos quedarnos con una porción bien definida de la cadena podemos utilizar los dos índices de la siguiente manera:

      "Programando en Javascript".substring(0,11); // devuelve "Programando"

Arrays en javascript, ejemplos

2011-05-28T20:31:00.006-03:00

Declaración de un array

Un array o arreglo en Javascript tiene varias maneras de declararse algunos ejemplos:

Utilizando el constructor de array y el operador new:

      var arr1 = new Array(); // declarando un array vacio
      var arr2 = new Array(5); // declarando un array de 5 elementos (su propiedad length está en 5)
      var arr3 = new Array(3,3); // declarando un array de 2 elementos [3,3]

La manera anterior no está recomendada porque da lugar a ambiguedades (lo cual puede notarse en las dos últimas declaraciones).

Una mejor manera de declarar arrays en Javascrip es utilizando la notación literal de Array, va el ejemplo:

      var arr4 = [];  // declarando un array vacío
      var arr5 = [0,0,0,0,0];  // declarando un array de 5 elementos cuyos valores son 0
      var arr6 = [3,3];  // declarando un array de 2 elementos cuyos valores son 3 y 3

Conocer el tamaño de un array

Todos los arrays tienen una propiedad llamada length que permite saber su tamaño.

      var arr7 = [1,2,3,4,5,6,7];
      log(arr7.length); // imprime 7 porque el array tiene 7 elementos.

Hay que tener en cuenta que el length no es el índice de la última posición del array. Como las posiciones comienzan a indexarse desde 0 el índice de la última posición del array siempre puede calcularse utilizando length - 1

      var arr8 = ["a","b","c"];
      log(arr8[arr8.length - 1]); // imprime "c", el último elemento del array

Accediendo a los objetos de un array

Veamos como podemos acceder a los diferentes elementos del array:

      var arr = [1,2,3,4];
      log(arr[0]); // accediendo al primer elemento del array
      var  i;
      for(i = 0; i < arr.length ; i++) { // listando los elementos del array
        log('En la posición: ' + i + ' esta el elemento: ' +  arr[i]);
      }

Los índices de los arrays comienzan en 0

Algoritmo de ordenación en C [INSERTION SORT]

2011-05-21T14:31:00.004-03:00

#include<stdio.h>

void swap(int *e1,int *e2) 
{
  int tmp = *e1;
  *e1 = *e2;
  *e2 = tmp;
}

void insertion_sort(int s[], int n)
{
  int i,j;
  for (i=1; i<n; i++) {
    j=i;
    while ((j>0) && (s[j] < s[j-1])) {
      swap(&s[j],&s[j-1]);
      j = j-1;
    }
  }
}

void print_array(int vect[], int len) 
{
  int i;
  printf("Imprimiendo array de: %d\n", len);
  for(i = 0; i < len ; i++) {
    printf("idx: %d = %d \n", i,vect[i]);
  }
}

int main() 
{
  int vect[10] = {9,5,7,8,4,3,2,5,6,1};
  print_array(vect,10);
  insertion_sort(vect,10);
  print_array(vect,10);
  return 0;
}

Para compilar utilizar:

gcc -Wall insertion-sort.c -o insertion-sort.out

Conectarse remotamente utilizando GNU/Emacs, SSH y Tramp

2010-12-13T21:49:00.001-03:00

Descripción

Como conectarse a un servidor remoto utilizando mediante SSH utilizando GNU/Emacs y tramp.

Por puerto default

C-x C-f /ssh:usuario@hostRemoto:/

Por puerto 60

C-x C-f /ssh:usuario@hostRemoto#60:/

Tareas por línea de comando en Symfony

2010-12-13T21:48:00.000-03:00

Borrar caché

php symfony cc

Nuevo proyecto

php symfony generate:project

Nueva aplicación

php symfony generate:app

Nuevo módulo

php symfony generate:module

Nuevo programa BATCH/TASK

php symfony generate:task

Genera las clases del modelo a partir del SCHEMA

php symfony doctrine-build-model

Crear todo a partir del SCHEMA

php symfony doctrine-build-all-reload

Borra la base

Ejecutar DQL

php symfony doctrine-dql frontend "FROM BlogPost p, p.Tags t"

Ver todas las tareas disponibles para Doctrine

php symfony list doctrine

Generar el SCHEMA a partir de la base de datos

php symfony doctrine:build-schema

Descripción de los status para los archivos versionados con Subversion

2010-12-13T21:47:00.001-03:00

Descripción

El significado de los diferentes status que se presentan en subversion al ejecutar el comando:

Estado	Descripción
`U`	Fichero actualizado
`L`	Fichero bloqueado
`M`	Modificado localmente
`M`	Modificado localmente en sus propiedades, no en su contenido
`?`	Fichero ignorado (nuevo, hay que hacer un add)
`!`	Fichero borrado por el usuario u otro programa (hay que hacer un del)
`~`	Versionado como fichero pero es un directorio (o viceversa)
`A +`	Añadido con historial de procedencia
`M +`	Añadido con historial y tiene modificaciones locales
`D`	Preparado para borrado
`A`	Preparado para añadir
`C`	Conflictos con un update
`S`	Directorio cambiado a rama
`G`	Modificado localmente e incorporados cambios remotos

Nota: La posición de la letra que identifica al estado del archivo es relevante para la descripción del mismo. Por ejemplo M no significa el mismo estado que M

Mantener un servidor DNS local en Ubuntu

2010-12-13T21:45:00.000-03:00

Descripción

Acelera sensiblemente la navegación, ahorrando tiempo en la resolución de nombres, ya que tenemos un caché local con los nombres de dominio resueltos a su correspondiente Ip.

Instalación

sudo aptitude install dnsmasq

Copiando servidores DNS actuales para que use DNSMasq

sudo cp /etc/resolv.conf /etc/resolv.dnsmaq.conf

Editamos archivo `/etc/resolv.conf` y agregamos como primera línea:

nameserver 127.0.0.1

Probamos velocidad de las queries ejecutando varias veces:

dig www.google.com.ar | grep Query

Aumentamos el tamaño de la cache del servicio:

# Editar: vim /etc/dnsmasq.conf
# Set the cachesize here.
cache-size=5500

Ver los archivos de un paquete en Ubuntu

2010-12-13T21:43:00.001-03:00

Con apt-file podemos ver los archivos de un paquete especifico.

sudo apt-file install apt-file
sudo apt-file update
apt-file list package-name

Login por SSH sin password

2010-12-13T21:42:00.000-03:00

Descripción

Permite acceder de manera segura a un servidor mediante SSH sin tener que autenticarse con password.

Generación de las claves en el HOST

Lo primero que debemos hacer es generar claves con nuestro usuario en el HOST desde el cual queremos acceder al servidor para esto ejecutamos:

ssh-keygen -t rsa

Este comando genera la clave pública y privada.

Subiendo la clave pública al SERVIDOR:

La clave pública debe ser subida al SERVIDOR al cual queremos conectarnos para esto utilizamos la copia segura scp

scp ~/.ssh/id_rsa.pub usuarioServidor@ip_servidor:/home/usuarioServidor/temporal

Ahora nos conectamos al servidor y agregamos la clave pública subida recientemente al archivo de claves autorizadas conocidos .ssh/authorized_keys, para esto ejecutamos el siguiente comando en el servidor:

cat temporal >> .ssh/authorized_keys
rm temporal # borramos la clave pública.

Esto debiera bastar para poder hacer login sin que se nos solicite contraseña.

Expresiones regulares en GNU/Emacs

2010-12-13T21:40:00.000-03:00

Descripción

Notas sobre el uso y abuso de expresiones regulares en el editor GNU/Emacs. Basado en el manual de GNU/Emacs y su Wiki.

Expresiones regulares

Las expresiones regulares, son un patron que determinan un conjunto de cadenas (que puede ser incluso infinito).

Cuando una cadena pertenece a dicho conjunto, decimos que la expresión regular produce coincidencias sobre el conjunto.

Caracteres ordinarios

La expresión regular a, es un caracter ordinario que produce coincidencias únicamente sobre la cadena a. La concatenación de dos expresiones regulares produce otra expresión regular, así la expresión regular aa produce coincidencias únicamente sobre la cadena aa.

Por ejemplo que tengamos el siguiente texto en un buffer de Emacs. Para ejecutar una búsqueda hacia adelante de las cadenas sobre las cuales una expresión regular produce coíncidencias, hacemos uso de la función search-forward-regexp cuyo key-binding por defecto es C-M s. Así probamos ejecutar C-M s a estando posicionados con el cursor al principio del buffer.

bbab
AaA

Lo primero que vemos es que la función search-forward-regexp iluminará varios trozos del buffer. En la primera línea iluminará la única a que produce coíncidencias. En la segunda línea, las tres as aparecen iluminadas. Esto no significa que la expresión regular a produzca coíncidencias con la cadena AaA sino que produce coíncidencias sobre cada una de las as por separado. La segunda cuestión importante a destacar es que por defecto la mayoría de las funciones que utilizan expresiones regulares en Emacs producen coíncidencias tanto con minúsculas y con mayúsculas cuando los caracteres ordinarios de la expresión regular están en minúsculas, para activar (o desactivar) la distinción podemos ejecutar el key-binding M-c cuando estemos dentro de la búsqueda (en el minibuffer). La distinción también se activará automáticamente si alguno de los caracteres ordinarios es introducido en mayúsculas. La subsecuente ejecución del key-binding M-c marcará la coíncidencia actual que produce la función en otro color, esto nos permitirá movernos por las cadenas exactas que producen coíncidencias con la expresión regular búscada.

Sintáxis

La sintáxis de las expresiones regulares incluye caracteres ordinarios y construcciones especiales. Un caracter ordinario es una expresión regular simple, que produce coincidencias con el mismo caracter y con nada más. los caracteres especiales son $, ^, ., *, +, ?, [, y \. el caracter ] es especial si este termina un caracter de apertura de alternativa [. el caracter - es especial adentro del caracter de alternativa. cualquier otro caracter que aparezca es una expresión regular es ordinario, a menos que \ lo preceda. (cuando usas expresiones regulares en un programa lisp, cada \ debe ser duplicado.)

Por ejemplo, f no es un caracter especial, es ordinario, y por lo tanto f es una expresión regular simple que produce la coincidencia con la cadena f y con ninguna otra cadena. (no produce coincidencias con la cdena ff.) de la misma manera que o es una expresión regular que produce la coincidencia sólo con la cadena o. (Cuando las diferencias entre mayúsculas y minúsculas son ignoradas, estas expresiones regulares también producen coincidencias con las cadenas F y O, pero consideramos esta una generalización de "la misma cadena", en vez de una excepción.)

Cualesquiera dos expresiones regulares A y B pueden estar concatenadas. El resultado es una expresión regular que produce coincidencias con una cadena si A produce coincidencias sobre una parte del comienzo de la cadena y B produce coincidencias sobre el resto de la cadena.

Como un ejemplo simple, podemos concatenar las expresiones regulares f y o para obtener la expresión regular fo, la cual produce coincidencias sólo con la cadena fo. Aún trivial. Para hacer algo no trivial, se necesita usar alguno de los caracteres especiales. A continuación una lista detallada de estos:

Definiciones de los caracteres especiales

.

Es una caracter especial que produce coincidencias sobre cualquier caracter excepto sobre el caracter de nueva línea. Usando la concatenación, podemos realizar expresiones regulares como a.b, la cual produce coincidencias sobre cualquier cadena de tres caracteres que comience con a y termine en b.

*

No es una construcción en si misma; es un operador posfijo que significa que la expresión regular precedente a la que se aplica producirá coincidencias repetidamente cuantas veces sea posible. Por lo cual, o* produce coincidencias cualquier número de o (incluso la ausencia de o). * siempre aplica a la menor expresión precedente posible. Por lo que, fo* produce repeticiones de o no de la cadena fo. Coincide con f, fo, foo, etc.

+

Es un operador posfijo, similar a * excepto que para producir coincidencias la expresión a la que aplica debe producir coincidencias al menos una vez. Así, por ejemplo, ca+r coincide con la cadena car y caaaar pero no con la cadena cr, en cambio la expresión regular ca*r produce coincidencias sobre las tres cadenas.

?

Es un operador posfijo, similar a * excepto que puede producir coincidencias con la expresión regular que le precede una vez o ninguna vez. Por ejemplo, ca?r coincide con car o con cr y con nada más.

*?, +?, ?

Son las versiones no-glotonas de los operadores anteriores. Los operadores *, +, ? normales son "glotones" en el sentido que producen coincidencias tanto como pueden. Seguidos de un ?, se convierten en operadores no glotones: producen coincidencias con lo mínimo posible.

Por lo tanto, ab* y ab*? pueden coincidir con la cadena a y con la cadena abbbb; pero si se intentara producir coincidencias contra la cadena abbb, la expresión regular ab* capturará la coincidencia abbb (toda la cadena), en cambio ab*? producirá la coincidencia sólo con a (la mínima coincidencia válida).

\{N\}

Es un operador posfijo que específica la repetición N veces, esto es, la expresión regular precedente debe producir coincidencias exactamente N veces en una fila. Por ejemplo, x\{4\} coincide con la cadena `xxxx` y con ninguna más.

\{N,M\}

Es un operador posfijo que especifica repetición entre N y M veces, esto es, la expresión regular precedente debe coincidir al menos N veces, pero no más que M veces. Sí M es omitido, entonces no hay límite superior, pero la expresión regular precedente debe coincidir al menos N veces. Por ejemplo: \{0,1\} es equivalente a ?. `\{0,\} es equivalente a *. \{1,\} es equivalente a +.

[ ... ]

Es un conjunto de caracteres, que comienza con [ y que es terminado por ]. En el caso más simple, los caracteres entre los parentesis son con los que este conjunto puede producir coincidencias.

Así [ad] coincide con a o con una d, y [ad]* coincide con cualquier cadena compuesta sólo de a y de d (incluyendo la cadena vacía), de lo cual se concluye que [c[ad]* coincide con cr, car, cdr, caddaar, etc.

Se puede también, incluir rangos de caracteres en el conjunto, escribiendo el caracter de comienzo y el caracter de finalización con un - entre ellos. Así, [a-z] coincide con cualquier letra en minuscula ASCII. Los rangos pueden ser intercalados libremente con caracteres individuales, como en `[a-z$%.], el cual produce coincidencias con cualquier letra minúscula ASCII o $, % o el punto ..

Notar que los caracteres especiales no tienen un significado especial dentro del conjunto de caracteres. Un conjunto completamente diferente de caracteres especiales existe dentro de los conjuntos de caracteres: ], - y ^.

Para incluír ] en un conjunto, se debe poner como primer caracter. Por ejemplo, []a] coincide con ] y con a. Para incluír -, se debe escribir -como el primer o último caracter del conjunto, o poniendolo fuera de un rango. Así, []-] produce coincidencias con ] y con -.

Para incluír ^ en un conjunto, se lo pone en cualquier lugar distinto del principio del conjunto. (En el comienzo, significa el complemento del conjunto, ver más adelante.)

Cuando se utiliza un rango en una búsqueda no sensitiva a minúsculas y mayúsculas, se deben escribir ambos extremos del rango en mayúsculas, o en minúsculas, o ambos deben ser distintos de letras. El comportamiento de un rango que mezcla mayúsculas y minúsculas como A-z es algo no definido, y puede cambiar en futuras versiones de GNU/Emacs.

[^ ... ]

[^ comienza un "conjunto de carcateres complementario", que produce coincidencias con cualquier caracter excepto con los que se especifiquen en dicho conjunto. Así, [^a-z0-9A-Z] produce coincidencias con todos los caracteres excepto con los dígitos y las letras ASCII.

^ no es un caracter especial a menos que sea el primer caracter. El caracter siguiente a ^ es tratado como si fuese el primero (en otras palabras, - y ] no son especiales allí).

Un conjunto de caracteres complementarios pueden producir coincidencias con una nueva línea, a menos que la nueva línea sea mencionada como uno de los caracteres con los cuales no se debe producir coincidencias. Este comportamiento contrasta al manejo de expresiones regulares hecho en programas como grep.

^

Es un caracter especial que produce coincidencias con la cadena vacía, pero solo al comienzo de la línea del texto. En otro caso, la expresión no produce coincidencias con nada. Así, ^foo produce coincidencias con un foo que este al comienzo de una línea.

Por razones de compatibilidad histórica, ^ puede ser usado con este significado solamente al comienzo de una expresión regular, o luego de ( o \|.

$

Es similar a ^ pero produce coincidencias sólo al final de una línea. Así, x+$ produce coincidencias con una cadena de una x o más al final de una línea.

Por razones de compatibilidad histórica, $ puede ser usado con este significado solo al final de una expresión regular, o antes de \) o \|.

\

Tiene dos funciones: Es un caracter para escapar los caracteres especiales (incluyendo \), e introduce construcciones especiales adicionales.

Debido a que \ escapa los caracteres especiales, \$ es una expresión regular que produce coincidencias sólo con $, y \[ es una expresión regular que produce coincidencias con solo con [.

Nota: por razones de compatibilidad histórica, los caracteres especiales son tratados como ordinarios si aparecen en contextos dónde su significado especial no tiene sentido. Por ejemplo *foo trata a * como un caracter ordinario debido a que no precede una expresión sobre la cual * pueda actuar. Es una mala práctica depender de este comportamiento; es mejor escapar los caracteres especiales en cualquier caso, sin importar dónde aparezcan.

Comprimir y descomprimir carpetas en GNU/Linux

2010-12-13T21:37:00.001-03:00

Descripción

Comprimir y descomprimir una carpeta en un entorno GNU/Linux o GNU/Ubuntu.

Comprimir carpeta

tar -zcvf archivo-comprimido.tar.gz /tmp/carpeta-a-comprimir/

Descomprimir carpeta

 tar -zxvf archivo-comprimido.tar.gz

Desempaquetar un archivo tar

tar -cvf archivo.tar

Desempaquetar un archivo tar

tar -xvf archivo.tar

Como borrar los directorios .svn de un directorio.

2010-12-13T21:32:00.003-03:00

Descripción

Como borrar los directorios .svn de un directorio.

Ejecutar

find . -name '.svn' -print0 | xargs -0 rm -rf

substr: Como obtener subcadenas en PHP

2010-03-28T20:20:00.001-03:00

substr permite obtener una subcadena de una cadena, especificando un comienzo de la subcadena y la longitud que se quiere obtener.

La firma de la función es la siguiente:

 cadena substr  (  cadena $string  ,  int $comienzo  [,  int $longitud  ] )

Algunos ejemplos de uso son:

$cadena = "Como obtener una subcadena.";
echo substr($cadena,4) . "\n"; // ` obtener una subcadena.`
echo substr($cadena,0,4) . "\n"; // `Como`
echo substr($cadena,-10) . "\n"; // `subacdena`

En la última llamada a substr utilizamos un número negativo para el parametro $comienzo, esto hace que el comienzo a utilizar se cuente desde el final de la cadena hacia adelante, así un $comienzo de -10 como en el ejemplo nos ubica al comienzo de la palabra subcadena.

PHP uso de la función implode

2010-03-28T18:56:00.000-03:00

La función implode sirve para obtener una cadena a apartir de un array. A la función se le pasa como argumento una cadena que sirve para unir los pedazos del array y el array mismo que se debe unir.

La firma de la función es la siguiente:

 cadena implode  (  string $union  ,  array $arr  )

Entonces la podemos como en el ejemplo que sigue:

<?php
$arr = array( 'email1@example.com', 'email2@example.com', 'email3@example.com' );
$cc = implode($arr,','); 
echo $cc; 
// imprime:
// email1@example.com,email2@example.com,email3@example.com
?>

La funcion explode de PHP

2010-03-28T18:50:00.000-03:00

La función explode sirve para dividir una cadena (string) en una serie de valores que se guardan en un array. La cadena se divide por el delimitador que se le indique

La firma de explode es la siguiente:

 array explode  (  cadena $delimitador  ,  cadena $cadena  [,  int $limite  ] )

Algunos ejemplos:

$cadena = "rojo negro azul violeta";
$arr = explode(" ", $cadena);

foreach($arr as $val) {
  echo  $val . "\n";
}

// imprime
// rojo
// negro
// azul
// violeta

Como realizar un redirect en PHP, funcion header

2010-03-28T18:40:00.002-03:00

La forma más sencilla de realizar un redirect en PHP es indicarle al navegador en las cabeceras de respuesta que debe llevar al usuario a otra página

Utilizando PHP podemos enviar esta información con el uso de la función header:

Por ejemplo:

header('Location: http://codigomaldito.blogspot.com/');

Lo importante a tener en cuenta es que la función header se debe utilizar antes de que se imprima cualquier otra información de la página. Es decir no debe haber ni echos ni prints ni ningúna salida como bloques de html, sino la redirección no funcionará correctamente.

Otro ejemplo:

<?php
session_start();
if(!isset($_SESSION['login'])) {
  header('Location: login.php'); 
  exit();
}
?>
<html>
  <body>
    <p>
      Bienvenido al sitio.
    </p>
  </body>
</html>

En este ejemplo si el usuario no está logueado (recuerden que sólo es un ejemplo), lo redireccionamos a la página de login.php.

Bucles: for en PHP

2010-03-28T18:10:00.002-03:00

La sentencia for en PHP tiene la misma estructura que la sentencia for de C/C++ y derivados. Su estrucutura es la siguiente:

for (expr1; expr2; expr3)
    sentencia

expr1 se ejecutará una única vez, de expr2 se evaluará su valor booleano, y se ejecutará sentencia y expr3 mientras que de verdadero.

Su uso más común es una expresión idiomática muy conocida heredada desde C, y sirve para recorrer arrays.

$arr  = array(1,2,3,4,5); 
for($i = 0; $i < count($arr); $i++ ) {
   echo "En el indice: $i se encuentra el valor " . $arr[$i] . "\n";
}

foreach en php

2010-03-28T18:02:00.001-03:00

PHP tiene una estructura de control llamada foreach que nos permite recorrer un array de manera muy fácil.

Su estructura es la siguiente:

foreach (ARRAY as $valor)
    sentencia

En este caso ARRAY es un array o bien una expresión que devuelve un array. Por cada posición del array se ejecutará sentencia y en cada una de estas ejecuciones la varialbe $valor tendrá como contenido el valor de la posición actual del array.

Otra forma que puede tomar foreach es la siguiente:

foreach (ARRAY as $clave => $valor)
    sentencia

En este caso lo que cambia es que no sólo tendremos acceso a los valores de las posiciones del array sino también a los índices (o claves en un array asociativo) que indexan al array.

Veamos algunos ejemplos de los dos casos:

$arr = array(1, 2, 3, 4);
foreach ($arr as $val) {
   echo $val . "\n"; 
}
// imprime:
// 1
// 2
// 3
// 4

Y ahora usando la versión ampliada con indices:

$arr = array(1, 2, 3, 4);
foreach ($arr as $key => $val) {
   echo $key . ": " . $val . "\n"; 
}
// imprime:
// 0: 1
// 1: 2
// 2: 3
// 3: 4

Recordar que los índices de los arrays comienzan en 0.

Un último ejemplo lo mostraremos con arrays asociativos (sus índices son strings)

$arr = array('rojo' => 1, 'verde' => 2, 'azul' => 3, 'marron' => 4);
foreach ($arr as $key => $val) {
   echo $key . ": " . $val . "\n"; 
}
// imprime:
// rojo: 1
// verde: 2
// azul: 3
// marron: 4

Switch en PHP

2010-03-28T17:48:00.000-03:00

La sentencia switch es similar a una serie de sentencias IF en la misma expresión. En muchas ocasaiones, querremos comprar la misma variable o expresión, con varios valores diferentes, y ejecutar una pieza de código según el resultado de esta comparación.

Aquí el ejemplo:

if ($variable == 0) {
    echo "Variable es 0";
} elseif ($variable == 1) {
    echo "Variable es 1";
} elseif ($variable == 2) {
    echo "Variable es 2";
}


switch ($variable) {
    case 0:
        echo "Variable es 0 0";
        break;
    case 1:
        echo "Variable es 1";
        break;
    case 2:
        echo "Variable es 2";
        break;
    default:
        echo "Variable tiene otro valor distinto.";
        break;
}

En este ejemplo se muestran códigos equivalentes con el uso de ifs anidados y con switch.

if else, si no, decisiones en php

2010-03-28T17:41:00.000-03:00

if y else son palabras reservadas del lenguaje PHP y su misión es modificar el flujo de ejecución del programa. Es decir tomar decisiones dentro del programa.

Veamos la estructura de if:

if (CONDICION) {
  // CONDICION es verdadera 
}

En el código anterior se evaluará CONDICION y según su valor booleano (verdadero o falseo) se ejecutará el código encerrado entre llaves (en el caso verdadero). Si CONDICION es falso el código entre llaves se ignorará. Y se continuará con el programa.

CONDICION puede ser cualquier expresión válida de PHP algunos ejemplos podrían ser:

if ($resultadoExamen == 10) {
  echo 'Felicitaciones';
}

if ($resultadoExamen < 4) {
  echo 'Desaprobado';
} else {
  echo 'Aprobado';
}

En el último ejemplo escribimos una palabra reservada más: else esta palabra indica el código que se debe ejecutar si la condición expresada en el if resultó falsa. Pero este código nunca se ejecutará si la condición es verdadera.

Como realizar un sistema de Login en PHP y MySQL

2010-02-21T14:42:00.004-03:00

En el siguiente artículo mostraremos como realizar un sistema de Login o Autenticación de usuarios con la ayuda de PHP y Mysql.

Introducción a la autenticación

La autenticación nos permite identificar a un usuario, cuando este presente su nombre de usuario y contraseña. En general estos datos son guardados por el servidor en una base de datos como MySQL y se utilizan para validar los datos ingresados en el momento del Login.

Una vez realizado el Login exitoso, se registra el login en la sesión. Esto nos permite asegurar páginas simplemente pidiendo que exista la sesión del usuario logueado.

La acción de Logout (o Cerrar sesión), se refiere a destruir esta información de la sesión, así el usuario dejará de ser un usuario autenticado.

La siguiente imagen muestra un diagrama dónde se representa el flujo antes explicado

Base de datos

Empecemos por crear la tabla necesaria para lograr la autenticación, requerimos minimamente almacenar un nombre de usuario y una contraseña, por lo que nuestra tabla de usuarios llevará las columnas: username y password.

Nos conectamos a mysql o a phpmyadmin y creamos nuestra tabla de usuarios:

test@test-laptop:~/$ mysql -uroot -p
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 45
Server version: 5.1.37-1ubuntu5.1-log (Ubuntu)

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> create database ejemplo;
Query OK, 1 row affected (0.00 sec)

mysql> use ejemplo;
Database changed
mysql> create table usuarios (id int not null auto_increment primary key, username varchar(100), password varchar(40)) type=innodb;
Query OK, 0 rows affected, 1 warning (0.14 sec)

mysql> alter table usuarios add unique (username);
Query OK, 0 rows affected (0.27 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> describe usuarios;
+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| id       | int(11)      | NO   | PRI | NULL    | auto_increment | 
| username | varchar(100) | YES  | UNI | NULL    |                | 
| password | varchar(40)  | YES  |     | NULL    |                | 
+----------+--------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

En la línea 13, es dónde creamos la tabla. Incorporamos una primary key `id`, y en la línea 16 también agregamos un índice `unique` para asegurarnos que los usuarios no tengan el `username` duplicado.

Por cuestiones de seguridad no guardaremos los passwords en texto plano, por eso elegimos para la columna password un tamaño de 40 caracteres, ya que este es el ancho de cualquier cadena hasheada por la función SHA1.

Clase UserAutentication

Pasemos ahora a escribir la clase de autenticación de usuario que se encargará de la mayoría del trabajo de nuestro sistema de Login. Las responsabilidades de esta clase serán:

Responder si el usuario actual está en sesión y autenticado.
Autenticar a un usuario contra la base de datos y guardar la autenticación en sesión con un username y password.
Desautenticar (logout) a un usuario que se encuentra en sesión.

Definidas estas responsabilidades podemos ahora dar tres métodos públicos para cada una de estas:

bool isAuthenticated()
bool doLogin($username,$password)
doLogout()

La clase usará un objeto PDO proporcionado en el constructor por el cliente del objeto, o bien intentará crear uno con las constantes de clases predefinidas.

Definido esto pasamos a la implementación propiamente dicha de la clase:

<?php
/*
 * UserAuthentication:
 *
 */


class UserAuthentication
{

  private $_session_namespace = "sistema_usuario"; /* Nombre de
                                                      espacio para no
                                                      ensuciar en
                                                      cualquier lugar
                                                      el super arreglo
                                                      de $_SESSION */

  private $_user_table = "usuarios"; /* Nombre de la tabla de usuarios */

  private $_db;

  /* Constantes de clase para crear una conexión por defecto */
  const default_db_user = 'root';
  const default_db_pass = 'root';
  const default_db_name = 'ejemplo';
  const default_db_host = 'localhost';

  /*
   * Debe recibir una conexión PDO válida o intentará crear una.
   */
  public function __construct($pdoConnection = NULL)
  {
    if(!$pdoConnection)
      $pdoConnection = $this->getConnection();
    $this->_db = $pdoConnection;
  }

  /*
   * Crea una conexión PDO con los datos por default definidos como
   * constantes de clase.
   */
  private function getConnection()
  {
    $dsn = 'mysql:dbname='.self::default_db_name.';host='.self::default_db_host;
    try {
      $dbh = new PDO($dsn, self::default_db_user, self::default_db_pass);
    } catch (PDOException $e) {
      die( 'Connection failed: ' . $e->getMessage() );
    }
    return $dbh;
  }
  
  /*
   * Responde si el usuario activo está autenticado en sesión.
   */
  public function isAuthenticated()
  {
    return $this->getSession('user_authenticated') === true;
  }
  /*
   * Realiza un Login y guarda los datos en sesión.
   */
  public function doLogin($username,$password)
  {
    $result = $this->checkLoginInDB($username,$password);
    if(!$result) {
      $this->doLogout();
      return false;
    }

    $this->setSession('user_authenticated',true);
    $this->setSession('username',$result['username']);
    $this->setSession('id',$result['id']);

    return true;
  }

  /*
   * Quita al usuario de sesión.
   */
  public function doLogout()
  {
    $this->destroySession();
  }

  /*
   * Verifica si el usuario está en la base de datos.
   */
  private function checkLoginInDB($username,$password)
  {
    try {
      $query = 'SELECT id, username FROM '. $this->_user_table . ' WHERE ';
      $query .= ' username = ? AND password = ? ';
      $sth = $this->_db->prepare($query);
      $sth->execute(array($username,$this->encryptPassword($password)));
      return $sth->fetch(PDO::FETCH_ASSOC);
    } catch (PDOException $e) {
      die( 'Query failed: ' . $e->getMessage() );
    }
  }

  /*
   * Encripta un password en texto plano.
   */
  private function encryptPassword($password)
  {
    return sha1($password);
  }
  
  private function getSession($key)
  {
    $session = $_SESSION[$this->_session_namespace];
    if(isset($session[$key]))
      return $session[$key];
    return null;
  }
  private function setSession($key,$val)
  {
    return $_SESSION[$this->_session_namespace][$key] = $val;
  }
  private function destroySession()
  {
    $_SESSION[$this->_session_namespace] = null;
    unset($_SESSION[$this->_session_namespace]);
  }

}

Asegurando páginas

Ahora sólo nos queda asegurar páginas valiendonos de la clase UserAuthentication. Para esto vamos a guiarnos por el diagrama de flujo antes mostrado.

Entonces suponiendo que queremos asegurar una página galeria.php usamos el siguiente código:

<?php
require_once('UserAuthentication.class.php');  
// utilizamos conexion por defecto.
$userAuthentication = new UserAuthentication();

if(!$userAuthentication->isAuthenticated()) {
  // el usuario no está autenticado requiere login.
  header( "Location: /login/login.php?uri=". base64_encode($_SERVER["REQUEST_URI"]));
}
// contenido seguro
?>
<html>
  <head>
  <title>Pagina segura</title>
  </head>
  <body>Contenido seguro
  <a href="http://localhost/login/logout.php">Cerrar sesion</a>
  </body>
</html>

El archivo login.php es el formulario que se encargará de autenticar, también valiéndose de la clase UserAuthentication:

<?php
require_once('UserAuthentication.class.php');  
if(isset($_POST['username']) && $_POST['password']) {
  $username = $_POST['username'];
  $password = $_POST['password'];
  $uri = isset($_POST['uri']) && !empty($_POST['uri']) ? base64_decode($_POST['uri']) : '/';
  $userAuthentication = new UserAuthentication();
  if($userAuthentication->doLogin($username,$password)) {
    header("Location: ". $uri);
  } else {
    $msg_error = 'Usuario o password invalidos';
  }
}
?><html>
  <head>
  <title>Login</title>
  </head>
  <body>
    <?php if(isset($msg_error)): ?>
       <p style="color: red;"><?php echo $msg_error ?></p>
    <?php endif; ?>
    <form method="post" action="login.php">
      Usuario: <input type="text" name="username" /><br />
      Password: <input type="password" name="password" />
      <input name="uri" type="hidden" value="<?php echo isset($_GET['uri']) ? $_GET['uri'] : ''  ?>" /><br />
      <input type="submit" />
    </form>
  </body>
</html>

Por último el script logout.php se encargará de de destruir la sessión.

<?php
require_once('UserAuthentication.class.php');  
$userAuthentication = new UserAuthentication();
$userAuthentication->doLogout();
?>
<html>
  <head>
    <title>Logout</title>
  </head>
    <body>
      Sesion cerrada
    </body>
</html>

Review de Emacs

2009-02-10T21:36:00.001-02:00

En el sitio argentino Taringa publican una buena review de Emacs desde la perspectiva de un programador.

Valores por defecto en java

2008-06-26T13:14:00.002-03:00

Cuando se crea un objeto de una clase que posee miembros sin inicializar Java utilizará un valor por defecto para los miembros. El siguiente ejemplo ilustra la situación al crear una objeto de la clase Valores, e imprimir uno a uno sus miembros:


class Valores {
  boolean b;
  char c;
  byte by;
  short s;
  int i;
  long l;
  float f;
  double d;
}


class defecto {
  private static void log(String s)
  {
    System.out.println(s);
  }
  public static void main(String [] args)
  {
    Valores objeto = new Valores();
    log(" Valor por defecto de boolean = " + objeto.b   );
    log(" Valor por defecto de char    = " + objeto.c   );
    log(" Valor por defecto de byte    = " + objeto.by  );
    log(" Valor por defecto de short   = " + objeto.s   );
    log(" Valor por defecto de int     = " + objeto.i   );
    log(" Valor por defecto de long    = " + objeto.l   );
    log(" Valor por defecto de float   = " + objeto.f   );
    log(" Valor por defecto de double  = " + objeto.d   );
  } 
}

Cálculo de raíces cuadradas en java

2008-06-26T13:09:00.003-03:00

El siguiente ejemplo muestra como hacer uso de java.lang.Math para el cálculo de raíces cuadradas.

class raices {
  private static void log(String s)
  {
    System.out.println(s);
  }
  public static void main (String [] args)  
  {
    // sqrt(x) devuelve la raíz cuadrada.
    for (int i=0; i < 10; i++) {
      log("La raíz cuadrada de " + i + " es " + Math.sqrt(i));
   }
  }
}

La salida generada es:

La raíz cuadrada de 0 es 0.0
La raíz cuadrada de 1 es 1.0
La raíz cuadrada de 2 es 1.4142135623730951
La raíz cuadrada de 3 es 1.7320508075688772
La raíz cuadrada de 4 es 2.0
La raíz cuadrada de 5 es 2.23606797749979
La raíz cuadrada de 6 es 2.449489742783178
La raíz cuadrada de 7 es 2.6457513110645907
La raíz cuadrada de 8 es 2.8284271247461903
La raíz cuadrada de 9 es 3.0

Implementación de strend en C

2008-06-26T11:46:00.002-03:00

/* strend1(s,t) devuelve 1 si la cadena t 
se presenta al final de la cadena s 
y 0 en caso contrario */ 
#include <stdio.h>
int strend1(const char *s , const char *t){
  const char *ini; 
  ini = t;
  while(*s)
    ++s;
  while(*t)
    ++t;
  while(*s-- == *t--)
    if (t+1 == ini)
      return 0;
  return 1;
}


/* Probamos la función */ 
int main(){
  char  cadena1[100] = "hola que tal  estas? como estas?";
  char  cadena2[50] = "estas?";
  if (strend1(cadena1,cadena2))
    printf("Cadena1 no contiene a cadena2\n");
  else
    printf("CADENA1 CONTIENE A CADENA2\n");
  return 0;
}

link - Some emacs tricks

2008-05-27T11:03:00.000-03:00

Some emacs tricks

Flisol en facultad de Palermo

2008-04-23T22:54:00.002-03:00

Este sábado 26 de abril se realiza la Flisol (Festival Latinoaméricano de Instalación de Software Libre) en la facultad de palermo. Desde CaFeLUG se está organizando el evento. Hay registración obligatoria por lo que antes de ir hagan una visita al sitio. Enlace

My Wall Street Journal

2008-04-14T17:46:00.002-03:00

Así se llama la nueva publicación estado unidense que pretende ser una sátira del prestigioso y tradicional. Se puede ver la tapa y comprar un ejemplar en Amazon.

Calculadora con notación polaca inversa en C

2008-04-14T12:20:00.000-03:00

El siguiente programa es la implementación en C de una calculadora que funciona con notación polaca inversa. El programa es harto conocido porque figura en el libro de facto de C de Kernighan y Ritchie.

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#define MAXOP 100
#define NUMBER '0' /* señal se encontró un número */

int getop(char []);
void push(double);
double pop(void);

int main()
{
  int type;
  double op2;
  char s[MAXOP];
  while((type = getop(s)) != EOF) {
    switch(type) {
    case NUMBER:
      printf("NUMBER: %s\n",s);
      push(atof(s));
      break;
    case '+':
      push(pop() + pop());
      break;
    case '*':
      push(pop() * pop());
      break;
    case '-':
      op2 = pop();
      push(pop() - op2);
      break;
    case '/':
      op2 = pop();
      if (op2 != 0.0)
        push(pop() / pop());
      else
        printf("error: divisor 0\n");
      break;
    case '\n':
      printf("\t%.8g\n",pop());
      break;
    default:
      break;
        
    }
  }
  return 0;
}


#define MAXVAL 100
int sp = 0;
double val[MAXVAL];

void push(double f)
{
  printf("push numero: %f en indice: %d\n",f,sp);
  if (sp < MAXVAL)
    val[sp++] = f;
  else 
    printf("error: pila llena\n");
}

double pop(void) 
{
  if (sp > 0) {
    printf("pop %f en indice: %d\n",val[sp],sp);
    return val[--sp];
  }
  else {
    printf("error: pila vacia\n");
    return 0.0;
  }
}

#include <ctype.h>
int getch(void);
void ungetch(int);

int getop(char s[]) 
{
  int i,c;
  while ((s[0] = c = getch()) == ' ' || c == '\t')
    ;
  s[1] = '\0';

  if (!isdigit(s[0]) && c != '.')
    return c;

  i = 0;
  if (isdigit(c))
    while (isdigit(s[++i] = c = getch()))
      ;
  if (c == '.')
    while(isdigit(s[++i] = c = getch()))
      ;
  s[i] = '\0';
  if (c != EOF)
    ungetch(c);
  return NUMBER;
}


#define BUFSIZE 100
char buf[BUFSIZE];
int bufp = 0;

int getch(void)
{
  return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c)
{
  if (bufp >= BUFSIZE)
    printf("ungetch: demasiados caracteres\n");
  else
    buf[bufp++] = c;
}

Infobae y técnicas de posicionamiento

2008-04-07T12:59:00.002-03:00

En mi nuevo trabajo estamos trabajando con los feeds (RSS) de diarios argentinos. Y desde hace aproximádamente un mes, estamos viendo que Infobae envia feeds con diferentes títulos para la misma nota. Hay veces que llega a enviar hasta 7 títulos para la misma nota a lo largo del día. Si no me equivoco el objetivo es que los agregadores automáticos envien más links con diferentes palabras a las páginas de Infobae. Pero el que la paga es el usuario que ve su lector de feeds infladísimo con entradas que en realidad son duplicadas.

Google debería penalizar esta técnica porque en definitiva baja la calidad del buscador y hay un perjuicio para los usuarios.

Permisos en GNU/Linux

2008-03-16T21:34:00.002-03:00

Un archivo cualquiera de Linux/Unix genera con sus permisos una partición sobre los usuarios, está partición consta de: un usuario dueño del archivo, los usuarios pertenecientes al grupo del archivo y todos los demás usuarios. Esta clasificación se conoce a veces como UGO, por User, Group, Others.

Cuando un archivo se crea, el archivo tiene como dueño al usuario que lo creó y como grupo, el grupo principal al cual pertenece el usuario.

      $whoami
      santi
      $touch f1
      $ls -l f1
      -rw-r--r-- 1 santi staff 0 2008-03-16 19:48 f1

El dueño del archivo f1, es santi, y el archivo pertenece al grupo staff. A cada uno de los tres grupos podemos darle o quitarle permisos de: lectura (r), escritura (w) o ejecución (x). Estos permisos se asignan de manera discreta por lo que necesitamos 9 bits para asignarlos (3 clases de usuarios User, Group, Others, y 3 tipos de permisos Read, Write, eXecution).

      rwx         rwx         rwx
      ---         ---         ---
      Usuario     Grupo       Otros

El sistema octal de bits permite representar los 8 estados que pueden tomar cada una de las clases. Esto se ve en la tabla siguiente:

      Bin  Oct          Permisos
      000  0       ---   Ningún permiso
      001  1       --x   Sólo ejecución
      010  2       -w-   Sólo escritura
      011  3       -wx   Escritura y ejecución
      100  4       r--   Sólo lectura
      101  5       r-x   Lectura y ejecución
      110  6       rw-   Lectura y escritura
      111  7       rwx   Los tres permisos

Por este motivo es común que los permisos se suelan representar como una secuencia de tres números octales que designen los permisos para Usuario, Grupo y Otros.

Algunos ejemplos serían:

      000 Ningún permiso
      444 Lectura para todos.
      400 Lectura sólo para el dueño.
      644 Lectura y escritura para el dueño y sólo lectura a los
          demás.
      777 Todos los permisos a todo el mundo.

Muchas veces la gente no recuerda esa tabla, por lo que se asignan permisos directamente utilizando las clases de usuarios y las letras de los permisos. El comando para la asignación de permisos es chmod:

      $chmod 644 f1
      # Es equivalente a:
      $chmod ugo+r  f1  # lectura para todos
      $chmod go-wx  f1  # quitamos escritura y ejecución
      $chmod u+wr   f1  # escritura y ejecución a dueño
      $ls -l f1
      -rw-r--r-- 1 santi staff 0 2008-03-16 20:19 f1

El comando ls -l que nos mostró los permisos tiene un menos adelante para indicar que es un archivo y no un directorio. En el caso de un directorio tendríamos una d en lugar de un menos:

      $mkdir borrar
      $ls -l | grep borrar
      drwxr-xr-x 2 santi staff 4096 2008-03-16 20:27 borrar

Sticky bit (pegajoso)

Los unix tienen un permiso especial llamado Sticky bit que tenía el propósito de alertar al kernel para que deje el archivo en memoria luego de terminar el programa. Esto era conveniente para archivos utilizados muy frecuentemente, hoy día en casi todos los kernels modernos este permiso ya no hace falta debido a los nuevos sistemas de paginación de memoria que se implementan por lo que el uso del permiso sticky con este fin está obsoleto.

SUID y SGID

SUID y SGID son acrónimos de Set User Id y Set Group Id. Cuando un usuario ejecuta un archivo sin estos permisos, el programa corre con los permisos de ejecución del usuario que lo ejecuta. Es decir que si el usuario no tiene permisos de escribir el directorio /bk/ los programas que ejecute tampoco lo tendrán, a menos que alguno de estos programas tengan permisos SUID o SGID con lo cual el programa corre con los permisos del dueño del archivo o del grupo del archivo.

Programas como ping que requieren permisos de root para ejecutarse por lo que suelen tener este permiso asignado.

      $ls -l /bin/ping
       -rwsr-xr-x 1 root root 30856 2007-07-06 04:40 /bin/ping

Es conveniente verificar nuestro sistema en busca de programas con este tipo de permisos, ya que pueden ser utilizados con fines maliciosos. Es común que un atacante que ganó en algún momento privilegios de root, deje para su uso posterior una copia de un shell como bash con permisos SUID.

Directorios

Para entender el significado de los permisos asignados a los directorios, hay que entender que un directorio es una lista de los archivos que contiene. Es decir que si nosotros tenemos permiso de lectura en ese directorio podremos leer la lista por lo que podremos listar los archivos del directorio. Pero si no tenemos permisos de lectura aún podremos modificar archivos del directorio suponiendo que conozcamos su nombre y tengamos los permisos sobre el archivo para hacerlo.

La misma lógica se sigue con el resto de los permisos, si queremos borrar un archivo de un directorio deberíamos tener permisos para modificar la lista, es decir permisos de escritura en el directorio

 
      $mkdir borrar/
      $touch borrar/archivo
      $chmod u-rw borrar/
      $ls borrar/
      ls: borrar/: Permission denied
      $echo "saludos" > borrar/archivo
      $cat borrar/archivo
      saludos
      $rm borrar/archivo
      rm: cannot remove `borrar/archivo': Permission denied

Pero todavía queda un permiso que no sabemos como actua y es el de ejecución, y si este permiso se quita se prohiben todas las acciones dentro del directorio, sus archivos y subdirectorios. Es decir si quitamos los permisos de ejecución para alguna de las clases, no se podrá hacer a nada dentro del directorio ni siquiera cambiar a él con cd.

      $cd borrar/
      $pwd
      /home/santi/tmp/unix/borrar
      $cd ..
      $chmod u-x borrar/
      $cd borrar
      bash: cd: borrar/: Permission denied

Sony Vaio CR131/E

2008-03-13T21:05:00.004-02:00

Bueno es mi primera notebook y por el momento no me decepcionó. Sistema operativo por defecto el Vista. Nunca lo había usado es lindo, pero después de probar todo el hardware voló. Le puse Ubuntu Gusty, la instalación fue bastante bien, tuve que tocar un par de cosas para hacer funcionar el sonido y no hubo problemas. El Wifi funciona aunque tendría que probar la famosa norma N que mi router no soporta.

Por el momento lo único que no pude hacer arrancar es la cámara, aunque vi que hay un módulo para el kernel que debería funcionar con la mayoría de las cámaras que traen las vaio.

La máquina es hermosa esteticamente, el teclado me encanta, es distinto al de otras notebooks que había probado.

Me tiene un poco preocupado que cuando la utilizo enchufada da unas pequeñas descargas de estática en una parte de la carcaza de metal. Voy a ver si instalo en algún lugar acá un enchufe con descarga a tierra porque tengo miedo de que se dañe algún componente.

Conexiones tiene un montón, salida de de super-video, memmory stick, SD (sí, ahora las vaio traen SD), tres entradas USB y salida para monitor.

En fin, el equipo me encanta. Ya les contaré como se desenvuelve en el tiempo.

Tutorial SDL

2008-03-03T17:12:00.001-02:00

Tutorial de la librería SDL para la programación de juegos

Las ideas, las patentes, las personas y bla!

2008-02-24T18:23:00.001-02:00

Vale la pena que lo lean no el ataque personalizado que hace al monigote de Microsoft sino el porque la supuesta apertura de protocolos de Microsoft no significa más
que una jugada publicitaria con poca incidencia en la industria. Gallí lo explica bien, pero para mi las personas son circunstanciales, acá lo que hay que discutir son las ideas.

Desde emacs II

2008-02-24T07:25:00.006-02:00

Hace poco comenté como postear desde GNU/Emacs con g-client, pero últimamente estoy bastante desde GNUS así que acá va una función para invocar rápidamente un nuevo correo a la dirección secreta de Blogger, con el header Content-type en html.

(defun entrada-codigomaldito ()
  "Inserta una entrada en código maldito"
  (interactive)
   (compose-mail "codigomaldito "
                "Sujeto"
                '(("Content-Type" . "text/html;"))
                nil
                )
   (message-sort-headers)
   )

Chau!

Las raíces de Lisp

2008-02-21T22:21:00.002-02:00

Traducción

El siguiente documento es una traducción bastante libre del documento publicado por Paul Graham en su sitio web [The Roots Of Lisp], es un ensayo sobre los fundamentos del lenguaje de programación Lisp.

Autor: Paul Graham, borrador Enero 18, 2002

En 1960, John McCarthy publicó un notable paper en el cuál, hizo por la programación algo parecido a lo que Euclides hizo por la geometría ^[1]. Mostró de que manera con un puñado de operadores simples y una notación para funciones, se puede construir un lenguaje de programación. Llamó a este lenguaje Lisp, por "List Processing", debido a que una de sus principales ideas era usar una estructura de datos simple llamada list, para el código y los datos.

Vale la pena comprender lo que McCarthy descubrió, no sólo como un hito en la historia de las computadores, sino como un modelo de lo que la programación está tendiendo a convertirse en nuestro propio tiempo. Parece que se han producido dos claros modelos consistentes de programación hasta la fecha: el modelo de C y el modelo de Lisp. Una receta popular para los nuevos lenguajes de programación en los pasados 20 años fue tomar el modelo de C y agregarle, pequeñas partes tomadas del modelo de Lisp, tales como tipado en tiempo de ejecución y recolección de basura.

En este artículo se intentará explicar en los términos más simples posibles lo que McCarthy descubrió. El punto no es sólo aprender acerca de un interesante resultado teórico que alguien averiguó hace cuarenta años, sino mostrar de dónde los lenguajes partieron. La característica inusual de Lisp -en realidad, la definición de la calidad de Lisp- es que puede escribirse a si mismo. Para entender lo que McCarthy quiere decir con esto, vamos a recorrer sus pasos, con su notación matemática traducida en código Common Lisp ejecutable.

1. Siete operadores primitivos

Para empezar, se define una expresión. Una expresión es a la vez un átomo, el cual es una secuencia de letras (e.g. foo), o una lista de cero o más expresiones, separadas por espacios en blanco y encerradas por paréntesis. Algunas expresiones:

      foo
      ()
      (foo)
      (foo bar)
      (a b (c) d)

La última expresión es una lista de cuatro elementos, el tercero de ellos es a su vez una lista de un elemento.

En aritmética la expresión 1 + 1 tiene el valor 2. Las expresiones válidas en Lisp también tienen valores. Si de una expresión e se obtiene el valor v, se dice que e devuelve v. El próximo paso es definir que tipo de expresiones puden existir, y que valor devuelve cada tipo.

Si una expresión es una lista, se llama al primer elemento el operador y a los elementos restantes los argumentos. Se van a definir siete operadores primitivos (en el sentido de axiomas): quote, atom, eq, car, cdr, cons, y cond.

1. (quote x)

(quote x) devuelve x. Por legibilidad abreviamos (quote x) como 'x.

      > (quote a)
      a
      > 'a
      a
      > (quote (a b c))
      (a b c)

Nota traducción: la mayoría de las veces traduciremos quoted, como escapar

2. (atom x)

(atom x) devuelve el átomo t si el valor de x es un átomo o la lista vacía. En Lisp se acostumbra a usar el átomo t para representar verdadero, y la lista vacia para representar falso.

      > (atom 'a)
      t
      > (atom '(a b c))
      ()
      > (atom '())
      t

Ahora que se tiene un operador cuyo argumento es evaluado se puede mostrar para que sirve quote. Escapando una lista con quote evitamos su evaluación. Una lista no escapada dada como argumento a un operador como atom es tratada como código:

      > (atom (atom 'a))
      t

en cualquier lugar en dónde aparezca una lista escapada se trata como una mera lista, en este caso una lista de dos elementos:

      > (atom '(atom 'a))
      ()

Esto es similar a la manera en que se usan las comillas en inglés. Cambridge es una ciudad en Massachusetts que tiene cerca de 90.000 personas. "Cambridge" es una palabra que contiene nueve letras.

Escapar puede parecer un concepto algo lejano, porque muy pocos lenguajes tienen algo como esto. Está muy relacionado a una de las más distintivas características de Lisp: código y datos están hechos de las mismas estructuras de datos, y el operador quote es la manera en que se distingue entre ellos.

3. (eq x y)

(eq x y) devuelve t si los valores de x e y son el mismo átomo, o los dos la lista vacía, y () en cualquier otro caso.

      > (eq 'a 'a)
      t
      > (eq 'a 'b)
      ()
      > (eq '() '())
      t

4. (car x)

(car x) espera que el valor de x sea una lista, y devuelve su primer elemento.

      > (car '(a b c))
      a

5. (cdr x)

(cdr x) espera que el valor de x sea una lista, y devuelve todo lo posterior al primer elemento.

      > (cdr '(a b c))
      (b c)

6. (cons x y)

(cons x y) espera que el valor de y sea una lista, y devuelve el valor de x seguido por los elementos del valor de y.

      > (cons 'a '(b c))
      (a b c)
      > (cons 'a (cons 'b (cons 'c '())))
      (a b c)
      > (car (cons 'a '(b c)))
      a
      > (cdr (cons 'a '(b c)))
      (b c)

7. (cond (p₁ e₁)...(p_n e_n))

(cond (p₁ e₁)...(p_n e_n)) es evaluado de la siguiente manera. La expresiones p son evaluadas en orden hasta que una devuelva t. Cuando una es encontrada, el valor de la expresión e correspondiente es devuelto como el valor de toda la expresión cond.

      > (cond ((eq 'a 'b) 'first)
                 ((atom 'a) 'second))
      second

En cinco de los siete operadores primitivos, los argumentos son siempre evaluados cuando una expresión que comienza con ese operador es evaluada.^[2] Se llama a un operador de ese tipo una función.

2. Denotar funciones

A continuación se define una notación para describir funciones. Una función se expresa como (lambda (p₁...p_n) e), dónde p₁...p_n son átomos (llamados parámetros) y e es una expresión. Una expresión cuyo primer elemento es una expresión

      ((lambda (p₁...p_n) e) a₁...a_n)

es conocida como una llamada de función y su valor es cálculado de la siguiente manera. Cada expresión a_i es evaluada. Luego e es evaluada. Durante la evaluación de e, el valor de cualquier ocurrencia de uno de los p_i , es el valor del correspondiente a_i en la llamada de función más reciente.

      > ((lambda (x) (cons x '(b))) 'a)
      (a b)
      > ((lambda (x y) (cons x (cdr y)))
            'z
            '(a b c))
      (z b c)

Si una expresión tiene como primer elemento un átomo f que no es uno de los operadores primitivos

      (f a₁...a_n)

y el valor de f es una función (lambda (p₁...p_n) e) luego el valor de la expresión es el valor de

      ((lambda (p₁...p_n) e) a₁...a_n)

En otras palabras, los parámetros pueden ser usados tanto como operadores o como argumentos en expresiones:

      > ((lambda (f) (f '(b c))) 
            '(lambda (x) (cons 'a x)))
      (a b c)

Hay otra notación para funciones que permite a la función referirse a sí misma, así se brinda una manera conveniente de definir funciones recursivas.^[3] La notación

      (label f (lambda (p₁...p_n e))

denota una función que se comporta como (lambda (p₁...p_n) e), con la propiedad adicional de que una ocurrencia de f en e evalua a la expresión label, como si f fuese un parametro de la función.

Suponiendo que se quisiera definir una función (subst x y z), la cual toma una expresión x, un átomo y, y una lista z, y devuelve una lista como z pero con cada instancia de y (a cualquier profundidad de anidamiento) en z reemplazada por x.

      > (subst 'm 'b '(a b (a b c) d))
      (a m (a m c) d)

Se puede denotar esta función como

      (label subst (lambda (x y z)
                     (cond ((atom z)
                            (cond ((eq z y) x)
                                  ('t z)))
                           ('t (cons (subst x y (car z))
                                     (subst x y (cdr z)))))))

Se abreviará f = (label f (lambda (p₁...p_n) e)) como

      (defun f (p₁...p_n) e)

así

      (defun subst (x y z)
        (cond ((atom z)
               (cond ((eq z y) x)
                     ('t z)))
              ('t (cons (subst x y (car z))
                        (subst x y (cdr z))))))

A proposito, aquí se ve como conseguir una cláusula por omisión en una expresión cond. Una cláusula cuyo primer elemento es 't será siempre éxitosa. Así

      (cond (x y) ('t z))

es equivalente a lo que tal vez se escribiría en un lenguaje con síntaxis como:

      if x then y else z

3. Algunas funciones

Ahora que se tiene una manera de expresar funciones, se definen algunas nuevas en términos de los siete operadores primitivos. Primero es conveniente introducir algunas abreviaciones de patrones comunes. Se usará el cxr, dónde x es una secuencia de as o ds, como una abreviación para la composición correspondiente de car y cdr. Así, por ejemplo (cadr e) es una abreviación de (car (cdr e)), la cual devuelve el segundo elemento de e.

      > (cadr '((a b) (c d) e))
      (c d)
      > (caddr '((a b) (c d) e))
      e
      > (cdar '((a b) (c d) e))
      (b)

También, se usará (list e₁...e_n para (cons e₁ ... (cons e_n '()) ... ).

      > (cons 'a (cons 'b (cons 'c '())))
      (a b c)
      > (list 'a 'b 'c)
      (a b c)

Ahora se definen algunas funciones nuevas. Se cambiaron los nombres de estas funciones agregando un punto al final. Esto distingue a las funciones primitivas de las definidas en términos de estas, y además evita colisiones con funciones existentes en Common Lisp.

1. (null. x)

(null. x) prueba si su arguemento es la lista vacia.

      (defun null. (x)
        (eq x '()))
      > (null. 'a)
      ()
      > (null. '())
      t

2. (and. x y)

(and. x y) devuelve t si ambos argumentos lo hacen, y () en cualquier otro caso.

      (defun and. (x y)
        (cond (x (cond (y 't) ('t '())))
              ('t '())))
      > (and. (atom 'a) (eq 'a 'a))
      t
      > (and. (atom 'a) (eq 'a 'b))
      ()

3. (not. x)

(not. x) devuelve t si su argumento devuelve (), y () si su argumento devuelve t.

      (defun not. (x)
        (cond (x '())
              ('t 't)))
      > (not. (eq 'a 'a))
      ()
      > (not. (eq 'a 'b))
      t

4. (append. x y)

(append. x y) toma dos listas y devuelve la concatenación de estas.

      (defun append. (x y)
        (cond ((null. x) y)
              ('t (cons (car x) (append. (cdr x) y)))))
      > (append. '(a b) '(c d))
      (a b c d)
      > (append. '() '(c d))
      (c d)

5. (pair. x y)

(pair. x y) toma dos listas de igual longitud y devuelve una lista de listas de dos elementos conteniendo pares sucesivos de un elemento de cada una.

      (defun pair. (x y)
        (cond ((and. (null. x) (null. y)) '())
              ((and. (not. (atom x)) (not. (atom y)))
               (cons (list (car x) (car y))
                     (pair. (cdr x) (cdr y))))))
      > (pair. '(x y z) '(a b c))
      ((x a) (y b) (z c))

6. (assoc. x y)

(assoc. x y) toma un átomo x y una lista y de la forma creada por pair., y devuelve el segundo elemento de la primera lista en y cuyo primer elemento es x.

      (defun assoc. (x y)
        (cond ((eq (caar y) x) (cadar y))
              ('t (assoc. x (cdr y)))))
      > (assoc. 'x '((x a) (y b)))
      a
      > (assoc. 'x '((x new) (x a) (y b)))
      new

4. La sorpresa

Así, se pudo definir funciones que concatenan listas, sustituyen una expresión por otra, etc. Una notación elegante, tal vez, pero. ¿Ahora qué? Ahora viene la sorpresa. Se puede también, es resultado de, escribir una función que actue como un interprete para nuestro lengauje: una función que tome como un argumento cualquier expresión Lisp, y devuelva su valor. Aquí está:

      (defun eval. (e a)
        (cond 
          ((atom e) (assoc. e a))
          ((atom (car e))
           (cond 
             ((eq (car e) 'quote) (cadr e))
             ((eq (car e) 'atom)  (atom (eval. (cadr  e) a)))
             ((eq (car e) 'eq)    (eq   (eval. (cadr  e) a)
            (eval. (cadr  e) a)))
             ((eq (car e) 'car)   (car  (eval. (cadr  e) a)))
             ((eq (car e) 'cdr)   (cdr  (eval. (cadr  e) a)))
             ((eq (car e) 'cons)  (cons (eval. (cadr  e) a)
            (eval. (caddr e) a)))
             ((eq (car e) 'cond) (evcon. (cdr e) a))
             ('t (eval. (cons (assoc. (car e) a)
         (cdr e))
          a))))
          ((eq (caar e) 'label)
           (eval. (cons (caddar e) (cdr e))
           (cons (list (cadar e) (car e)) a)))
          ((eq (caar e) 'lambda)
           (eval. (caddar e)
           (append. (pair. (cadar e) (evlis. (cdr e) a))
             a)))))
      
      (defun evcon. (c a)
        (cond ((eval. (caar c) a)
        (eval. (cadar c) a))
       ('t (evcon. (cdr c) a))))
      
      (defun evlis. (m a)
        (cond ((null. m) '())
       ('t (cons (eval. (car m) a)
          (evlis. (cdr m) a)))))

La definición de eval. es más larga que cualquiera de las otras vistas anteriormente. Vamos a considerar como trabaja cada parte.

La función toma dos argumentos: e, la expresión a ser evaluada, y a, una lista que representa los valores que los átomos fueron tomanado al aparecer como parámetros en las llamadas de función. Esta lista es llamada entorno, y es de la forma creada por pair.. ~~Su fin es construir y buscar en las listas que se escribieron para pair. y assoc.~~It was in order to build and search these lists that we wrote pair. and assoc.

La columna de eval. es una expresión cond con cuatro cláusulas. Como se evalua una expresión depende del tipo que sea. La primer cláusula evalua átomos. Si e es un átomo, se busca su valor en el entorno:

      > (eval. 'x '((x a) (y b)))
      a

La segunda cláusula de eval. es otra cond para el manejo de expresiones de la forma (a ...), dónde a es un átomo. Esto incluye todos los usos de los operadores primitivos, y existe una cláusula para cada uno.

      > (eval. '(eq 'a 'a) '())
      t
      > (eval. '(cons x '(b c))
                  '((x a) (y b)))
      (a b c)

Todos ellos (excepto quote) llaman a eval. para encontrar el valor de sus argumentos.

Las dos últimas cláusulas son más complicadas. Para evaluar una expresión cond llamamos a una función auxiliar llamada evcond., la cual trabaja a su manera a través de las cláusulas recursivamente, buscando una en la cual el primer elemento devuelva t. Cuando encuentra dicha cláusula devuelve el valor del segundo elemento.

      > (eval. '(cond ((atom x) 'atom)
                         ('t 'list))
                  '((x '(a b))))
      list

La parte final de la segunda cláusula de eval.. Maneja llamadas a funciones que han sido pasadas como parametros. Trabaja reemplazando el átomo con su valor (que debería ser una expresión lambda o label) y evaluando la expresión resultante. Así

       (eval. '(f '(b c))
              '((f (lambda (x) (cons 'a x)))))

se convierte en

      (eval. '((lambda (x) (cons 'a x)) '(b c))
             '((f (lambda (x) (cons 'a x)))))

que devuelve (a b c).

Las dos últimas cláusulas en eval. manejan llamadas a funciones en las cuales el primer argumento es una expresión lambda o label. Una expresión label es evaluada empujando la lista del nombre de la función y la función en si misma dentro del entorno, y luego llamando a eval. en una expresión con el lambda interior sustituido por la expresión label. Esto es,

      (eval. '((label firstatom (lambda (x)
                                  (cond ((atom x) x)
                                        ('t (firstatom (car x))))))
               y)
             '((y ((a b) (c d)))))

que se convierte en

      (eval. '((lambda (x) 
           (cond ((atom x) x)
                 ('t (firstatom (car x)))))
         y)
       '((firstatom 
          (label firstatom (lambda (x)
                             (cond ((atom x) x)
                                   ('t (firstatom (car x)))))))
         (y ((a b) (c d)))))

la cual termina por devolver a.

Finalmente una expresión de la forma ((lambda (p₁...p_n) e) a₁...a_n) es evaluada llamando primero a evlist. para obtener una lista de valores (v₁ ... v_n) de los argumentos a₁ ... a_n, y luego evaluando e con (p₁ v₁) ... (p_n v_n) agregado al frente del entorno. Así

      (eval. '((lambda (x y) (cons x (cdr y)))
               'a
               '(b c d))
             '())

se convierte en

      (eval. '(cons x (cdr y))
             '((x a) (y (b c d))))

que termina devolviendo (a c d).

5. Consecuencias

Ahora que se entiende como eval trabaja, volvamos un paso atras y consideremos lo que significa. Lo que se tiene aquí es un extraordinariamente elegante modelo de computación. Usando sólo quote, atom, eq, car, cdr, cons, y cons, se pudo definir una función, eval., que en realidad implementa nuestro propio lenguaje, y luego usándo se puede definir cualquier función adicional que se quiera.

Por supuesto que ya existen modelos de computación-el más notable es la máquina de Turing. Pero los programas de la máquina de Turing no son demasiado ~~fáciles~~ edifying de leer. Si se quiere un lenguaje para describir algoritmos, se debe desear algo más abstracto, y ese fue uno de los objetivos de McCarthy al definir Lisp.

Al lenguaje que él definió en 1960 le faltaba un monton. No tenía ~~efectos laterales~~ side-effects, ejecución secuencial (la cual sólo es útil con efectos laterales), no tenía números prácticos^[4] y alcance dinámico. Pero estas limitaciones pueden ser remediadas, sorprendentemente con muy código adicional. Steele y Sussman muestran como hacerlo en un famoso paper llamado "The Art of the Interpreter"^[5].

Si se entiende la función eval de McCarthy, se entiende más que sólo un estadío en la historia de los lenguajes. Estas ideas están aún presentes en el núcleo semántico de Lisp en la actualidad. Así que estudiando el paper original de McCarthy nos muestra, en un sentido, lo que Lisp realmente es. No es tanto algo que McCarthy diseño sino algo que descubrió. No es intrínsicamente un lenguaje para AI o para realizar prototipos rápidos, o cualquier otra tarea de ese nivel. Es lo que obtienes (o una de las cosas que obtienes) cuando intentas ~~axiomatizar la computación~~ axiomatize computation.

En el tiempo, el lenguaje medio, queriendo decir el lenguaje utilizado por el programador medio, ha ido acercándose considerablemente a Lisp. Así que entiendiendo eval estarás entendiendo lo que probablemente sea el principal modelo computacional en el futuro.

1 Recursive functions of symbolic expressions and their computation by machine (Part I) Communications of the ACM in April 1960. (El paper original) Volver

2 Las expresiones que comienzan con los otros dos operadores, quote and cond, son evaluadas de manera diferente. Cuando una expresión es escapada su argumento no es evaluado, es simplemente devuelto como el valor de toda la expresión escapada. Y en una expresión cond válida, sólo un camino con forma de L de subexpresiones será evaluado. Volver

3 Lógicamente no se necesita definir una nueva notación para esto. Se puede definir funciones recursivamente con la notación que se tiene hasta el momento usando una función en funciones llamada Y combinator. Puede que McCarthy no supiese acerca del Y combinator cuando escribió su paper, en cualquier caso la notación con etiqueta (labe) es más leíble. Volver

4 Es posible realizar aritmética en el Lisp de McCarthy de 1960 utilizando una lista de n átomos para representar el número n. Volver

5 Guy Lewis Steele, Jr. y Gerald Jay Sussman, "The Art of the interpreter, or the Modularity Complex (Part Zero, One, and Two)," MIT AI Lab Memo 453, Mayo de 1978. Volver

pequeña nota mental

2008-02-21T17:06:00.005-02:00

Acordarse para mañanaa de memorizar esto:

##################################################              ##################################################              
#              ECB keystrokes.                   #              #              GNUS keystrokes.                  #              
##################################################              ################################################## 
C-c . ,         ecb-cycle-maximized-ecb-buffers                 C-d             gnus-summary-enter-digest-group                 
C-c . .         ecb-cycle-through-compilation-buffers           C-k             gnus-summary-kill-same-subject                  
C-c . /         ecb-toggle-compile-window-height                C-l             gnus-recenter                                   
C-c . \         ecb-toggle-compile-window                       RET             gnus-summary-scroll-up                          
C-c . a         ecb-toggle-auto-expand-tag-tree                 C-o             gnus-summary-save-article-mail                  
C-c . e         eshell                                          C-t             gnus-summary-toggle-truncation                  
C-c . f         Prefix Command                                  C-w             gnus-summary-mark-region-as-read                
C-c . g         Prefix Command                                  C-x             Prefix Command                                  
C-c . h         ecb-show-help                                   ESC             Prefix Command                                  
C-c . l         Prefix Command                                  SPC             gnus-summary-next-page                          
C-c . m         Prefix Command                                  !               gnus-summary-tick-article-forward               
C-c . n         ecb-nav-goto-next                               #               gnus-summary-mark-as-processable                
C-c . o         ecb-toggle-scroll-other-window-scrolls-compile  &               gnus-summary-execute-command                    
C-c . p         ecb-nav-goto-previous                           *               gnus-cache-enter-article                        
C-c . r         ecb-rebuild-methods-buffer                      ,               gnus-summary-best-unread-article                
C-c . s         ecb-window-sync                                 -               negative-argument                               
C-c . x         ecb-expand-methods-nodes                        .               gnus-summary-first-unread-article               
                                                                /               gnus-summary-limit-map                          
C-c . m a       ecb-maximize-window-analyse                     0 .. 9          digit-argument                                  
C-c . m b       ecb-maximize-window-speedbar                    <               gnus-summary-beginning-of-article               
C-c . m d       ecb-maximize-window-directories                 =               gnus-summary-expand-window                      
C-c . m h       ecb-maximize-window-history                     >               gnus-summary-end-of-article                     
C-c . m m       ecb-maximize-window-methods                     ?               gnus-summary-mark-as-dormant                    
C-c . m s       ecb-maximize-window-sources                     A               gnus-summary-article-map                        
                                                                B               gnus-summary-backend-map                        
C-c . g 1       ecb-goto-window-edit1                           C               gnus-summary-cancel-article                     
C-c . g 2       ecb-goto-window-edit2                           D               gnus-summary-mark-as-read-backward              
C-c . g a       ecb-goto-window-analyse                         E               gnus-summary-mark-as-expirable                  
C-c . g b       ecb-goto-window-speedbar                        F               gnus-summary-followup-with-original             
C-c . g c       ecb-goto-window-compilation                     G               gnus-summary-goto-map                           
C-c . g d       ecb-goto-window-directories                     H               gnus-summary-help-map                           
C-c . g h       ecb-goto-window-history                         I               gnus-summary-increase-score                     
C-c . g l       ecb-goto-window-edit-last                       K               gnus-summary-mime-map                           
C-c . g m       ecb-goto-window-methods                         L               gnus-summary-lower-score                        
C-c . g s       ecb-goto-window-sources                         M               gnus-summary-mark-map                           
                                                                N               gnus-summary-next-article                       
C-c . l c       ecb-change-layout                               O               gnus-summary-save-map                           
C-c . l r       ecb-redraw-layout                               P               gnus-summary-prev-article                       
C-c . l t       ecb-toggle-layout                               Q               gnus-summary-exit-no-update                     
C-c . l w       ecb-toggle-ecb-windows                          R               gnus-summary-reply-with-original                
                                                                S               gnus-summary-send-map                           
C-c . f c       ecb-methods-filter-current-type                 T               gnus-summary-thread-map                         
C-c . f f       ecb-methods-filter-function                     U               gnus-summary-tick-article-backward              
C-c . f h       ecb-history-filter                              V               gnus-summary-score-map             
C-c . f l       ecb-methods-filter-delete-last                  W               gnus-summary-wash-map              
C-c . f m       ecb-methods-filter                              X               gnus-uu-extract-map                
C-c . f n       ecb-methods-filter-nofilter                     Y               gnus-summary-buffer-map            
C-c . f p       ecb-methods-filter-protection                   Z               gnus-summary-exit-map              
C-c . f r       ecb-methods-filter-regexp                       ^               gnus-summary-refer-parent-article  
C-c . f s       ecb-sources-filter                              a               gnus-summary-post-news             
C-c . f t       ecb-methods-filter-tagclass                     b               gnus-article-view-part


##################################################              ##################################################
#              GNUS keystrokes.                  #              #              GNUS keystrokes.                  #
##################################################              ##################################################
c               gnus-summary-catchup-and-exit                   T u             gnus-summary-up-thread                           
d               gnus-summary-mark-as-read-forward                                                                                
e               gnus-summary-edit-article                       V C             gnus-score-customize                             
f               gnus-summary-followup                           V F             gnus-score-flush-cache                           
g               gnus-summary-show-article                       V R             gnus-summary-rescore                             
h               gnus-summary-select-article-buffer              V S             gnus-summary-current-score                       
i               gnus-summary-news-other-window                  V c             gnus-score-change-score-file                     
j               gnus-summary-goto-article                       V e             gnus-score-edit-current-scores                   
k               gnus-summary-kill-same-subject-and-select       V f             gnus-score-edit-file                             
l               gnus-summary-goto-last-article                  V m             gnus-score-set-mark-below                        
m               gnus-summary-mail-other-window                  V s             gnus-summary-set-score                           
n               gnus-summary-next-unread-article                V t             gnus-score-find-trace                            
o               gnus-summary-save-article                       V w             gnus-score-find-favourite-words                  
p               gnus-summary-prev-unread-article                V x             gnus-score-set-expunge-below                     
q               gnus-summary-exit                                                                                                
r               gnus-summary-reply                              W 6             gnus-article-de-base64-unreadable                
s               gnus-summary-isearch-article                    W B             gnus-article-add-buttons-to-head                 
t               gnus-summary-toggle-header                      W C             gnus-article-capitalize-sentences                
u               gnus-summary-tick-article-forward               W D             gnus-summary-wash-display-map                    
w               gnus-summary-stop-page-breaking                 W E             gnus-summary-wash-empty-map                      
x               gnus-summary-limit-to-unread                    W G             gnus-summary-wash-header-map                     
|               gnus-summary-pipe-output                        W H             gnus-summary-wash-highlight-map                  
DEL             gnus-summary-prev-page                          W M             gnus-summary-wash-mime-map                       
                                                                W Q             gnus-article-fill-long-lines                     
        gnus-summary-next-thread                        W T             gnus-summary-wash-time-map                       
          gnus-summary-prev-thread                        W W             gnus-summary-wash-hide-map                       
     gnus-summary-prev-page                          W Y             gnus-summary-wash-deuglify-map                   
        gnus-summary-prev-page                          W Z             gnus-article-decode-HZ                           
   mouse-face                                      W a             gnus-article-strip-headers-in-body               
       gnus-mouse-pick-article                         W b             gnus-article-add-buttons                         
         Prefix Command                                  W c             gnus-article-remove-cr                           
                                                                W d             gnus-article-treat-dumbquotes                    
C-c C-b         gnus-bug                                        W e             gnus-article-emphasize                           
C-c C-d         gnus-summary-describe-group                     W f             gnus-article-display-x-face                      
C-c C-f         gnus-summary-mail-forward                       W g             gnus-treat-smiley                                
C-c TAB         gnus-info-find-node                             W h             gnus-article-wash-html                           
C-c C-r         gnus-summary-caesar-message                     W l             gnus-summary-stop-page-breaking                  
C-c C-s         Prefix Command                                  W m             gnus-summary-morse-message                       
C-c C-v         Prefix Command                                  W o             gnus-article-treat-overstrike                    
C-c ESC         Prefix Command                                  W p             gnus-article-verify-x-pgp-sig                    
                                                                W q             gnus-article-de-quoted-unreadable                
C-x C-s         gnus-summary-reselect-current-group             W r             gnus-summary-caesar-message                      
                                                                W s             gnus-summary-force-verify-and-decrypt            
C-M-a           gnus-summary-customize-parameters               W t             gnus-summary-toggle-header                       
C-M-b           gnus-summary-prev-thread                        W u             gnus-article-unsplit-urls                        
C-M-d           gnus-summary-read-document                      W v             gnus-summary-verbose-headers                     
C-M-e           gnus-summary-edit-parameters                    W w             gnus-article-fill-cited-article                  
C-M-f           gnus-summary-next-thread                                                                                         
C-M-h           gnus-summary-hide-thread                        X B             gnus-uu-decode-binhex                            
C-M-k           gnus-summary-kill-thread                        X O             gnus-uu-decode-save                              
C-M-l           gnus-summary-lower-thread                       X P             gnus-uu-decode-postscript-and-save               
M-RET           gnus-summary-scroll-down                        X S             gnus-uu-decode-unshar-and-save                   
C-M-n           gnus-summary-next-same-subject                  X U             gnus-uu-decode-uu-and-save                       
C-M-p           gnus-summary-prev-same-subject                  X b             gnus-uu-decode-binhex                            
C-M-s           gnus-summary-show-thread                        X m             gnus-summary-save-parts                          
C-M-t           gnus-summary-toggle-threads                     X o             gnus-uu-decode-save                              
C-M-u           gnus-summary-up-thread                          X p             gnus-uu-decode-postscript                        
M-#             gnus-summary-unmark-as-processable              X s             gnus-uu-decode-unshar                            
M-&             gnus-summary-universal-argument                 X u             gnus-uu-decode-uu                                
M-*             gnus-cache-remove-article                       X v             gnus-uu-extract-view-map                         
M-K             gnus-summary-edit-global-kill                                                                                    
M-U             gnus-summary-clear-mark-backward                Y c             gnus-summary-insert-cached-articles              
M-^             gnus-summary-refer-article                      Y d             gnus-summary-insert-dormant-articles             
M-g             gnus-summary-rescan-group                       Y g             gnus-summary-prepare                             
M-i             gnus-symbolic-argument                                                                                           
M-k             gnus-summary-edit-local-kill                    Z C             gnus-summary-catchup-all-and-exit                
M-n             gnus-summary-next-unread-subject                Z E             gnus-summary-exit-no-update                      
M-p             gnus-summary-prev-unread-subject                Z G             gnus-summary-rescan-group                        
M-r             gnus-summary-search-article-backward            Z N             gnus-summary-next-group                          
M-s             gnus-summary-search-article-forward             Z P             gnus-summary-prev-group                          
M-t             gnus-summary-toggle-display-buttonized          Z Q             gnus-summary-exit                                
M-u             gnus-summary-clear-mark-forward                 Z R             gnus-summary-reselect-current-group              
                                                                Z Z             gnus-summary-exit                                
/ *             gnus-summary-limit-include-cached               Z c             gnus-summary-catchup-and-exit                    
/ .             gnus-summary-limit-to-unseen                    Z n             gnus-summary-catchup-and-goto-next-group         
/ /             gnus-summary-limit-to-subject                   Z s             gnus-summary-save-newsrc                         
/ C             gnus-summary-limit-mark-excluded-as-read                                                                         
/ D             gnus-summary-limit-include-dormant              C-c C-v C-v     gnus-uu-decode-uu-view                           
/ E             gnus-summary-limit-include-expunged                                                                              
/ M             gnus-summary-limit-exclude-marks                C-c C-s C-a     gnus-summary-sort-by-author                      
/ N             gnus-summary-insert-new-articles                C-c C-s C-c     gnus-summary-sort-by-chars                       
/ T             gnus-summary-limit-include-thread               C-c C-s C-d     gnus-summary-sort-by-date                        
/ a             gnus-summary-limit-to-author                    C-c C-s TAB     gnus-summary-sort-by-score                       
/ c             gnus-summary-limit-exclude-childless-dormant    C-c C-s C-l     gnus-summary-sort-by-lines                       
/ d             gnus-summary-limit-exclude-dormant              C-c C-s C-n     gnus-summary-sort-by-number                      
/ m             gnus-summary-limit-to-marks                     C-c C-s C-o     gnus-summary-sort-by-original                    
/ n             gnus-summary-limit-to-articles                  C-c C-s C-r     gnus-summary-sort-by-random                      
/ o             gnus-summary-insert-old-articles                C-c C-s C-s     gnus-summary-sort-by-subject                     
/ p             gnus-summary-limit-to-display-predicate                                                                          
/ s             gnus-summary-limit-to-subject                   C-c C-M-s       gnus-summary-limit-include-expunged              
/ t             gnus-summary-limit-to-age                                                                                        
/ u             gnus-summary-limit-to-unread                    A M-RET         gnus-summary-scroll-down                         
/ v             gnus-summary-limit-to-score                                                                                      
/ w             gnus-summary-pop-limit                          B C-M-e         gnus-summary-expire-articles-now                 
/ x             gnus-summary-limit-to-extra                                                                                      
                                                                G M-n           gnus-summary-next-unread-subject                 
A RET           gnus-summary-scroll-up                          G M-p           gnus-summary-prev-unread-subject                 
A ESC           Prefix Command                                                                                                   
A SPC           gnus-summary-next-page                          M M !           Prefix Command                                   
A <             gnus-summary-beginning-of-article               M M ?           Prefix Command                                   
A >             gnus-summary-end-of-article                     M M d           Prefix Command                                   
A D             gnus-summary-enter-digest-group                 M M e           Prefix Command                                   
A M             gnus-mailing-list-insinuate                     M M u           Prefix Command                                   
A P             gnus-summary-print-article                                                                                       
A R             gnus-summary-refer-references                   M V c           gnus-summary-clear-above                         
A T             gnus-summary-refer-thread                       M V k           gnus-summary-kill-below                          
A ^             gnus-summary-refer-parent-article               M V m           gnus-summary-mark-above                          
A b             gnus-summary-beginning-of-article               M V u           gnus-summary-tick-above                          
A e             gnus-summary-end-of-article                                                                                      
A g             gnus-summary-show-article                       M P G           gnus-uu-unmark-by-regexp                         
A n             gnus-summary-next-page                          M P R           gnus-uu-mark-by-regexp                           
A p             gnus-summary-prev-page                          M P S           gnus-uu-mark-sparse                              
A r             gnus-summary-refer-parent-article               M P T           gnus-uu-unmark-thread                            
A s             gnus-summary-isearch-article                    M P U           gnus-summary-unmark-all-processable              
A t             gnus-article-babel                              M P a           gnus-uu-mark-all                                 
A DEL           gnus-summary-prev-page                          M P b           gnus-uu-mark-buffer                              
A       gnus-summary-prev-page                          M P g           gnus-uu-unmark-region                            
                                                                M P i           gnus-uu-invert-processable                       
B ESC           Prefix Command                                  M P k           gnus-summary-kill-process-mark                   
B B             gnus-summary-crosspost-article                  M P p           gnus-summary-mark-as-processable                 
B I             gnus-summary-create-article                     M P r           gnus-uu-mark-region                              
B c             gnus-summary-copy-article                       M P s           gnus-uu-mark-series                              
B e             gnus-summary-expire-articles                    M P t           gnus-uu-mark-thread                              
B i             gnus-summary-import-article                     M P u           gnus-summary-unmark-as-processable               
B m             gnus-summary-move-article                       M P v           gnus-uu-mark-over                                
B p             gnus-summary-article-posted-p                   M P w           gnus-summary-save-process-mark                   
B q             gnus-summary-respool-query                      M P y           gnus-summary-yank-process-mark                   
B r             gnus-summary-respool-article                                                                                     
B t             gnus-summary-respool-trace                      M M-#           gnus-summary-unmark-as-processable               
B w             gnus-summary-edit-article                                                                                        
B DEL           gnus-summary-delete-article                     S D b           gnus-summary-resend-bounced-mail                 
B    gnus-summary-delete-article                     S D e           gnus-summary-resend-message-edit                 
B       gnus-summary-delete-article                     S D r           gnus-summary-resend-message                      
                                                                                                                                 
G C-n           gnus-summary-next-same-subject                  S O m           gnus-uu-digest-mail-forward                      
G C-p           gnus-summary-prev-same-subject                  S O p           gnus-uu-digest-post-forward                      
G ESC           Prefix Command                                                                                                   
G N             gnus-summary-next-article                       S o m           gnus-summary-mail-forward                        
G P             gnus-summary-prev-article                       S o p           gnus-summary-post-forward                        
G b             gnus-summary-best-unread-article                                                                                 
G f             gnus-summary-first-unread-article               S B R           gnus-summary-reply-broken-reply-to-with-original 
G g             gnus-summary-goto-subject                       S B r           gnus-summary-reply-broken-reply-to               
G j             gnus-summary-goto-article                                                                                        
G l             gnus-summary-goto-last-article                  S M-c           gnus-summary-mail-crosspost-complaint            
G n             gnus-summary-next-unread-article                                                                                 
G o             gnus-summary-pop-article                        T M-#           gnus-uu-unmark-thread                            
G p             gnus-summary-prev-unread-article                                                                                 
                                                                W E A           gnus-article-strip-all-blank-lines                      
H C             gnus-group-fetch-control                        W E a           gnus-article-strip-blank-lines                   
H c             gnus-group-fetch-charter                        W E e           gnus-article-strip-trailing-space                
H d             gnus-summary-describe-group                     W E l           gnus-article-strip-leading-blank-lines           
H f             gnus-summary-fetch-faq                          W E m           gnus-article-strip-multiple-blank-lines          
H h             gnus-summary-describe-briefly                   W E s           gnus-article-strip-leading-space                 
H i             gnus-info-find-node                             W E t           gnus-article-remove-trailing-blank-lines         
H v             gnus-version                                    W E w           gnus-article-remove-leading-whitespace           
                                                                                                                                 
K C             gnus-article-view-part-as-charset               W T e           gnus-article-date-lapsed                         
K E             gnus-article-encrypt-body                       W T i           gnus-article-date-iso8601                        
K b             gnus-summary-display-buttonized                 W T l           gnus-article-date-local                          
K c             gnus-article-copy-part                          W T o           gnus-article-date-original                       
K e             gnus-article-view-part-externally               W T p           gnus-article-date-english                        
K i             gnus-article-inline-part                        W T s           gnus-article-date-user                           
K m             gnus-summary-repair-multipart                   W T u           gnus-article-date-ut                             
K o             gnus-article-save-part                          W T z           gnus-article-date-ut                             
K v             gnus-article-view-part                                                                                           
K |             gnus-article-pipe-part                          W M b           gnus-article-view-part                           
                                                                W M c           gnus-article-decode-charset                      
M C-c           gnus-summary-catchup-all                        W M v           gnus-mime-view-all-parts                         
M ESC           Prefix Command                                  W M w           gnus-article-decode-mime-words                   
M SPC           gnus-summary-clear-mark-forward                                                                                  
M !             gnus-summary-tick-article-forward               W D D           gnus-article-remove-images                       
M #             gnus-summary-mark-as-processable                W D d           gnus-article-display-face                        
M ?             gnus-summary-mark-as-dormant                    W D f           gnus-treat-from-picon                            
M B             gnus-summary-remove-bookmark                    W D m           gnus-treat-mail-picon                            
M C             gnus-summary-catchup                            W D n           gnus-treat-newsgroups-picon                      
M H             gnus-summary-catchup-to-here                    W D s           gnus-treat-smiley                                
M K             gnus-summary-kill-same-subject                  W D x           gnus-article-display-x-face                      
M M             Prefix Command                                                                                                   
M P             gnus-uu-mark-map                                W G f           gnus-article-treat-fold-headers                  
M S             gnus-summary-limit-include-expunged             W G n           gnus-article-treat-fold-newsgroups               
M V             gnus-summary-mscore-map                         W G u           gnus-article-treat-unfold-headers                
M b             gnus-summary-set-bookmark                                                                                        
M c             gnus-summary-clear-mark-forward                 W H a           gnus-article-highlight                           
M d             gnus-summary-mark-as-read-forward               W H c           gnus-article-highlight-citation                  
M e             gnus-summary-mark-as-expirable                  W H h           gnus-article-highlight-headers                   
M h             gnus-summary-catchup-from-here                  W H s           gnus-article-highlight-signature                 
M k             gnus-summary-kill-same-subject-and-select                                                                        
M r             gnus-summary-mark-as-read-forward               W W C-c         gnus-article-hide-citation-maybe                 
M t             gnus-summary-tick-article-forward               W W B           gnus-article-strip-banner                        
M x             gnus-summary-mark-as-expirable                  W W C           gnus-article-hide-citation-in-followups          
                                                                W W P           gnus-article-hide-pem                            
O B             gnus-summary-write-article-body-file            W W a           gnus-article-hide                                
O F             gnus-summary-write-article-file                 W W b           gnus-article-hide-boring-headers                 
O P             gnus-summary-muttprint                          W W c           gnus-article-hide-citation                       
O b             gnus-summary-save-article-body-file             W W h           gnus-article-hide-headers                        
O f             gnus-summary-save-article-file                  W W l           gnus-article-hide-list-identifiers               
O h             gnus-summary-save-article-folder                W W s           gnus-article-hide-signature                      
O m             gnus-summary-save-article-mail                                                                                   
O o             gnus-summary-save-article                       W Y a           gnus-article-outlook-repair-attribution          
O p             gnus-summary-pipe-output                        W Y c           gnus-article-outlook-rearrange-citation          
O r             gnus-summary-save-article-rmail                 W Y f           gnus-article-outlook-deuglify-article            
O s             gnus-soup-add-article                           W Y u           gnus-article-outlook-unwrap-lines                
O v             gnus-summary-save-article-vm                                                                                     
                                                                X v B           gnus-uu-decode-binhex-view                       
S ESC           Prefix Command                                  X v O           gnus-uu-decode-save-view                         
S B             Prefix Command                                  X v P           gnus-uu-decode-postscript-and-save-view          
S D             gnus-send-bounce-map                            X v S           gnus-uu-decode-unshar-and-save-view              
S F             gnus-summary-followup-with-original             X v U           gnus-uu-decode-uu-and-save-view                  
S N             gnus-summary-followup-to-mail-with-original     X v b           gnus-uu-decode-binhex-view                       
S O             Prefix Command                                  X v o           gnus-uu-decode-save-view                         
S R             gnus-summary-reply-with-original                X v p           gnus-uu-decode-postscript-view                   
S V             gnus-summary-very-wide-reply-with-original      X v s           gnus-uu-decode-unshar-view                       
S W             gnus-summary-wide-reply-with-original           X v u           gnus-uu-decode-uu-view                           
S c             gnus-summary-cancel-article                                                                                      
S f             gnus-summary-followup                           M M e N         gnus-summary-put-mark-as-expirable-next-unread   
S i             gnus-summary-news-other-window                  M M e P         gnus-summary-put-mark-as-expirable-prev-unread   
S m             gnus-summary-mail-other-window                  M M e e         gnus-summary-put-mark-as-expirable               
S n             gnus-summary-followup-to-mail                   M M e n         gnus-summary-put-mark-as-expirable-next          
S o             Prefix Command                                  M M e p         gnus-summary-put-mark-as-expirable-prev          
S p             gnus-summary-post-news                                                                                           
S r             gnus-summary-reply                              M M ? ?         gnus-summary-put-mark-as-dormant                 
S s             gnus-summary-supersede-article                  M M ? N         gnus-summary-put-mark-as-dormant-next-unread     
S u             gnus-uu-post-news                               M M ? P         gnus-summary-put-mark-as-dormant-prev-unread     
S v             gnus-summary-very-wide-reply                    M M ? n         gnus-summary-put-mark-as-dormant-next            
S w             gnus-summary-wide-reply                         M M ? p         gnus-summary-put-mark-as-dormant-prev            
S y             gnus-summary-yank-message                                                                                        
                                                                M M ! !         gnus-summary-put-mark-as-ticked                  
T ESC           Prefix Command                                  M M ! N         gnus-summary-put-mark-as-ticked-next-unread      
T #             gnus-uu-mark-thread                             M M ! P         gnus-summary-put-mark-as-ticked-prev-unread      
T H             gnus-summary-hide-all-threads                   M M ! n         gnus-summary-put-mark-as-ticked-next             
T S             gnus-summary-show-all-threads                   M M ! p         gnus-summary-put-mark-as-ticked-prev             
T T             gnus-summary-toggle-threads                                                                                      
T ^             gnus-summary-reparent-thread                    M M u N         gnus-summary-put-mark-as-unread-next-unread      
T d             gnus-summary-down-thread                        M M u P         gnus-summary-put-mark-as-unread-prev-unread      
T h             gnus-summary-hide-thread                        M M u n         gnus-summary-put-mark-as-unread-next             
T i             gnus-summary-raise-thread                       M M u p         gnus-summary-put-mark-as-unread-prev             
T k             gnus-summary-kill-thread                        M M u u         gnus-summary-put-mark-as-unread                  
T l             gnus-summary-lower-thread                                                                                        
T n             gnus-summary-next-thread                        M M d N         gnus-summary-put-mark-as-read-next-unread        
T o             gnus-summary-top-thread                         M M d P         gnus-summary-put-mark-as-read-prev-unread        
T p             gnus-summary-prev-thread                        M M d d         gnus-summary-put-mark-as-read                    
T s             gnus-summary-show-thread                        M M d n         gnus-summary-put-mark-as-read-next               
T t             gnus-summary-rethread-current                   M M d p         gnus-summary-put-mark-as-read-prev

Sí, y ustedes se creían duros memorizando decimales de pi. Y esto son sólo dos aplicaciones de GNU/Emacs: ECB y Gnus.

Flymake en php

2008-02-16T19:38:00.002-02:00

Agenden esta extensión para flymake, que te cambia la vida. :)

Filtrar procesos con psgrep para bash

2008-02-12T16:01:00.000-02:00

Una alias/función fundamental para cualquier usuario de BASH en GNU/Linux. Agregarle a tu .bashrc:

psgrep()
{
 ps aux | grep $1 | grep -v grep
}

Luego lo usas así:

  psgrep xmms

Útil. ¿No? Muchísimos trucos más pueden encontrarle al bash si instalan su documentación:

  sudo aptitude install bash-doc

Luego navegan el directorio /usr/share/doc/bash-doc/examples

Probando g-client en emacs 22

2008-02-10T22:08:00.001-02:00

Estamos probando hacer un post directamente desde Emacs, utilizando el cliente para servicios de google. Veremos si anda bien.

Si lo quieren probar, los pasos son más o menos los siguientes:

	# sudo aptitude install curl w3m
	# svn -co http://emacspeak.googlecode.com/svn/trunk/lisp/g-client/
	# make

Ahora editas tu ~/.emacs

	(push "~/g-client" load-path)
	(load-library "g")
	(setq g-user-email "example@gmail.com")
	(setq g-html-handler 'browse-url-of-buffer)
	(setq browse-url-browser-function 'w3m-browse-url)

Haces un M-x eval-buffer, luego un gblogger-blog y listo!

Final de algoritmos resuelto en pascal UTN

2007-12-19T14:09:00.001-03:00

Un final de algoritmos resuelto en código de la UTN FRBA, va con enunciado

Una empresa de encomiendas internacionales desea procesar su
información. Para ello cuenta con dos archivos con las siguientes
características:

Archivo de precios, desordenado que registra el precio por Kg. enviado
desde una ofcina a otra (no aparecen en el archivo 2 registros que
relacionan las mismas oficinas), con la siguiente estructura:
- código de oficina1 (1..250)
- código de oficina2 (1..250)
- precio por kg (single)

Archivo de oficinas, ordenado en forma creciente por País y Ciudad,
con la siguiente estructura:
- código de oficina (1..250)
- ciudad (25 caracteres)
- país (20 caracteres)

Se desea desarrollar una estrategia y un algoritmo para el
procesamiento interactivo diario de encomiendas considerando que:

Se ingresa por teclado un código de Oficina Origen y un código de
Oficina Destino:

- Si ambos son distintos de 0 (cero) se trata de un envío, por lo que
debe solicitarse el ingreso por telcado del peso, en Kg (single), y se
debe generar el ticket correspondiente detallando:
- Oficina de origen:
- Oficina de destino:
- Peso:
- Importe:

- Si sólo el Origen es 0 se debe listar (por pantalla) la cantidad de
encomiendas enviadas a la oficina Destino indicada, detallada por
origen.

- Si sólo el Destino es 0, se debe listar (por pantalla) la cantidad
de encomiendas enviadas desde esa Oficina Origen, detallada por
Destino.

- Si ambos son 0, se trata del fin del día y se debe generar un
listado (por impresora), del tráfico del día, en orden creciente por
País y Ciudad con el siguiente formato:
 País:
  Ciudad:
    Oficina:     Enviados:   Recibidos:

   Ciudad:
    Oficina:     Enviados:   Recibidos:


RESTRICCIONES: 
Estática: 
 246.5 Kb
Dinámica:
 10b x nodo utilizado.


program otro;

type
   string25       = string[25];
   string20       = string[20];
   tregPrecios    = record
                       ofi1   : byte;
                       ofi2   : byte;
                       precio : single;
                    end;      
   tarPrecios     = file of tregPrecios;
   tregOficinas   = record

                       ofi    : byte;
                       ciudad : string25;
                       pais   : string20;
                    end;      
   tarOficinas    = file of tregOficinas;
   tenviados      = ^tnodoenviados;
   tnodoenviados  = record
                       oficina : byte;
                       destino : byte;
                       ste     : tenviados;
                    end;       
   trecibidos     = ^tnodorecibidos;
   tnodorecibidos = record

                       oficina : byte;
                       origen  : byte;
                       ste     : trecibidos;
                    end;       
   tmatprecios    = Array[1..250 , 1..250] of single;

var           
   arprecios      : tarprecios;
   aroficinas     : taroficinas;
   enviados       : tenviados;
   recibidos      : trecibidos;
   precios        : tmatprecios;
   origen,destino : byte;
   peso,precio    : single;


procedure listarResumen(enviados : tenviados;recibidos:trecibidos;var oficinas:taroficinas);

var
   reg,ant : tregoficinas;
   auxE    : tenviados;
   auxR    : trecibidos;
   cant    : byte;
begin
   ant.pais := '';
   ant.ciudad := '';   
   writeln('Resumen diario:');
   while not eof(oficinas) do

   begin
      read(oficinas,reg);
      if ant.pais <> reg.pais then begin
         ant.pais := reg.pais;
         writeln('Pais: ', reg.pais);
      end;
      if ant.ciudad <> reg.ciudad then begin

         ant.ciudad := reg.ciudad;
         writeln('Ciudad: ', reg.ciudad);
      end;
      writeln('Oficina: ',reg.ofi);
      auxE := enviados;
      cant := 0;
      while (auxE <> nil) do
      begin

         if auxE^.oficina = reg.ofi then
            inc(cant);
         auxE := auxE^.ste;
      end;
      writeln('Enviados por la oficina: ',cant);
      auxR := recibidos;
      cant := 0;
      while (auxR <> nil) do

      begin
         if auxR^.oficina = reg.ofi then
            inc(cant);
         auxR := auxR^.ste;
      end;
      writeln('Recibidos por la oficina: ',cant);
            
   end;

end; 

procedure liberarmemoria(var enviados: tenviados; var recibidos:trecibidos);
begin
   writeln('Liberando memoria...');
   while(enviados <> nil) do

   begin
      dispose(enviados);
      enviados:= enviados^.ste;
   end;
   while(recibidos <> nil) do
   begin
      dispose(recibidos);
      recibidos:= recibidos^.ste;
   end;

end;
procedure factura(origen,destino : byte; peso,precio:single);
begin
   writeln('Origen: ',origen,' Destino: ',destino);
   writeln('Peso: ',peso:2,' Precio: ',precio:2);

end; { factura }
procedure ResumenOrigenes(var origen : byte;recibidos:trecibidos);
var cant : byte;
begin

   cant := 0;
   while(recibidos <> nil) do
   begin
      if(recibidos^.origen = origen) then begin

         writeln('Destino: ', enviados^.oficina);
         inc(cant);
      end;
      recibidos := recibidos^.ste;
   end;
   writeln('Cantidad de recibidos al origen ( ',origen,' ): ', cant);
end;
procedure ResumenDestinos(var destino : byte;enviados:tenviados);

var cant : byte;
begin
   cant := 0;
   while(enviados <> nil) do
   begin
      if(enviados^.destino = destino) then begin

         writeln('Origen: ', enviados^.oficina);
         inc(cant);
      end;
      enviados := enviados^.ste;
   end;
   writeln('Cantidad de enviados al destino ( ',destino,' ): ', cant);
end;
procedure iEnviados(oficina,destino: byte;var enviados : tenviados);

var nodo : tenviados;
begin;
   new(nodo);
   nodo^.oficina := oficina;
   nodo^.destino := destino;
   nodo^.ste := enviados;
   enviados := nodo;
end;
procedure iRecibidos(oficina,origen:byte;var recibidos : trecibidos);
var nodo : trecibidos;

begin;
   new(nodo);
   nodo^.oficina := oficina;
   nodo^.origen := origen;
   nodo^.ste := recibidos;
   recibidos := nodo;   
end;
procedure menu(var origen : byte;var destino:byte;var peso:single);

begin;
   writeln('Origen: ');
   readln(origen);
   writeln('Destino: ');
   readln(destino);
   if (destino <> 0) AND (origen <> 0) then begin

      writeln('Kg: ');
      readln(peso);
   end;
end;

procedure iniPrecios(var precios : tmatprecios;var ar : tarprecios);

var
   reg : tregPrecios;
   i,j : byte;
begin
   for i:= 1 to 250 do
      for j:=1 to 250 do

         precios[i,j]:=0;
   
   while(not eof(ar)) do
   begin
      read(ar,reg);
      precios[reg.ofi1,reg.ofi2] := reg.precio;
      precios[reg.ofi2,reg.ofi1] := reg.precio;
      writeln('Cargando precio: precios[',reg.ofi1,',',reg.ofi2,'] := ',precios[reg.ofi1,reg.ofi2]);
   end;


end;
procedure iniListas(var enviados : tenviados; var recibidos : trecibidos);
begin
   enviados:=nil;
   recibidos:=nil;
end;

procedure iniArchivos(var precios: tarprecios;var oficinas : taroficinas);
var
   regp      : tregPrecios;
   rego      : tregOficinas;
begin
   assign(precios,'precios.dat');
   assign(oficinas,'oficinas.dat');
   rewrite(precios);
   rewrite(oficinas);
   regp.ofi1:=1; regp.ofi2:=2; regp.precio:=13;write(precios,regp);
   regp.ofi1:=3; regp.ofi2:=4; regp.precio:=14;write(precios,regp);
   regp.ofi1:=5; regp.ofi2:=6; regp.precio:=15;write(precios,regp);
   regp.ofi1:=7; regp.ofi2:=8; regp.precio:=16;write(precios,regp);
   regp.ofi1:=9; regp.ofi2:=10;regp.precio:=17;write(precios,regp);
   regp.ofi1:=12;regp.ofi2:=11;regp.precio:=18;write(precios,regp);

   rego.ofi:=1;rego.ciudad:= 'Buenos Aires';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=2;rego.ciudad:= 'Mar del Plat';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=3;rego.ciudad:= 'San Juan    ';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=4;rego.ciudad:= 'Rosario     ';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=5;rego.ciudad:= 'Lujan       ';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=6;rego.ciudad:= 'Mercedes    ';rego.pais:='Argentina';write(oficinas,rego);
   rego.ofi:=7;rego.ciudad:= 'Milan       ';rego.pais:='Italia   ';write(oficinas,rego);
   rego.ofi:=8;rego.ciudad:= 'Mayorca     ';rego.pais:='España   ';write(oficinas,rego);
   rego.ofi:=9;rego.ciudad:= 'Valencia    ';rego.pais:='España   ';write(oficinas,rego);
   rego.ofi:=10;rego.ciudad:='Madrid      ';rego.pais:='España   ';write(oficinas,rego);
   rego.ofi:=11;rego.ciudad:='Napoles     ';rego.pais:='Italia   ';write(oficinas,rego);
   rego.ofi:=12;rego.ciudad:='Jael        ';rego.pais:='España   ';write(oficinas,rego);
   rego.ofi:=13;rego.ciudad:='San fernando';rego.pais:='España   ';write(oficinas,rego);
   rego.ofi:=14;rego.ciudad:='Bombay      ';rego.pais:='India    ';write(oficinas,rego);
   reset(precios);
   reset(oficinas);
   

end;
   
begin 
   iniArchivos(arprecios,aroficinas);
   iniListas(enviados,recibidos);
   iniPrecios(precios,arprecios);
   repeat
      menu(origen,destino,peso);
      if (origen = 0) and (destino <> 0) then

      begin
         ResumenDestinos(destino,enviados);
      end;
      if (origen <> 0) and (destino = 0) then

      begin
         ResumenOrigenes(origen,recibidos);
      end;
      if (origen <> 0) and (destino <> 0) then

      begin
         precio := peso * (precios[origen,destino]);
         writeln('Por kg precios[',origen,',',destino,']: ', precios[origen,destino]);
         iEnviados(origen,destino,enviados);
         iRecibidos(destino,origen,recibidos);
         factura(origen,destino,peso,precio);
      end;
   until (origen = 0) AND (destino = 0);
   listarResumen(enviados,recibidos,aroficinas);
   liberarMemoria(enviados,recibidos);

end.

Ordena Burbuja en Java

2007-11-17T11:31:00.000-03:00

Dos versiones del algoritmo de ordenación burbuja en Java. Descomentar la llamada del método para probar una u otra.

class OrdenaAlgoritmo {
    public static void ordenar( int [] arreglo) {
 int pasadas = 0;
 int comparaciones = 0;
 for (int i = 0; i < arreglo.length; i++) {
     ++pasadas;
     for (int j = 0; j < arreglo.length - 1; j++) {
  ++comparaciones;
  if (arreglo[j] > arreglo[j + 1]) {
      intercambiar(arreglo, j, j+1);
  }
     }
 }
 estadisticas(pasadas, comparaciones);
    }

    public static void ordenarMejorado( int [] arreglo) {
 int pasadas = 0;
 int comparaciones = 0;
 boolean hayCambios = true;
 for (int i = 0; hayCambios ; i++) {
     ++pasadas;
     hayCambios = false;
     for (int j = 0; j < arreglo.length - 1; j++) {
  ++comparaciones;
  if (arreglo[j] > arreglo[j + 1]) {
      intercambiar(arreglo, j, j+1);
      hayCambios = true;
  }
     }
 }
 estadisticas(pasadas, comparaciones);
    }

    private static void intercambiar(int [] arreglo, int a, int b) {
 int tmp = arreglo[a];
 arreglo[a] = arreglo[b];
 arreglo[b] = tmp;
    }

    private static void estadisticas( int pasadas, int comparaciones) {
 System.out.println( "Pasadas: " + pasadas );
 System.out.println( "Comparaciones: " + comparaciones );
    }
}


public class OrdenaBurbuja {
    public static void  main (String args[]) {

 int [] valores = {15,35,01,05,04,03,19,45,13,02,55,8,
    78,997,451,546,12,16,24,103,99,784,
    4541,15};

 //OrdenaAlgoritmo.ordenar(valores);
 OrdenaAlgoritmo.ordenarMejorado(valores);
 // Mostrar arreglo.
 for (int i = 0; i < valores.length ; i++)
     System.out.println ( "valores["+i+"]: "+  valores[i]);
 
    }
}

Búsqueda binaria en java

2007-11-17T09:27:00.000-03:00

Implementación del algoritmo de búsqueda binaria de manera no recursiva en Java.

Se utiliza una función estática de la clase BusquedaAlgoritmo.

Recordar que para que funcione correctamente los valores del arreglo deben estar ordenados.

class BusquedaAlgoritmo {
    public static int buscar( int [] arreglo, int dato) {
 int inicio = 0;
 int fin = arreglo.length - 1;
 int pos;
 while (inicio <= fin) {
     pos = (inicio+fin) / 2;
     if ( arreglo[pos] == dato )
       return pos;
     else if ( arreglo[pos] < dato ) {
  inicio = pos+1;
     } else {
  fin = pos-1;
     }
 }
 return -1;
    }
}

public class BusquedaBinaria {
    public static void  main (String args[]) {
 // Llenar arreglo
 int [] edades = new int [35];
 for (int i = 0; i < edades.length ; i++)
     edades[i] = i*i ;

 // Mostrar arreglo.
 for (int i = 0; i < edades.length ; i++)
     System.out.println ( "edades["+i+"]: "+  edades[i]);

 int resultado = BusquedaAlgoritmo.buscar(edades, 9);

 if (resultado != -1) {
     System.out.println ( "Encontrado en: "+  resultado);
 } else {
     System.out.println ( "El dato no se encuentra en el arreglo, o el arreglo no estÃ¡ ordenado."  );
 }
 
    }
}

Arrays en Java

2007-11-04T14:26:00.000-03:00

Para obtener un arreglo en Java lo primero que debemos hacer es definir la referencia a este, por ejemplo:

int [] arregloEntero;

Definimos una referencia a un arreglo entero, pero aún no hemos creado el arreglo. Una sintaxis similar es la siguiente:

int arregloEntero[];

Sin embargo se considera más elegante la primera porque queda más claro que int [] es un tipo referencia a array entero.

Para inicializar la referencia podemos asignar una lista objetos (o tipos primitivos) según el tipo de la referencia por ejemplo:

  // Dos elementos, de tipo primitivo.
  int [] arregloTiposPrimitivos = {1, 2}

  // Arreglo de objetos de dos elementos.
  TipoDeObjeto [] arregloObjetos = {new TipoDeObjeto(), new TipoDeObjeto()}

Con el modo de inicialización anterior el tamaño del objeto se está conoce en tiempo de compilación.

Una manera alternativa es determinar el tamaño mediante new, si se trata de un array de datos primitivos estos se inicializaran con su valor por defecto (por ejemplo 0 para int), mientras que en un array de objetos obtendremos un array de referencias inicializadas en null. Por ejemplo:

  int [] arregloDatosPrimitivos = new int[tamaño];
  // Imprime 0.
  System.out.println(arregloDatosPrimitivos[tamaño-1]);

  Tipo [] arregloObjetos = new Tipo[tamaño];
  // Imprime null.
  System.out.println(arregloObjetos[tamaño-1]);
  arregloObjetos[tamaño-1] = new Tipo();
  //Imprime lo devuelto por getAlgunDato()
  System.out.println(arregloObjetos[tamaño-1].getAlgunDato());

Veamos ahora un ejemplo que ilustre las situaciones anteriores:

// Archivo: ArreglosJava.java
// codigomaldito.blogspot.com
// Compilar con: javac ArreglosJava.java 
// Ejecutar con: java ArreglosJava

class DatoA {
    private int z;
    DatoA(int i) { z = i; }
    public int getDato() { return z; }
}


public class ArreglosJava {

    //Flujo principal de ejecuciÃ³n.
    public static void main(String [] args) {
 // Array de tipo de primitivo. Dos notaciones. Estilo Java y estilo C.
 int [] arregloEntero =   {1,2,3,4,5};
 int arregloEntero2 [] =  {1,2,3,4,5};
 //5 elementos, los Ãndices van de 0...4
 for(int i = 0 ; i < arregloEntero.length ; i++)
     System.out.println("arregloEntero["+i+"] = "+ arregloEntero[i]);
 for(int i = 0 ; i < arregloEntero2.length ; i++)
     System.out.println("arregloEntero2["+i+"] = "+ arregloEntero2[i]);

 //Generamos un nÃºmero aleatorio entre 1 y 10.
 int EnteroAleatorio = (int)(10.0 * Math.random()) + 1;
 // Utilizamos EnteroAleatorio como tamaÃ±o del arreglo
 // esto significa que el tamaÃ±o puede definirse en tiempo de 
 // ejecuciÃ³n.
 int [] arregloVariable = new int[EnteroAleatorio];
 System.out.println("Mostrando arreglo de "+EnteroAleatorio+" elementos.");
 // Sin inicializar mostramos el arreglo, automÃ¡ticamente 
 // java lo inicializÃ³ en 0.
 for(int i = 0 ; i < arregloVariable.length ; i++)
     System.out.println("arregloVariable["+i+"] = "+ arregloVariable[i]);

 
 DatoA [] arregloDeObjetos = new DatoA[10];
 // Valor en la posiciÃ³n 2 igual a null. (es un array de referencias).
 System.out.println("arregloDeObjetos[2] = "+ arregloDeObjetos[2]);
 
 //Lo siguiente serÃa un error en tiempo de ejecuciÃ³n. La posiciÃ³n no apunta a nada aÃºn.
 //System.out.println("arregloDeObjetos[2].getDato() = "+ arregloDeObjetos[2].getDato());

 for(int i = 0 ; i < arregloDeObjetos.length ; i++)
     arregloDeObjetos[i] = new DatoA(5);
 for(int i = 0 ; i < arregloDeObjetos.length ; i++)
     System.out.println("arregloDeObjetos["+i+"].getDato() = "+ arregloDeObjetos[i].getDato());

 //Otro mÃ©todo alternativo de inicializaciÃ³n
 // 2 objetos.
 DatoA [] arregloDeObjetos2 = {new DatoA(1), new DatoA(2) };
 for(int i = 0 ; i < arregloDeObjetos2.length ; i++)
     System.out.println("arregloDeObjetos2["+i+"].getDato() = "+ arregloDeObjetos2[i].getDato());
    }
}

Referencia this en Java

2007-11-04T13:44:00.001-03:00

Muchos métodos de un objeto necesitan acceder a los datos miembros de este, y a otras propiedades del objeto. Por este motivo es que el lenguaje Java junto a la ejecución de un método pasa como argumento la referencia del objeto que está ejecutando el miembro. Para referirnos explícitamente a esta referencia desde el método utilizamos la palabra reservada this. Que no es otra cosa que una referencia al objeto que está ejecutando al método.

Si bien en muchos casos se puede omitir su uso, otras veces nos ayuda a resolver ambiguedades o para devolver referencias del objeto que ejecutó el método. Por ejemplo:

// Referencia this.
// Compilar con: javac UsoThis.java
// Ejecutar con: java UsoThis
// http://codigomaldito.blogspot.com

class Ventana {
    private int largo;
    private int ancho;
    Ventana(int largo, int ancho) {
 //this.DATOMIEMBRO elimina la ambiguedad.
 this.largo = largo;
 this.ancho = ancho;
    }
    Ventana(){
 // No es necesario usar this.
 largo = 0;
 ancho = 0;
    }

    // Devuelve una referencia al mismo objeto
    // esto permite una llamada del tipo 
    // obj.incrementarLargo().incrementarLargo();
    public Ventana incrementarLargo() {
 ++largo;
 return this;
    }
    public Ventana incrementarAncho() {
 ++ancho;
 return this;
    }
    public int getAncho() {
 return ancho;
    }
    public int getLargo() {
 //utilzamos la referencia.
 return this.largo;
    }


    public void mostrar() {
 // AquÃ no hay ambiguedad, podemos utilizar
 // explicitamente a this, o bien
 // no especificarlo.
 System.out.println("Ancho: "+getAncho()+" y Largo: "+ this.getLargo());
    }

}


public class UsoThis {

    
    // Flujo principal de ejecuciÃ³n
    public static void main (String [] args) {
 //El constructor usa this para resolver la ambiguedad.
 System.out.println("Referencia A");
 Ventana A = new Ventana(0,0);
 A.mostrar();
 //incrementarAncho() devuelve una referencia al objeto.
 System.out.println("Se incrementa dos veces el ancho del objeto al que apunta A");
 A.incrementarAncho().incrementarAncho();
 A.mostrar();

 // Este modo de asignar resulta curioso
 // Creamos una referencia, pero no un objeto.
 Ventana B;
 // Asignamos la referencia de incrementarLargo();
 B = A.incrementarLargo();
 //Ahora las dos referencias apuntan al mismo objeto.
 System.out.println("Referencia A y referencia B apuntan al mismo objeto.");
 A.mostrar();
 B.mostrar();
    }
}

La salida del programa es:

Referencia A
Ancho: 0 y Largo: 0
Se incrementa el ancho del objeto al que apunta A
Ancho: 2 y Largo: 0
Referencia A y referencia B apuntan al mismo objeto.
Ancho: 2 y Largo: 1
Ancho: 2 y Largo: 1

Constructores y sobrecarga en Java

2007-11-04T13:33:00.001-03:00

Los constructores son métodos específicos de la clase que llevan el mismo nombre que esta. Siempre que se cree un nuevo objeto no primitivo se ejecutará un constructor incluso cuando no se defina ningun constructor por parte del programador, Java ejecutará constructor automáticamente.

Como el resto de los métodos, los constructores pueden estar sobrecargados. Esto significa que podemos definir distintos constructores cambiando el orden, la cantidad y el tipo de parámetros que reciben. Luego dependiendo la manera en la que se cree el objeto con new Java elegirá el constructor adecuado basándose en la lista de parámetros.

En el ejemplo siguiente se ilustra la sobrecarga de constructores:

// Archivo: Constructores.java
// Uso de constructores
// Compilar con: javac Constructores.java
// Ejecutar con: java Constructores


class Luz {
    //Datos miembro privados de la clase.
    // Dato primitivo valor por defecto: 0.
    private int brillo;        
    // Dato primitivo valor por defecto: false.
    private boolean encendida; 

    //Constructor por defecto, sin argumentos.
    Luz() {
 salida("Constructor por defecto Luz()");
 this.brillo = 0;
 this.encendida = true;
    }

    //Constructor que recibe un entero.
    Luz(int brillo) {
 salida("Constructor con un parametro entero Luz(int brillo)");
 this.brillo = brillo;
    }

    //Constructor que recibe un boolean
    Luz(boolean encendida) {
 salida("Constructor con un parametro boolean Luz(boolean encendida)");
 this.encendida = encendida;
    }

    //Constructor que recibe un boolean y un entero.
    Luz(boolean encendida, int brillo) {
 //Podemos invocar a otro constructor con this(), siempre
 // que sea lo primero en llamarse.
 this(brillo);
 salida("Constructor con dos parametros: Luz(boolean encendida, int brillo)");
 this.encendida = encendida;
    }
    
    //Atajo para imprimir.
    public void salida(String s) {
 System.out.println(s);
    }

}


public class Constructores {
    // Flujo inicial de ejecuciÃ³n
    public static void main (String [] args) {
 // Vamos a crear Lamparitas.
 System.out.println("Se crea lamparita A, con Luz().");
 Luz lamparitaA = new Luz();
 System.out.println("Se crea lamparita B, con Luz(10).");
 Luz lamparitaB = new Luz(10);
 System.out.println("Se crea lamparita C, con Luz(true).");
 Luz lamparitaC = new Luz(true);
 System.out.println("Se crea lamparita D, con Luz(true,15).");
 Luz lamparitaD = new Luz(true,15);
 
    }
}

La salida del programa anterior es la siguiente:

Se crea lamparita A, con Luz().
Constructor por defecto Luz()
Se crea lamparita B, con Luz(10).
Constructor con un parametro entero Luz(int brillo)
Se crea lamparita C, con Luz(true).
Constructor con un parametro boolean Luz(boolean encendida)
Se crea lamparita D, con Luz(true,15).
Constructor con un parametro entero Luz(int brillo)
Constructor con dos parametros: Luz(boolean encendida, int brillo)

Tipos de datos primitivos en Java

2007-11-04T00:19:00.000-03:00

Tipo primitivo	Tamaño	Mínimo	Máximo	Valor por defecto como dato miembro
boolean	-	-	-	false
char	16 bits	Unicode 0	Unicode 2^16-1	'\u0000'(null)
byte	8 bits	-1^28	+127	(byte)0
shot	16 bits	-2^15	+2^15-1	(short)0
int	32 bits	-2^15	+2^31-1	0
float	32 bits	IEEE754	IEEE754	0.0f
double	64 bits	IEEE754	IEEE754	0.0d
void	-	-	-	-

Números aleatorios en Java

2007-11-04T00:06:00.000-03:00

/*
 * Nũmeros aleatorios en Java. 
 * 
 *
 */
import java.util.*;
class NumeroAleatorio {
    private double x1;
    private int x2;
    private Random aleatorio = new Random();
    public NumeroAleatorio() {
 generar();
    }
    public double dameDouble() {
 generar();
 return x1;
    }
    public int dameEntero() {
 generar();
 return x2;
    }
    private void generar() {
 x1 = aleatorio.nextDouble();
 x2 = aleatorio.nextInt();
    }
}

public class Ejercicio04 {
    //Comienzo del flujo principal del programa.
    public static void main(String [] argumentos) {
 NumeroAleatorio z = new NumeroAleatorio();
 int x = 10;
 while(x > 0) {
     x--;
     salida("Entero aleatorio: " + z.dameEntero());
     salida("Double aleatorio: " + z.dameDouble());
 }
 System.exit(0);
    }

    public static void salida ( String cadena ) {
 System.out.println(cadena);
    }

}

Ejemplo de switch en java

2007-11-04T00:05:00.001-03:00

El siguiente es un ejemplo del uso de la sentencia swtich en Java

/*
 * Ejemplo de uso switch. 
 * 
 *
 */

public class Ejercicio03 {
    //Comienzo del flujo principal del programa.
    public static void main(String [] argumentos) {
 int x = 1;
 int tope = 20;

 salida("valor x: " + x);
 salida("valor tope: " + tope);
 while(x < tope) {
     evaluar(x++);
 }
 System.exit(0);
    }

    public static void salida ( String cadena ) {
 System.out.println(cadena);
    }

    public static void evaluar ( int numero ) {
 switch(numero) {
 case 1: 
     salida("Uno");
     break;
 case 2: 
     salida("Dos");
     break;
 case 3: 
     salida("Tres");
     break;
 case 4: 
     salida("Cuatro");
     break;
 case 5: 
 case 6: 
     salida("Cinco o seis");
     break;
 default: 
     salida("Otro nÃºmero");
     break;
 }

    }

}

Ciclos: for, while, do while en java

2007-11-04T00:02:00.000-03:00

/*
 * Ejemplo de uso de diferentes iteradores. 
 * while, for, do while, etc
 *
 */

public class Ejercicio02 {
    //Comienzo del flujo principal del programa.
    public static void main(String [] argumentos) {
 int x = 0;
 int y = 10;
 salida("Primer iterador");
 while(x < y) {
     salida("x es "+  x++);
 }
 salida("Segundo iterador");
 for(int i = 0; i < 10 ; ++i) {
     salida("i es "+ i);
 }
 salida("Tercer iterador");
 do {
     salida("x es " + x--);
 } while ( x > 0 );

 System.exit(0);
    }

    public static void salida ( String cadena ) {
 System.out.println(cadena);
    }

}

If else en java

2007-11-04T00:01:00.000-03:00

public class Ejercicio1 {
    //Comienzo del flujo principal del programa.
    public static void main(String [] argumentos) {
 // Uso de if.
 int x = 5;
 int y = 7;
 comparar(x,y);
 comparar(7,5);
 comparar(5,5);
 System.exit(0);
    }
    public static void salida ( String cadena ) {
 System.out.println(cadena);
    }
    public static void comparar(int entero1, int entero2) {
 if (entero1 > entero2)
     salida("El primer argumento es menor");
 else
     if(entero1 < entero2)
  salida ("El primer argumento es mayor."); 
 else
     salida("Los dos argumentos son iguales");
    }
}

Introducción a SQL y mysql

2007-09-02T23:09:00.001-03:00

SQL significa Lenguaje de Consulta Estructurado, y se utiliza para manipular y extraer la información de las bases de datos relacionales.

El SQL actual debe su origen a un lenguaje desarrollado por IBM en los años 70, denominado Sequel. Actualmente SQL es el lenguaje estándar de las bases de datos relacionales.

Tipos de datos:

char(n): Cadena de caracteres de longitud fija. Dónde n específica la cantidad de caracteres. Es una abreviación de character.
varchar(n): Una cadena de caracteres de longitud variable, pero con un máximo de caracteres específicado por n. Es abreviación de character varying.
int: Un subconjunto de los enteros (el rango depende generalmente de las características del equipo). Abreviación de integer.
smallint: Subconjunto de los enteros más pequeño (o igual) que el subconjunto de int. Nuevamente depende de las características del equipo.
numeric(p,d): Número real de p dígitos más el signo de los cuales d son la parte decimal.
real, double precision: Número reales con precisión no especificada por el usuario, dependiente de la máquina y de la implementación.
float(n): Real con precisión de al menos n dígitos.

Ejemplos de su manejo:

La instrucción CREATE TABLE permite crear una tabla, a continuación la creación de dos tablas relacionadas por el campo ciudad_id de cliente y el campo id de la tabla ciudad:

      CREATE TABLE cliente (
        id integer,
        nombre CHAR(100),
        apellido CHAR(100),
        ciudad_id INTEGER, primary key(id) );

      CREATE TABLE ciudad (
        id integer,
        nombre CHAR(100),
        pais_id integer, primary key(id));

En ambas elegimos como clave primaria al campo id, un entero único que identificara a cada uno de nuestros registros.

Podemos verificar que tablas existen en la base de datos actual con el comando SHOW TABLES, por ejemplo:

mysql> show tables;
+-------------------+
| Tables_in_testing |
+-------------------+
| ciudad            |
| cliente           |
+-------------------+
2 rows in set (0.00 sec)

En mysql tenemos la posibilidad de describir el esquema de una tabla con el comando DESCRIBE:

mysql> describe ciudad;
+---------+-----------+------+-----+---------+-------+
| Field   | Type      | Null | Key | Default | Extra |
+---------+-----------+------+-----+---------+-------+
| id      | int(11)   | NO   | PRI | 0       |       |
| nombre  | char(100) | YES  |     | NULL    |       |
| pais_id | int(11)   | YES  |     | NULL    |       |
+---------+-----------+------+-----+---------+-------+
3 rows in set (0.01 sec)

Ahora que tenemos las tablas deberíamos insertar valores en ellas, para esto utilizamos INSERT de la siguiente manera:

      -- En la tabla ciudad
      INSERT INTO ciudad VALUES (1,'Parana',1); 
      INSERT INTO ciudad VALUES (2,'Buenos Aires',1); 
      INSERT INTO ciudad VALUES (3,'Cordoba',1); 
      INSERT INTO ciudad VALUES (4,'Rosario',1); 
      -- En la tabla clientes
      INSERT INTO cliente VALUES (1,'Emilio','Cardozo',2);
      INSERT INTO cliente VALUES (2,'Juan','Decker',3);
      INSERT INTO cliente VALUES (3,'Facundo','Manzano',4);
      INSERT INTO cliente VALUES (4,'Romina','Casla',1);

Para realizar consultas sobre la información que contiene la base de datos, utilizamos SELECT seguido de los nombres de campos. Si utilizamos * traeremos todos los campos:

mysql> select * from cliente;
+----+---------+----------+-----------+
| id | nombre  | apellido | ciudad_id |
+----+---------+----------+-----------+
|  1 | Emilio  | Cardozo  |         2 |
|  2 | Juan    | Decker   |         3 |
|  3 | Facundo | Manzano  |         4 |
|  4 | Romina  | Casla    |         1 |
+----+---------+----------+-----------+
4 rows in set (0.00 sec)

Especificando los campos podríamos utilizar:

      mysql> select nombre, apellido from cliente;
+---------+----------+
| nombre  | apellido |
+---------+----------+
| Emilio  | Cardozo  |
| Juan    | Decker   |
| Facundo | Manzano  |
| Romina  | Casla    |
+---------+----------+
4 rows in set (0.00 sec)

Opcionalmente podemos agregar condiciones para que no traiga todos los campos detras de la clausula where:

 mysql> SELECT nombre from cliente where ciudad_id = 2;
+--------+
| nombre |
+--------+
| Emilio |
+--------+
1 row in set (0.00 sec)

La información también puede ser extraída desde diferentes tablas. Por ejemplo podemos traer el nombre de cada uno de los clientes y al lado el nombre de la ciudad a la que pertenecen (a partir del campo ciudad_id;

mysql> SELECT cliente.nombre, ciudad.nombre FROM cliente, ciudad 
       WHERE cliente.ciudad_id = ciudad.id;
+---------+--------------+
| nombre  | nombre       |
+---------+--------------+
| Romina  | Parana       |
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Facundo | Rosario      |
+---------+--------------+
4 rows in set (0.01 sec)

Tambien podemos especificar el orden de los campos agregando al final de la instruccion las palabras order by CAMPO [ASC || DESC], dónde campo puede ser el nombre del campo o un entero que represente el número de campo por el cual queremos ordernar:

      SELECT cliente.nombre, ciudad.nombre FROM cliente, ciudad 
       WHERE cliente.ciudad_id = ciudad.id ORDER BY ciudad.nombre;
+---------+--------------+
| nombre  | nombre       |
+---------+--------------+
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Romina  | Parana       |
| Facundo | Rosario      |
+---------+--------------+
4 rows in set (0.00 sec)

Supongamos que uno de nuestros clientes tiene un ciudad_id en 0, valor que no se encuentra en la tabla ciudad. Para representar esta situación insertamos la tupla:

INSERT INTO cliente VALUES (5,'Roberto','Martino',0);

Al hacer esto el select anterior que conectaba los clientes con cada una de sus ciudades sigue devolviendo lo mismo que antes (es decir sin el cliente Roberto recien insertado:

mysql> SELECT cliente.nombre, ciudad.nombre FROM cliente, ciudad
    ->WHERE cliente.ciudad_id = ciudad.id ORDER BY ciudad.nombre;
+---------+--------------+
| nombre  | nombre       |
+---------+--------------+
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Romina  | Parana       |
| Facundo | Rosario      |
+---------+--------------+
4 rows in set (0.00 sec)

Esto se debe a que no Roberto no satisface la clausula del where porque no hace match con ninguna ciudad, para salvar esta situación debemos hacer un LEFT JOIN:

mysql->  SELECT cliente.nombre, ciudad.nombre FROM cliente LEFT JOIN ciudad 
         ON cliente.ciudad_id = ciudad.id ORDER BY ciudad.nombre;
+---------+--------------+
| nombre  | nombre       |
+---------+--------------+
| Roberto | NULL         |
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Romina  | Parana       |
| Facundo | Rosario      |
+---------+--------------+
5 rows in set (0.00 sec)

De esta manera obtenemos todos los clientes y en el cliente sin ciudad obtenemos simplemente un NULL.

Muchas veces es comodo y eficiente trasladar una consulta a una vista para poder ejecutarla más fácil y rápidamente, pra esto hacemos:

mysql> CREATE VIEW ClienteCiudad AS 
          SELECT cliente.nombre AS CLIENTE, ciudad.nombre AS CIUDAD 
          FROM cliente LEFT JOIN ciudad
          ON cliente.ciudad_id = ciudad.id ORDER BY ciudad.nombre;
Query OK, 0 rows affected (0.00 sec)

Luego podemos realizar la misma consulta ejectuando un SELECT * sobre la vista:

mysql> SELECT * from  ClienteCiudad;
+---------+--------------+
| CLIENTE | CIUDAD       |
+---------+--------------+
| Roberto | NULL         |
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Romina  | Parana       |
| Facundo | Rosario      |
+---------+--------------+
5 rows in set (0.00 sec)

Para realizar actualizaciones nos valemos de UPDATE, el cual acepta la claúsula where, para especificar los registros que serán afectados durante la actualización. Por ejemplo actualizaremos la ciudad del cliente Roberto en la tabla cliente:

UPDATE cliente SET ciudad_id=3 WHERE id = 5;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Ahora al ejecutar la consulta a la vista anterior no veremos más el NULL, sino la ciudad correspondiente al la clave 4:

      mysql> SELECT * from  ClienteCiudad;
+---------+--------------+
| CLIENTE | CIUDAD       |
+---------+--------------+
| Emilio  | Buenos Aires |
| Juan    | Cordoba      |
| Roberto | Cordoba      |
| Romina  | Parana       |
| Facundo | Rosario      |
+---------+--------------+
5 rows in set (0.00 sec)

Para el borrado de registros utilizamos DELETE con la misma sintaxis que un SELECT salvo que omitiremos la seleccion de campos, por ejemplo borraremos el registro de Roberto de la tabla cliente:

mysql> select * from cliente where nombre = 'Roberto';
+----+---------+----------+-----------+
| id | nombre  | apellido | ciudad_id |
+----+---------+----------+-----------+
|  5 | Roberto | Martino  |         3 |
+----+---------+----------+-----------+
1 row in set (0.00 sec)

mysql> DELETE from cliente where nombre = 'Roberto';
Query OK, 1 row affected (0.00 sec)

mysql> select * from cliente where nombre = 'Roberto';
Empty set (0.00 sec)

En las consultas con SELECT podemos preguntar directamente por la cantidad de registros que traería una consulta aplicando COUNT() a la selección de campos:

mysql> SELECT COUNT(*) FROM cliente;
+----------+
| COUNT(*) |
+----------+
|        4 |
+----------+
1 row in set (0.00 sec)

Memoria Dinámica en Pascal

2007-07-25T22:41:00.001-03:00

La siguiente introducción a estructura dinámicas básicas está básada en los procedimientos estándar de la cátedra de mi facultad: Algoritmos y Estructuras de Datos de la Universidad Tecnológica Nacional de Buenos Aires, escritos por Sergio Fernando Abad.

Memoria Dinámica en Pascal

En teoría los programas PASCAL permiten utilizar 64KB de memoria estática.

Esto generalmente no es suficiente para aplicaciones reales, por eso pascal nos permite acceder a un sector de memoria que puede administrar el programador, tomando y liberando memoria arbitrariamente mientras las capacidades de la computadora en dónde ejecuta el programa lo permitan.

En memoria dinámica hay tres estructuras de datos principales que implementaremos en los ejemplos, a saber:

Listas
Pilas
Colas

Punteros

Hay un tipo de variable que nos permitirá construir las estructuras dinámicas. A esta variable se la conoce como Puntero, y es una variable de tipo estática pero con la particularidad de que su dominio de valores son las direcciones de memoria disponibles para el programador.

Esto significa que la variable tendrá como contenido una dirección de memoria (que puede ser la dirección dónde se encuentra, alguna otra variable, incluso la dirección dónde se encuentra otro puntero).

En PASCAL, declaramos los punteros con el símbolo ^ y una dirección de memoria a la cual lo hacemos apuntar. El tamaño que ocupa un puntero está dado por el tamaño necesario para almacenar una dirección de memoria, en muchas PCs hogareñas este valor suele ser 4 bytes.

    VAR PUNTERO:^INTEGER;

En el código anterior hemos declarado un puntero llamado PUNTERO que está apuntando a un tipo de dato entero, es decir que en él podemos almacenar valores de direcciones de memoria dónde se encuentren enteros.

Si bien el puntero está listo para guardar una dirección aún no lo hemos inicializado con ninguna dirección, el siguiente paso es reservar la memoria de un entero en el área de HEAP (dónde se aloca la memoria solicitada dinámicamente) y guardar la dirección de ese lugar en el puntero.

Para realizar esto utilizamos la instrucción NEW(), en caso de que la máquina no obtenga memoria para alocar el pedido, al puntero se le asignara la dirección NIL, cuyo significado es la "nada", es decir el puntero no apunta a ningún sector de la memoria.

Al terminar de utilizar la memoria a la cual accedíamos con el puntero, lo recomendable es siempre liberarla, para que quede disponible para otras aplicaciones que soliciten memoria.

Ahora bien, tiene sentido que uno quiera acceder al valor de lo que uno hasta el momento sólo conoce la dirección que almacena el puntero. Pascal nos permite referirnos al valor que se encuentra en la dirección de memoria de un puntero simplemente utilizando el nombre del puntero seguido inmediatamente por el símbolo ^.

    PUNTERO^ := 25;
    WRITELN( PUNTERO^ );

En las dos instrucciones anteriores hemos asignado al entero al cual apunta PUNTERO con 25, y luego hemos mostrado tal valor por pantalla.

Otro ejemplo, que muestra la diferencia entre el valor de un puntero y el valor que se haya en la dirección de memoria que guarda el puntero

    PROGRAM PUNTEROS_01;
    VAR
      PUNTERO:^INTEGER;
      AUXILIAR:^INTEGER;
    BEGIN
      NEW(PUNTERO);
      PUNTERO^:= 154;
      AUXILIAR:= PUNTERO;
      WRITELN( PUNTERO^ );
      WRITELN( AUXILIAR^ );
      DISPOSE(PUNTERO);
    END.

En el ejemplo anterior se ve el uso de las dos funcionalidades del puntero, cuando asignamos la dirección de memoria que contiene PUNTERO como valor, no utilizamos el símbolo ^, debido a que justamente estamos guardando la dirección en otro puntero llamado AUXILIAR. En cambio cuando queremos imprimir los valores de los enteros a los cuales apuntan (en este caso ambos apuntan a lo mismo) debemos utilizar el el símbolo ^.

NODOS

Un nodo es una pequeña estructura especialmente creada por el programador, para poder crear otras estructuras tales cómo Listas o Colas en memoria dinámica.

Los nodos guardan en una parte de la estructura la información que justamente requiere guardar nuestra aplicación o programa, en la otra parte tenemos un puntero que guarda la dirección de otro nodo.

Debido a que un nodo posee un puntero que permite almacenar una dirección de otro nodo, podemos valernos de él para enlazar múltiples nodos entre sí y hacer nuestras estructuras más complejas y alocarlas en memoria dinámica.

Ejemplo de definición:

    TYPE
      TipoLista =^ TipoNodo;
      TipoNodo = Record
        Info:TipoInfo;
        Siguiente:TipoLista
      END;

En la definición anterior en la primer instrucción declaramos un tipo de puntero llamado TipoLista que apunta a un registro TipoNodo, el cual aún no está definido hasta la siguiente línea, de hecho al momento de definir el tipo TipoNodo indicamos que la variable Siguiente es un puntero a un tipo de dato TipoLista. Esta forma de definición recursiva es totalmente legal y nos permite construir los nodos.

Listas

Llamamos Lista a una variable de tipo puntero que apunta a un nodo.

Ese nodo puede apuntar a otro nodo y este último a un próximo, por lo tanto podemos hablar de ciertas operaciones posibles en una Lista, como por ejemplo: insertar nodo al final, insertar al principio, insertar en el medio, buscar nodo, sacar del final, sacar del principio, etc.

Crear Lista

Ejemplo de procedimiento que crea una Lista:


    PROCEDURE CrearLista (VAR Lista:TipoLista);
    BEGIN
      Lista := NIL
    END;

El código anterior recibe un puntero y lo inicializa en NIL.

Insertar primer Nodo

Ejemplo de procedimiento que inserta el primer nodo de una Lista:

    PROCEDURE InsertaPrimero (VAR Lista:TipoLista; Valor:TipoInfo);
    VAR
      Ptr:TipoLista;
    BEGIN
     New(Ptr);
     Ptr^.Info := Valor;
     Ptr^.Siguiente := NIL;
     Lista := Ptr;
    END;

El código anterior recibe la Lista en la cual vamos a insertar un primer nodo, y el valor de la información que contendrá este nodo. Dentro del procedimiento tenemos una variable local a él, que la reservamos con la instrucción New(Ptr), luego le asignamos el valor recibido como parámetro e indicamos que este primer nodo apunta a NIL, por último debemos apuntar la lista a este nodo recien creado.

Insertar adelante

Ejemplo de procedimiento inserta un nodo para que sea el primero de la lista:

    PROCEDURE InsertaAdelante (VAR Lista:TipoLista; Valor:TipoInfo);
    VAR
      Ptr:TipoLista;
    BEGIN
      New(Ptr);
      Ptr^.Info := Valor;
      Ptr^.Siguiente := Lista;
      Lista := Ptr;
    END;

Nuestro objetivo es insertar un nodo que sea el primero de la lista, para esto recibimos como parámetro la Lista en la cual queremos insertar el nodo y el valor que guardará como información el nodo. Creamos el nodo, guardamos la información recibida, y le decimos al nuevo nodo que apunte a dónde está apuntando actualmente la Lista, resguardada esta dirección podemos decirle a Lista que apunte al nuevo nodo, de esta manera el nodo queda insertado al principio de todo.

Insertar con Orden

Ejemplo de procedimiento que dada una Lista y un valor inserta un nodo dónde corresponda según el valor que se pase por paramétro:

    PROCEDURE InsertaEnOrden (VAR Lista:TipoLista ; Valor:TipoInfo);
    VAR
      Ptr, PtrAux : TipoLista;
    BEGIN
      New(Ptr);
      Ptr^.Info := Valor;
      Ptr^.Siguiente := NIL;
      PtrAux := Lista;
      WHILE ( PtrAux^.Siguiente <> NIL )  AND ( Valor > PtrAux^.Siguiente^.Info ) do
        PtrAux := PtrAux^.Siguiente;
      Ptr^.Siguiente := PtrAux^.Siguiente;
      PtrAux^.Siguiente := Ptr;
    END;

Este código es algo más complejo. Para empezar como siempre que se trate de una inserción debemos recibir el valor y la lista en dónde insertar. Luego creamos dos variables locales, Ptr y PtrAux, la primera es el nuevo nodo a insertar y la segunda será un auxiliar para recorrer la lista y encontrar la posición adecuada al nodo. Debido a que esta última variable sólo nos vale para encontrar la posición no hace falta que le reservemos memoria ya que le asignaremos direcciones de memoria ya reservada, en cambio para Ptr sí que debemos hacerlo porque justamente representa nuestro nuevo nodo. Por lo tanto guardamos el valor pasado por parámetro en este, y luego lo hacemos apuntar a NIL.

Para la búsqueda del lugar adecuado, asignamos a nuestro auxiliar al principio de la lista, y luego lo hacemos avanzar evaluando siempre que no estamos parados en el último nodo y que el Valor que queremos insertar es mayor que el Info del nodo siguiente al cual estamos apuntando. La manera de avanzar es bien sencilla y es obligar a PtrAux que apunte al nodo siguiente.

Al momento del salir del While indefectiblemente PrtAux estará apuntando al último nodo o bien a un nodo cuyo valor es el mayor de todos los valores menores al nuevo Valor. Es decir que estamos insertando al nuevo nodo ordenadamente de manera ascendente según el valor que trae y los valores de los nodos ya existentes en la lista.

Insertar Nodo

Recapitulando tenemos una serie de procedimientos que nos permiten insertar de diferente manera nodos en una Lista, ahora nos valeremos de todos ellos para crear un procedimiento Insertar Nodo genérico que según el valor dado inserte el nodo en la posición más conveniente:

    PROCEDURE InsertaNodo (VAR Lista:TipoLista; Valor:TipoInfo);
    BEGIN
     IF Lista = NIL THEN
       InsertarPrimero(Lista,Valor);
     ELSE
       IF Valor < Lista^.Info THEN
         InsertarAdelante(Lista,Valor);
       ELSE
         InsertaEnOrden(Lista,Valor);
    END;

El procedimiento InsertaNodo no utiliza variables locales, simplemente evalua a que procedimiento llamar para insertar el nuevo valor en la Lista pasada por parametro. Si la lista está vacía utiliza el procedimiento de insertar el primer nodo, si la lista ya contiene nodos entonces evalua sí el nodo debe ser ir adelante de todo o debemos meterlo por el medio. ¿Se te ocurre alguna manera de generalizar InsertaEnOrden para que pueda tratar con todas las situaciones? Me gustaría ver tu solución en los comentarios.

Suprimir Nodo

Mostramos ahora un procedimiento que suprime nodos de una Lista:

    PROCEDURE SuprimeNodo (VAR Lista:TipoLista ;  Valor:TipoInfo );
    VAR
      PtrAct , PtrAnt : TipoLista;
    BEGIN
      PtrAct := Lista;
      PtrAnt := NIL;
      WHILE ( PtrAct <> NIL ) AND ( Valor > PtrAct^.Info ) DO
      BEGIN
        PtrAnt := PtrAct;
        PtrAct := PtrAct^.Siguiente;
      END;
      IF ( PtrAct <> NIL ) AND ( Valor = PtrAct^.Info ) THEN
      BEGIN
 If PtrAnt <> NIL THEN
   PtrAnt^.Siguiente := PtrAct^.Siguiente
 ELSE
   Lista := PtrAct^.Siguiente;
 DISPOSE (PtrAct);
      END
    END;

Al procedimiento SuprimeNodo le pasamos la Lista de la cual queremos quitar un nodo y el Valor del nodo que queremos suprimir.

Como variables locales al procedimiento tenemos dos punteros auxiliares para realizar la operación de borrado. La idea es recorrer la lista con ellos, uno apuntando una posición más que el otro, cuando PtrAct se apunte a un nodo cuyo valor es menor que el del parámetro Valor detenemos la recorrida, si esto nunca sucede detendremos la recorrida al momento que PtrAct alcance el fin de la lista.

Al finalizar el WHILE debemos preguntarnos si el nodo al cual apunta PtrAct es realmente el nodo con el valor buscado, si realmente es así todavía tenemos que evaluar si PtrAnt se encuentra apuntando a NIL (el nodo a eliminar es el primero), o está apuntando a un valor distinto de NIL lo cual nos dice que éste nodo es el que debemos colgar de la dirección a la cual dejará de apuntar el nodo próximo a elminar (PtrAct).

Por último, si bien hemos quitado el nodo de la Lista, aún no hemos liberado la memoria que este ocupa, para esto utilizamos la instrucción antes mencionada, Dispose.

Pilas

La Pila es una Lista a la que sólo se le permite insetar y quitar nodos por el principio.

Con tal concepto y con los procedimientos escritos para la Lista no es díficil tomar un subconjunto de estos y crear la Pila y procedimientos para manipularla.

Crear Pila

  
    PROCEDURE CrearPila ( VAR Pila : TipoPila );
    BEGIN
      Pila := NIL;
    END

Nuevamente recibimos por referencia el nombre de la pila y la inicializamos en nil

Insertar PUSH

Este procedimiento es común encontrarlo escrito en su traducción en inglés Push:

    PROCEDURE Insertar ( VAR Pila:TipoPila ; Valor:TipoInfo);
    VAR
      Ptr:TipoPila;
    BEGIN
      New(Ptr);
      Ptr^.Info := Valor;
      Ptr^.Siguiente := Pila;
      Pila := Ptr;
    END;

En el código anterior, recibimos la Pila y un Valor, localmente con el puntero Ptr alocamos la memoria dinámica y asignamos el valor al nuevo nodo, a este lo hacemos apuntar al primer nodo al que apunta la Pila, y por último a la Pila la hacemos apuntar al nuevo puntero. De esta manera acabamos de insertar el nuevo nodo al principio de la pila.

Sacar POP

Nuevamente a este procedimiento se lo suele llamar Pop en muchos programas:

    PROCEDURE Pop ( VAR Pila:TipoPila ; VAR Valor:TipoInfo);
    VAR
      Ptr:TipoPila;
    BEGIN
      Ptr := Pila;
      Pila := Ptr^.Siguiente;
      Valor := Ptr^.Info;
      DISPOSE(Ptr);
    END;

Aquí agarramos con un puntero local al procedimiento al primer nodo de la pila y luego hacemos a apuntar a ésta última al siguiente nodo. Antes de liberar la memoria del nodo "sacado", asignamos su valor al parametro por referencia Valor, luego sí estamos en condiciones de liberarlo con DISPOSE.

Colas

Una Cola es otro tipo de lista que restringe las operaciones, la idea es insertar siempre al principio (tal como se inserta en una pila) y luego retirar del final.

Cuando retiramos un nodo de una Cola sabemos qué este es el nodo más antiguo (que entró hace más tiempo) de todos de los que están presente en la Cola al momento de retirar.

Para poder realizar estas operaciones debemos tener presente que hará falta tener dos punteros, uno apuntando al principio de la cola, y otro auxiliar apuntando al final de ésta.

Crear Cola

Aquí las cosas difieren un poco ya que aparecen los dos punteros de los que hablabamos para mantener la dirección del principio y del fin de la Cola.

    PROCEDURE CrearCola (VAR Cprin , Cfin : TipoCola );
    BEGIN
      Cprin := NIL;
      Cfin := NIL;
    END;

Insertar Nodo

Recordemos que esta operación está restringida a insertar al principio:

    PROCEDURE Insertar (VAR Cprin,Cfin:TipoCola; Valor:TipoInfo);
    VAR
      Ptr:TipoCola;
    BEGIN
      New(Ptr);
      Ptr^.Info := Valor;
      Ptr^.Siguiente := NIL;
      IF (Cprin = NIL) THEN
        Cprin := Ptr
      ELSE
        Cfin^.Siguiente := Ptr;
      Cfin := Ptr;
    END;

Recibimos el principio y el final de la cola y el valor para insertar el nuevo nodo. Alocamos la memoria del nuevo nodo, asignamos su valor y lo hacemos apuntar a NIL (recordemos que va a entrar al principio). Ahora evaluamos si la Cola está vacia, si esto sucede le asignamos este nuevo nodo a Cprin, en caso contrario lo el que debe apuntar a ese lugar es el nodo al cual actualmente apunta Cfin, en cualquier caso Cfin tiene que apuntar al nuevo nodo creado.

Sacar Nodo

Recordemos que ahora queremos sacar nodos desde el final:

    PROCEDURE Suprimir (VAR Cprin, Cfin:TipoCola ; Var:TipoInfo);
    VAR
     Ptr:TipoCola;
    BEGIN
      Ptr:=Cprin;
      Valor := Cprin^.Info;
      Cprin := Cprin^.Siguiente;
      If (Cprin = NIL) THEN
        CFin := NIL;
      DISPOSE(Ptr)
    END;

Antes de soltar al último nodo resguardamos su dirección en Ptr, posteriomente avanzamos en uno a Cprin y luego nos fijamos si la cola quedó vacia, en tal caso Cfin debe tomar la dirección NIL.

Cómo siempre liberamos la memoria que estaba ocupando el nodo quitado de la cola.

Introducción a COBOL

2007-07-22T13:23:00.001-03:00

Algunas nociones de COBOL traducidas libremente desde el libro Programming Guide Enterprise COBOL for z/OS de IBM

COBOL

COBOL es un lenguaje de programación desarrollado en el año 1960 por un consorcio de fabricantes de computadoras y el Departamento de Defensa de Estados Unidos.

El nombre es un acrónimo de COmmon Business Oriented Language.

Divisiones

Un programa COBOL cuenta con cuatro divisiones: IDENTIFICATION DIVISION, ENVIRONMENT DIVSION, DATA DIVSION, y la PROCEDURE DIVISION. Cada una cumple una función lógica especial.

El programa mínimo, debe al menos contar con la IDENTIFICATION DIVISION.

IDENTIFICATION DIVSION

La IDENTIFICATION DIVISION permite nombrar al programa e informar otra información opcional como el autor, la fecha de escritura, etc.

Ejemplo:

 
IDENTIFICATION DIVISION.
PROGRAM-ID.    ProcesoA.
AUTHOR.        Emilio Astarita.
INSTALLATION.  Universidad Tecnologica Nacional.
DATE-WRITTEN.  07/12/2007.
DATE-COMPILED. 07/12/2007.

El párrafo PROGRAM-ID da nombre al programa, y se utiliza para las siguientes funciones:

Es el nombre con el cual otros programas pueden hacer llamadas a tu programa.
Es el nombre que aparece en la cabecera del listado generado por el compilador
Si se utiliza la opción NAME en el compilador, cuando se genere el objeto contendrá este nombre, de esta manera será más fácil identificar al objeto.

Programas recursivos

Si se agrega el atributo RECURSIVE en la claúsula PROGRAM-ID se específica que el programa puede ser ejecutado recursivamente mientras una invocación anterior está aún activa.

Los sub-programas no pueden utilizar este atributo.

Estado inicial

Se puede utilizar el atributo INITIAL para especificar que cada vez que otro programa haga una llamada a este programa se inicializará a su estado inicial. Esto es debido a que por defecto los programas conservan el estado de las variables de la última ejecución producida por una llamada.

Con este atributo el programa inicializará todas las variables con el valor específicado por la claúsula VALUE (cuando exista) y los archivos son cerrados apropiadamente en caso de estar abiertos.

ENVIRONMENT DIVISION

En la ENVIRONMENT DIVISION se específican los items:

La plataforma en la que se compilará el programa, párrafo: SOURCE-COMPUTER.
La plataforma que ejecutará el programa, párrafo: OBJECT-COMPUTER.
Opciones especiales, cómo el trato del signo, el identificador del carácter decimal etc, párrafo: SPECIAL-NAMES.
Aquí también definiremos una sección muy importante que describe las entradas y salidas del programa: sección INPUT-OUTPUT SECTION

INPUT-OUTPUT SECTION

Principalmente describe las carácteristicas de los archivos con los que tratará el programa. Los asocia a los archivos externos y describe sus atributos.

Ejemplo:

SELECT ENTRADA
  ASSIGN TO "ENTRADA.TXT"
  ORGANIZATION IS SEQUENTIAL
  ACCESS IS LINE SECUENTIAL

En el código anterior estamos relacionando en nombre lógico ENTRADA al archivo de nombre físico ENTRADA.TXT, en el resto del programa nos referiremos a él con su nombre lógico.

La clausula ORGANIZATION específica el tipo de organización que tienen los datos de nuestro archivo y ACCESS específica el modo en el que se leera.

DATA DIVISION

En esta tercer división definiremos los datos correctamente con nombres y tipos.

Particularmente en la FILE SECTION se describen los datos que se utilizarán en las operaciones de entrada y salida. Y en esta división aún contamos con 3 secciones más de mucha importancia:

WORKING-STORAGE SECTION: dónde se definen las variables estáticas que se inicializan y ocupan memoria durante todo el tiempo que el programa este en ejecución (en el caso de un sub-programa estas variables mantendrán el estado en el que fueron dejadas por la última llamada del programa).
LOCAL-STORAGE SECTION: a diferencia de la WORKING-STORAGE estos datos se alocaran e inicializarán cada vez que el programa sea llamado.
LINKAGE SECTION: Esta es un área compartida de comunicación entre programas y subprogramas.

FILE SECTION

Ejemplo:

       FILE SECTION.
          FD ENTRADA.
            01 REGISTRO-ENTRADA.
              02  CLAVE          PIC 9(10).
              02  DATOS.
                 03 NOMBRE        PIC X(15).
                 03 APELLIDO      PIC X(15).

En este ejemplo estamos describiendo la estructura de datos del archivo de nombre lógico ENTRADA, de él decimos que tiene en las primeras diez posiciones un campo llamado CLAVE y las restantes 30 posiciones traen en el NOMBRE y APELLIDO de 15 posiciones cada uno.

Este registro (REGISTRO-ENTRADA) queda asociado directamente al archivo, esto significa que sobre él haremos las operaciones de lectura (READ) y escritura (WRITE).

WORKING-STORAGE SECTION

Cómo dijimos aquí escribiremos las definiciones de las variables locales del programa, veamos el siguiente ejemplo:

       WORKING-STORAGE SECTION.
          01 W000-AGRUPACION-NIVEL-1.
            03 W000-NIVEL-3.
               05 W000-NIVEL-5 PIC X(08).
               05 W000-OTRO-NIVEL-5 PIC X(08).
          01 W000-PAIS        PIC X(09) VALUE 'ARGENTINA'.
          01 A000-LEIDOS-E1   PIC 9(09) COMP-3.
          01 A000-LEIDOS-E2   PIC 9(09) VALUE ZEROES.
          01 A000-ESCRITOS    PIC 9(09) VALUE ZEROES.

En el código anterior, estuvimos definiendo variables sencillas, númericas y alfanúmericas.

En primer lugar tenemos el nivel del dato que estamos definiendo, los niveles 01 son el nivel superior y a medida que aumentamos el número definimos campos agrupados.

Noten que podemos referirnos a las variables contiguas W0000-NIVEL-5 y W000-OTRO-NIVEL-5 cómo W000-NIVEL-3. Este modo de agrupamiento nos permite gran flexibilidad para referirnos a diferentes partes de un registro o hacer movimientos completos de varios niveles inferiores utilizando el nombre de dato que los agrupa.

Inmediatamente después del nombre que define a la variable observamos la plabra PIC que es una abreviación de PICTURE con ella damos aviso de que vamos a especificar el tipo de dato de un campo. X en el caso de campos alfanúmericos y 9 en el caso de los númericos.

En el caso de los númericos podemos especificar la manera en que debe almacenarse el dato en la variable, aunque ya veremos al detalle más definiciones ponemos en uso a COMPUTATIONAL-3, que la utilizamos abreviadamente escribiendo COMP-3.

Por último tenemos la claúsula VALUE con la que damos un valor inicializador a la variable.

A grandes rasgos hemos descripto algunas de las formas que puede adoptar la WORKING-STORAGE SECTION.

PROCEDURE DIVISION

En la PROCEDURE DIVISION escribiremos las intrucciones que definen el proceso de los datos. Aquí se escribiran todas las decisiones, movimientos. cálculos y llamadas a otros programas.

PROCEDURE DIVISION USING...

Nos podemos valer de la claúsula USING DATO en el encabezado de la PROCEDURE DIVISION, dónde DATO es el nombre de un dato que traerá un valor externo, asignado por otro programa o por el ambiente en que se ejecute nuestro programa. Este dato debe estar declarado previamente en el área de comunicación (LINKAGE-SECTION).

SECCIONES, PÁRRAFOS, SENTENCIAS e INSTRUCCIONES

La PROCEDURE DIVISION puede dividirse en secciones y párrafos, que contengan sentencias, declaraciones y frases.

SECTION

Es una subdivisión lógica. Una sección tiene un encabezado y opcionalmente pueden seguirle uno o varios párrafos.

PARAGRAPH

Es una subdivisión de una SECTION, PROCEDURE, o programa.

Un párrafo es un nombre seguido por un punto y una o más sentencias.

SENTENCE

Una de serie de una o más declaraciones COBOL que terminan con un punto.

STATEMENT

Realiza un paso de procesamiento COBOL, como la suma de dos números.

Una instrucción es la combinación válida de palabras, y comienzan con un verbo COBOL. Las declaraciones son imperativas (indicando una acción incondicional), o una directiva del compilador.

PHRASE

Una subdivisión de un STATEMENT.

Instrucciones

Las instrucciones imperativas son verbos tales como ADD, MOVE, o CLOSE.

También contamos con instrucciones condicionales tales como IF, EVALUATE, y SEARCH).

Directivas del compilador

Como su nombre lo indica las directivas del compilador nos permiten darle ciertas órdenes como incluir otro archivo fuente al momento de compilar en un lugar dado.

Por ejemplo COPY es parecido al include de C, que inserta el contenido de otro archivo en el lugar en dónde se declara.

Delimitadores de alcance

Podemos utilizar el delimitador punto . para determinar el final del alcance de una instrucción, este terminador es ímplicito. El explicito se forma con la palabra reservada END, un guión -, seguido por último por el nombre de la sentencia a la que se quiere delimitar su alcance.

En el siguiente ejemplo se muestran una serie de instrucciones equivalentes:


IF REGISTRO = HIGH-VALUES 
   DISPLAY 'SE TERMINÓ DE LEER TODO EL ARCHIVO'
.

IF REGISTO = HIGH-VALUES
   DISPLAY 'SE TERMINÓ DE LEER TODO EL ARCHIVO'
END-IF

Siempre es preferible utilizar terminadores de alcance explícitos debido a que es más visible ver alcance.

Otro ejemplo:

READ REGISTRO-ENTRADA
AT END
  MOVE HIGH-VALUES TO R000-CLAVE
END-READ

READ REGISTRO-ENTRADA
AT END
  MOVE HIGH-VALUES TO R000-CLAVE.

Variables

Una variable es un dato cuyo valor puede cambiar durante la duración del programa. El valor está restringido al tipo y al tamaño de dato que con el que se definió.

Por ejemplo:

WORKING-STORAGE SECTION.
01 CLIENTE PIC X(020).
01 CLIENTE-MOROSO PIC X(020).
....
PROCEDURE DIVISION.
 MOVE CLIENTE TO CLIENTE-MOROSO

En este caso vemos la definición de dos datos de tipo y tamaño idéntico en la DATA DIVISION. Luego en la PROCEDURE DIVISION hacemos el movimiento del contenido de CLIENTE al de CLIENTE-MOROSO.

Jerarquización de datos

Los datos relacionados pueden ser parte de una estructura jerarquizada. Un campo de dato que tenga otros subordinados se llama campo elemental. Un campo que agrupe a otros de menor jerarquía es llamado un campo de agrupación.

Por ejemplo:

WORKING-STORAGE SECTION.
01 CLIENTE.
  05 NOMBRE PIC X(25).
  05 APELLIDO PIC X(25).
01 CLIENTE-ANTERIOR PIC X(50).
  05 NOMBRE PIC X(25).
  05 APELLIDO PIC X(25).
PROCEDURE DIVISION.
  MOVE CLIENTE TO CLIENTE-ANTERIOR
  MOVE SPACES  TO NOMBRE OF CLIENTE
  MOVE SPACES  TO APELLIDO OF CLIENTE-ANTERIOR

En este caso definimos dos campos de agrupación que contienen dos campos elementales cada uno. Cómo vemos podemos hacer un movimiento completo de estos dos, utilizando su nivel de agrupación mayor para referirnos a ambos. Notar también que se permite utilizar en los items subordinados variables del mismo nombre pero al momento de referirnos a ellas debemos mencionar la claúsula OF seguida del nombre de campo de un nivel superior para que el compilador pueda superar la ambiguedad.

Literales

Un literal es una secuencia de carácteres encerrados entre comillas en el caso de los literales alfanúmericos y simplemente un número en el caso de los númericos.

Con el podemos asignar directamente el valor a variables de tipo X.

Por ejemplo:

MOVE "JORGE GRIPPO" TO NOMBRE OF CLIENTE
MOVE 14 TO EDAD OF CLIENTE

Los MOVE anteriores son la asignación del literal de cadena JORGE GRIPPO y del literal númerico 14 a las variables NOMBRE y EDAD respectivamente.

Constantes

A diferencia de otros lenguajes COBOL, desgraciadamente no tiene una forma de definir constantes, esto es variables con un valor específicado al inicio del programa y que no puedan ser modificadas.

Sin embargo podemos valernos de la claúsula VALUE para setear un valor inicializador de una variable, aunque esto no impide manera alguna que por error en otra sección del programa se cambie el contenido de la variable.

Ejemplo:

  01 CLIENTE-DEFAULT PIC X(50) VALUE 'CLIENTE NO DEFINIDO - ERROR SISTEMA'.

Constantes figurativas

Nos podemos referir a muchos literales mediante una palabra, a estas se las llama constantes figurativas, por ejemplo: SPACES ZERO ZEROES HIGH-VALUE LOW-VALUES etc.

Apareo sencillo en COBOL

2007-07-16T19:51:00.001-03:00

Vamos a ver ahora un típico programa COBOL de apareo, muy común en bancos y otros negocios en dónde se necesitan procesar grandes lotes de datos.

Casi todos los programas COBOL tienen un flujo de programa estándar como el que se visualiza en la figura de abajo

En 100-INICIO nos aseguramos de realizar la apertura de archivos, la primer lectura de los mismos, y la inicialización de las variables necesarias.

En 200-PROCESO escribiremos la lógica que maneje el apareo.

Por último en 300-FINAL, cerraremos los archivos y mostraremos el resumen del proceso.

En la figura siguiente mostramos el flujo de proceso de 100-INICIO

La próxima figura muestra el flujo de 200-PROCESO. Que consiste en la evaluación de las claves de los archivos. Hacemos avanzar uno u otro según la comparación, y cuando las claves son iguales procesamos y grabamos la salida.

Es importante notar que 200-PROCESO se ejecutará hasta que se de la condición planteada por el UNTIL, que es el fin de archivo de la ENTRADA1.

Por último tenemos la figura de 300-FINAL, dónde simplemente cerramos los archivos.

El código siguiente muestra el programa completo, en dónde se obtienen las edades (ENTRADA2) de una serie de personas (ENTRADA1), la información que apareó se escribe en el archivo de SALIDA.

El programa fue compilado con el compilador OpenCobol y testeado en GNU/Ubuntu.

      ************************************************
      *  DESCRIPCION: ESTE PROGRAMA OBTIENE LAS EDA- *
      *  DES DE LAS PERSONAS LEIDAS EN EL ARCHIVO 1  *
      *  A PARTIR DEL ARCHIVO 2 DE EDADES.           *
      *                                              *
      *  WEB:   HTTP://CODIGOMALDITO.BLOGSPOT.COM    *
      *                                              *
      ************************************************

       IDENTIFICATION DIVISION.
       PROGRAM-ID.  LECTURA.
       AUTHOR.  B MITRE.
       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.

         SELECT ENTRADA1 ASSIGN TO "ENTRADA1.TXT"
           ORGANIZATION IS LINE SEQUENTIAL 
         FILE STATUS FS-ENTRADA1.

         SELECT ENTRADA2 ASSIGN TO "ENTRADA2.TXT"
            ORGANIZATION IS LINE SEQUENTIAL
         FILE STATUS FS-ENTRADA2.

         SELECT SALIDA ASSIGN TO "SALIDA.TXT"
            ORGANIZATION IS LINE SEQUENTIAL
         FILE STATUS FS-SALIDA.

                          
       DATA DIVISION.
                       
       FILE SECTION.

          FD ENTRADA1.
            01 REGISTRO-ENTRADA1.
              02  CLAVE1          PIC X(10).
              02  DATOS1.
                 03 NOMBRE        PIC X(15).
                 03 APELLIDO      PIC X(15).
                                                
          FD ENTRADA2.                            
            01 REGISTRO-ENTRADA2. 
              02  CLAVE2          PIC X(10).
              02  DATOS2.                    
                03 EDAD           PIC X(02).
                                                                        
          FD SALIDA.                    
          01 REGISTRO-SALIDA.              
            02  SAL-CLAVE         PIC X(10).
            02  ESPACIOS          PIC X(02) VALUE SPACES.
            02  SAL-NOMBRE        PIC X(15).
            02  SAL-APELLIDO      PIC X(15).
            02  SAL-EDAD          PIC X(02).
                                
                                                                                
                                                                       
       WORKING-STORAGE SECTION.
                                                              
                                                                    
      *           FILE STATUS                                             
          01 FS-ENTRADA1      PIC X(02) VALUE ZEROES.
          01 FS-ENTRADA2      PIC X(02) VALUE ZEROES.
          01 FS-SALIDA        PIC X(02) VALUE ZEROES.
                                                                           
                                                                        
      *           ACUMULADORES                                
          01 A000-LEIDOS-E1   PIC 9(09) VALUE ZEROES.              
          01 A000-LEIDOS-E2   PIC 9(09) VALUE ZEROES.               
          01 A000-ESCRITOS    PIC 9(09) VALUE ZEROES.            
                                                                
      *           SWITCHES
          01 S000-FIN-E1      PIC X(01) VALUE 'N'.
           88 S000-FIN-E1-SI   VALUE 'S'.
           88 S000-FIN-E1-NO   VALUE 'N'.

          01 S000-FIN-E2      PIC X(01) VALUE 'N'.
           88 S000-FIN-E2-SI   VALUE 'S'.
           88 S000-FIN-E2-NO   VALUE 'N'.
                                               
          01 W000-ABEND.
            02 W000-ABEND-OBJETO       PIC X(15).
            02 W000-ABEND-CODIGO       PIC X(05). 
            02 W000-ABEND-DESCRIPCION  PIC X(50).                              
                             
       PROCEDURE DIVISION.

      ****************************************** 
      * -------------------------------------- *
      * |              FLUJO                 | *
      * -------------------------------------- *
      ******************************************
          PERFORM 100-INICIO.                   

          PERFORM 200-PROCESO                   
            UNTIL S000-FIN-E1-SI.                

          PERFORM 300-FINAL.                   
 
      ****************************************
      * ------------------------------------ *      
      * |      DEFINICION DE PARRAFOS      | *
      * ------------------------------------ *
      ****************************************


      ****************************************
      *         100-INICIO                   *
      ****************************************
         100-INICIO.
            PERFORM 103-ABRIR-ARCHIVOS


            PERFORM 101-LEER-ENTRADA1
            IF FS-ENTRADA1 = '10'
              MOVE 'ARCHIVO VACIO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA1 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA1'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF             


            PERFORM 102-LEER-ENTRADA2
            IF FS-ENTRADA2 = '10'
              MOVE 'ARCHIVO VACIO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA2 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA2'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF             


          .

      ****************************************
      *         200-PROCESO                  *
      ****************************************
          200-PROCESO.                                         
          IF ( CLAVE1 > CLAVE2 ) 
                PERFORM 102-LEER-ENTRADA2
            ELSE 
              IF ( CLAVE1 <   CLAVE2)
                PERFORM 101-LEER-ENTRADA1
              ELSE
                INITIALIZE REGISTRO-SALIDA
                MOVE NOMBRE TO SAL-NOMBRE
                MOVE APELLIDO TO SAL-APELLIDO 
                MOVE EDAD   TO SAL-EDAD
 
                MOVE CLAVE1 TO SAL-CLAVE
                PERFORM 201-ESCRIBIR-SALIDA

                PERFORM 101-LEER-ENTRADA1
              END-IF
            END-IF
          .
      ****************************************
      *         300-FINAL                    *
      ****************************************
          300-FINAL.
           PERFORM 301-CERRAR-ARCHIVOS.
           PERFORM 302-MOSTRAR-RESUMEN.
           STOP RUN
         .
      ****************************************
      *         101-LEER-ENTRADA1            *
      ****************************************
          101-LEER-ENTRADA1.
            READ ENTRADA1
             AT END
               SET S000-FIN-E1-SI TO TRUE
               MOVE HIGH-VALUES TO CLAVE1
             NOT AT END
               ADD 1 TO A000-LEIDOS-E1
         .   



      ****************************************
      *         102-LEER-ENTRADA2            *
      ****************************************
          102-LEER-ENTRADA2.
            READ ENTRADA2
             AT END
               SET S000-FIN-E2-SI TO TRUE
               MOVE HIGH-VALUES TO CLAVE2
             NOT AT END
               ADD 1 TO A000-LEIDOS-E2
         .   

      ****************************************
      *         103-ABRIR-ARCHIVOS           *
      ****************************************
          103-ABRIR-ARCHIVOS.
            OPEN INPUT ENTRADA1
            IF FS-ENTRADA1 NOT = '00'
              MOVE 'ERROR AL ABRIR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA1 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA1'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 
            OPEN INPUT ENTRADA2
            IF FS-ENTRADA2 NOT = '00'
              MOVE 'ERROR AL ABRIR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA2 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA2'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 
            OPEN OUTPUT SALIDA
            IF FS-SALIDA NOT = '00'
              MOVE 'ERROR AL ABRIR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-SALIDA TO W000-ABEND-CODIGO
              MOVE 'SALIDA'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 

         .   
      ****************************************
      *         201-ESCRIBIR-SALIDA          *
      ****************************************
          201-ESCRIBIR-SALIDA.                              

            WRITE REGISTRO-SALIDA                         
                                                               
            IF FS-SALIDA NOT = '00'
              MOVE 'ERROR AL ESCRIBIR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-SALIDA TO W000-ABEND-CODIGO
              MOVE 'SALIDA'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO 
            END-IF 

            ADD 1 TO A000-ESCRITOS
         .   

      ****************************************
      *         301-CERRAR-ARCHIVOS          *
      ****************************************
         301-CERRAR-ARCHIVOS.
           CLOSE ENTRADA1
            IF FS-ENTRADA1 NOT = '00'
              MOVE 'ERROR AL CERRAR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA1 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA1'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 

           CLOSE ENTRADA2
            IF FS-ENTRADA2 NOT = '00'
              MOVE 'ERROR AL CERRAR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-ENTRADA2 TO W000-ABEND-CODIGO
              MOVE 'ENTRADA2'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 

           CLOSE SALIDA
            IF FS-SALIDA NOT = '00'
              MOVE 'ERROR AL CERRAR ARCHIVO' TO W000-ABEND-DESCRIPCION
              MOVE FS-SALIDA TO W000-ABEND-CODIGO
              MOVE 'SALIDA'  TO W000-ABEND-OBJETO
              PERFORM 900-ABEND-PROCESO
            END-IF 

         .

      ****************************************
      *         302-MOSTRAR-RESUMEN          *
      ****************************************
         302-MOSTRAR-RESUMEN.
           DISPLAY ' '
           DISPLAY '  ---------------------------------'           
           DISPLAY '         RESUMEN DEL PROCESO  '
           DISPLAY '         -------------------  '
           DISPLAY ' E1-> LEIDOS DE NOMBRES:   ' A000-LEIDOS-E1
           DISPLAY ' E2-> LEIDOS DE EDADES:    ' A000-LEIDOS-E2
           DISPLAY ' S1-> ESCRITOS:            ' A000-ESCRITOS
           DISPLAY '  ---------------------------------'           
         .




      ****************************************
      *         900-ABEND-PROCESO            *
      ****************************************
         900-ABEND-PROCESO.
           DISPLAY ' '
           DISPLAY '***********************************'           
           DISPLAY '* ERROR EN EL SISTEMA              '
           DISPLAY '* OBJETO:            ' W000-ABEND-OBJETO  
           DISPLAY '* CÓDIGO DE ERROR:   ' W000-ABEND-CODIGO  
           DISPLAY '* DESCRIPCION:       ' W000-ABEND-DESCRIPCION
           DISPLAY '***********************************'           
           STOP RUN.
         .

Errores de FILE STATUS

2007-06-17T20:00:00.000-03:00

Códigos de error que se registran en el FILSE STATUS asociado a un archivo en COBOL MAINFRAME
Código	Descripción
00	La operación fue exitosa.
02	La sentencia de INPUT o OUTPUT fue ejecutada exitosamente, pero se detectó una clave duplicada. Este tipo de error aplica a archivos indexados.
04	La sentencia de lectura fue ejecutada exitosamente, pero la longitud del registro leido no coincide con los atributos especificados para ese archivo.
05	La sentencia de open fue ejecutada exitosamente, pero el archivo opcional referenciado no está presente en el momento en que el OPEN se ejecuta.
10	Se alcanzó el fin de archivo EOF.
14	Se intentó hacer una lectura secuencial sobre un archivo relativo, y el número de dígitos significativos en el número relativo de registros fue mayor al tamaño de la clave descripta para el archivo.
21	Se detecta un error de secuencia para un archivo indexado.
22	Se intenta escribir un registro que crea una clave duplicada en un archivo relativo. Agregar la claúsula DUPLICATES en el archivo indexado.
23	En un archivo de acceso RANDOM se hace un START o un READ con una clave que no existe en el archivo.
24	Error en WRITE en archivos INDEXADOS. Verificar que el tamaño de la clave sea suficiente para la cantidad de registros.
30	Error permanente. Si te pasa esto llorá.
34	Violación de los límites, error permanente. Se intento un WRITE más alla de los límites definidos externamente de un archivo secuencial.
35	Se intento un OPEN sin especificar el tipo, es decir INPUT, I-O, EXTEND.
37	Se intentó una sentencia de open en un archivo que no soporta abrirse en el modo específicado en la sentencia.
38	Se intenta un OPEN sobre un archivo cerrado previamente con lock.
41	Se intenta abrir un archivo ya abierto.
42	Se intento un CLOSE para un archivo no abierto.
43	Para archivos secuenciales abiertos en el modo I-O, se ejecuta una sentencia de REWRITE posterior a una sentencia de READ fallida.
44	Existe una violación de límetes porque se intento hacer el REWRITE de un registro en un archivo y el registro no es del mismo tamaño que el registro a reemplazar. También puede ser un intento de escribir o reescribir un registro más largo o más pequeño que el permitido por la claúsula RECORD IS VARYING asociada al archivo.
46	Se intentó un READ secuencial en un archivo abierto en modo INPUT o en modo I-O y no se encontró un registro siguiente válido. Se da porque el READ anterior fue un AT END o bien no causó la condición de AT END pero no fue exitoso.
47	Se intenta leer un archivo que no se abrió en modo INPUT o I-O.
48	La ejecución del WRITE se hizo sobre un archivo que no fue abierto en modo I-O, en modo OUTPUT o bien en modo extendido.
49	Se intenta un DELETE o REWRITE en un archivo que no fue abierto en el modo correspondiente (I-O).
90	Sólo para aplicaciones multihilo (MULTITHREADING). Se realiza el close un VSAM o un QSAM en un hilo que no abrió el archivo.
91	VSAM: Password error.
92	Error lógico.
93	Recurso no disponible.
95	La información es invalida o incompleta.
96	En VSAM: Se intentó un OPEN en modo OUTPUT, o un OPEN en I-O o EXTEND pero en la DD no se especifico lo mismo.
97	El OPEN sobre el VSAM fue exitoso: Se verifica la integridad.
98	El OPEN falla debido a un error en la claúsula SELECT...ASSIGN.

Suma de dos números en JAVA

2007-05-13T14:34:00.000-03:00

//----JAVA SUMA DE DOS VARIABLES.
import javax.swing.JOptionPane; 

public class SumarNumeros {

   public static void main( String args[] )
   {
      String strNumero1;
      String strNumero2;
      int intNumero1;   
      int intNumero2;   
      int suma;
      strNumero1 = JOptionPane.showInputDialog( "Ingrese el entero 1" );
      strNumero2 = JOptionPane.showInputDialog( "Ingrese el entero 2" );
      intNumero1 = Integer.parseInt( strNumero1 );
      intNumero2 = Integer.parseInt( strNumero2 );

      suma = intNumero1 + intNumero2;

      JOptionPane.showMessageDialog(
         null, "La suma es " + suma, "Resultado,",
         JOptionPane.PLAIN_MESSAGE );
     System.exit( 0 );  
  } 
}

Indice del manual de C++

2006-06-17T20:24:00.000-03:00

Temas tratados

Pascal

Java

Hola Mundo en Java

Algoritmo, superprimos, residuo, division entera

2006-06-06T16:30:00.000-03:00

Un algoritmo para pasar el rato. Sacado de la página de los torneos de Computación y matemáticas. Cito:

Un numero es superimpar si todas sus cifras son impares. Cuáles son todos los múltiplos de 367 que tienen exactamente 5 cifras y son superimpares.

En papel calculamos que los múltiplos de 5 cifras de 367 están acotados así:

367*28 <= ABCDE <= 367*272

Debido a que 367*27 = 9909 y 272*27 = 99824, que tienen 4 y 5 cifras respectivamente (no nos sirven).

El algoritmo que implementaremos, se basará en la propiedad de los números pares que al dividirlos por 2 devuelven un resto igual a 0. Esto se logra fácilmente con el operador de residuo %.

Por ejemplo:

int a,b;
a = 4 % 2; //se asigna 0.
b = 5 % 2; //se asigna 1.

Realizamos la operación sobre el número ABCDE % 2, si obtenemos un 0 es porque el número es par, es decir su última cifra es par, por lo que ya podemos descartarlo. Si nos da distinto, seguimos adelante.

Ahora nos valdremos de la división entera por 10, para correr la coma un lugar hacia izquierda y quedarnos con la parte entera. Veamoslo así:

int a,b;
a = 12345;
b = a / 10; //asgina 1234

De esta manera ya podemos evaluar si es o no es par la segunda cifra. Repitiendo el procedimiento tres veces más terminamos de evaluar todas las cifras. Si todas nos dieron impares, mostramos el número.

Veamos el código entonces:

#include 
using std::cout;
using std::endl;
int main()
{
  int numero = 367;
  int evaluar;
  for (int i = 28 ; i < 272 ; i++) //Evaluamos todos los multiplos de 5 cifras.
    {
      evaluar = numero*i; //Construimos el multiplo.
      if (evaluar % 2 != 0) //estamos evaluando ABCDE
 if ( (evaluar /= 10) %2 != 0 ) // ABCD
   if ( (evaluar /= 10) %2 != 0 ) //  ABC
     if ( (evaluar /= 10) %2 != 0 ) //  AB
       if ( (evaluar /= 10) %2 != 0 ) //por fin A si todo salio bien mostramos
  cout << numero*i << " es igual a " 
                     << i << "*" << numero 
                     << endl;
    }
  return 0;
}

Compilamos así:

g++ superprimos.cpp -o superprimos.out

¿Les parece efectivo?
¿Otras soluciones?
Sí el enunciado nos pidiera que el mismo algoritmo se encargue de determinar los múltiplos de 5 cifras. ¿Como quedaría?
¿Es utilizar un ciclo para no repetir condiciones if? ¿Basta con una?

Que se diviertan si quieren dejen respuestas en los comentarios.

MANUAL XHTML

2006-05-02T22:16:00.000-03:00

Publico otro manual sobre el lenguaje XHTML. Espero que les guste.

Acutalización de template para Blogger

2006-03-07T13:55:00.000-03:00

Perdonen la poca actualización que le estoy haciendo al sitio. Ya voy a escribir más temas. Ocurrió que estoy dando finales, y por empezar la facultad nuevamente. Por lo que me cuesta mantener el ritmo de estudio del lenguaje. En cuanto pueda regresare. Por el momento he actualizado el template del sitio gracias al theme de .:losBits. Espero que les guste.

Miembros de tipo static en C++

2006-01-29T20:16:00.001-03:00

Las clases que estuvimos escribiendo, contenían datos miembros (variables), que servían para almacenar un valor que sería propio del objeto que luego creamos a partir de la clase.

Por ejemplo, si tenemos una clase Punto con los datos miembros x e y, y creamos dos objetos: Q(-5,43.12) y J(32,23), vemos que los datos miembros, almacenan valores que son propios de los objetos e independientes de la clase.

Pero a veces resulta útil tener datos miembros de características inversas (independientes de los objetos y propios de la clase) que sean compartidos por todos los objetos creados de una clase.

Para esto se definen dentro de la clase datos miembro de tipo static.

Podríamos definir un dato miembro static, llamado cantDeObj (cantidad de objetos) inicializado en 0, que se incrementaría cada vez que se ejecuta el constructor de la clase (es decir se crea un objeto), y se decrementaría cada vez que se ejecuta el destructor de la clase (es decir se destruye un objeto).

Si esto lo implementaramos, por ejemplo, en la clase Punto, podríamos saber en cualquier momento la cantidad de puntos (objetos de la clase Punto), que están creados.

En el próximo programa, utilizamos en la clase Prueba, un dato miembro static, llamado cantidad, que contendrá todo el tiempo la cantidad de objetos creados.

Como veremos al ser static, existe aún cuando no haya ningún objeto de la clase creado. Debemos tener en cuenta que cantidad estará bajo la etiqueta private: por lo que no podremos acceder a la variable directamente, sino que utilizaremos una función miembro static, llamada obtenerCant(), que al igual que un dato miembro static, es independiente de todos los objetos y propia de la clase.

Luego dentro de main(), creamos algunos objetos, y vemos como la variable cantidad va variando de valor.

Aquí el programa:

#include <iostream>
using std::cout;

using std::endl;
#include <new>
class Prueba
{

 public:
  Prueba (int valor = 0)
    {

      cout << "Llamado del constructor" << endl;
      x = valor;

      cantidad++;
    }
  ~Prueba()
    {

      cout << "Llamado del destructor" << endl;
      cantidad--;
    }

  static int obtenerCant(void)
  {
    return cantidad;

  }
 private:
  int x;
  static int cantidad;

};

int Prueba::cantidad = 0;//inicializacion del dato miembro.

int main()
{
  cout << "No se creo ningun objeto cantidad es: " << Prueba::obtenerCant() << endl;

  Prueba objeto;
  cout << "Luego de crear un obj, cantidad es: " << Prueba::obtenerCant() << endl;

  Prueba *arreglo;
  cout << "CREO EL ARREGLO" << endl;

  arreglo = new Prueba[5];
  cout << "Luego del arreglo de objetos cantidad es: " << Prueba::obtenerCant() << endl;

  cout << "BORRO EL ARREGLO" << endl;
  delete [] arreglo;

  cout << "Luego de borrar el arreglo cantidad es: " << Prueba::obtenerCant() << endl;

  Prueba objetoA;
  cout << "Creo otro objeto cantidad es: " << Prueba::obtenerCant() << endl;

  cout << "Luego de esto se ejecutaran los dos ultimos destructores: " << endl;
  return 0;
}

Para compilar:

g++ miembroStatic.cpp -o miembroStatic.out

Aquí abajo vemos como se ve la salida de este programa:

Destructores y constructores en C++

2006-01-29T19:35:00.001-03:00

Cuando vimos clases, hemos visto que toda clase tiene una función especial llamada constructor que posee la particularidad de tener el mismo nombre que la clase.

Esta función se ejecuta cada vez que se crea un objeto de la clase. De parecidas carácteristicas existe una función, llamada destructor que se ejecuta cada vez que el objeto se destruye.

Un objeto se destruye cuando se termina el programa, cuando se sale de una función (o bloque) que había creado al objeto, o bien cuando indicamos con la instrucción delete, la liberación de la memoria que habíamos reservado dinámicamente para algún objeto.

En todos estos casos se ejecuta el destructor del objeto. Este también lleva el nombre de la clase precedido por el símbolo ~.

Hasta el momento no nos hizo falta definir nuestros propios destructores, pero como veremos más adelante resulta muy útil y necesario cuando los programas administran memoria dinámica y no son clases tan triviales como las que vimos.

En el programa siguiente, crearemos la clase Prueba y le definiremos solamente un constructor y un destructor.

También poseera un dato miembro, que lo utilizaremos para diferenciar los diferentes objetos (objeto 0, objeto 1, etc).

El constructor y el destructor, sólo poseeran una instrucción cout, que mostrará cuando se ejecuta uno u otro y además dará el número de objeto para que podamos diferenciarlos.

Presten especial atención en los dos objetos creados dentro del bloque (el 1 y el 2). Se crea primero el objeto 1 y luego el objeto 2. Cuando se sale del bloque, los destructores se ejecutan en el orden inverso al que fueron creados, es decir primero el del objeto 2 y luego el del objeto 1.

Aquí va a el código:

#include <iostream>
using std::cout;

using std::endl;
#include <new>

class Prueba
{

 public:
  Prueba(int numero = 0); //constructor.

  ~Prueba(); //destructor
 private:
  int x;

};

//definiciones de las funciones miembro
Prueba::Prueba(int numero)//constructor.

{
  x = numero;
  cout << "Se ejecuta el constructor del objeto nro: " << (*this).x << endl;

}
Prueba::~Prueba()
{
  cout << "Se ejecuta el DESTRUCTOR del objeto nro: " << (*this).x << endl;

}

int main()
{
  cout << "***Entramos a main" << endl;

  Prueba objeto(0);
  {
    cout << "***Entramos al bloque" << endl;

    Prueba objetoA(1);
    Prueba objetoB(2);

    cout << "***Salimos del bloque" << endl;
  }

  Prueba *ptr; //creamos un puntero.

  ptr = new Prueba(3);//le asignamos un objeto dinamicamente, con argumento 3.
  Prueba *ptr2;

  ptr2 = new Prueba(4);//segundo puntero.
  //AHORA LIBERAMOS LA MEMORIA DINAMICA QUE HABIAMOS SOLICITADO, USANDO DELETE.

  cout << "--Borramos ptr2" << endl;
  delete ptr2;
  cout << "--Borramos ptr" << endl;

  delete ptr;
  cout << "***Ahora estamos por salir de main(), al salir se ejecutara el destructor" << endl << "del objeto 0 creado al principio de main()" << endl;

  return 0;
}

Para compilar:

g++ destructores.cpp -o destructores.out

Aquí abajo vemos como se ve la salida de este programa:

Memoria dinamica: new y delete en C++

2006-01-29T13:42:00.001-03:00

La memoria dinámica es un espacio de almacenamiento que se puede solicitar en tiempo de ejecución. Además de solicitar espacios de almacenamiento, también podemos liberarlos (en tiempo de ejecución) cuando dejemos de necesitarlos.

Para realizar esta administración de la memoria dinámica, C++ cuenta con dos operadores new y delete. Antes de utilizarlos, debemos incluir el encabezado <new>.

El operador new reserva memoria dinámica de cualquier tipo, esto es:

tipos primitivos (int, double, etc)
tipos definidos por el usuario (clases o estructuras).

Veamos las siguientes líneas:

int *ptrEntero;
ptrEntero = new int;
/*(al puntero ptrEntero le asignamos 
dinamicamente espacio para contener un valor int)*/


int *ptrEnteroA;
ptrEnteroA = new int(5);
/*(igual que al anterior 
pero de paso lo inicializamos en 5)*/

También podríamos hacerlo con un arreglo, para esto:

int *arreglo =  new int[45];
/*
(creamos un arreglo dinámico, ésta vez lo 
hacemos en la misma línea en la que 
declaramos el puntero)
*/

Supongamos ahora que poseemos una clase Punto, podríamos crear objetos dinámicos a partir de esta clase.

Punto *ptrQ;
ptrQ = new Punto(4,5);
/*
(en la segunda línea le pasamos 
además dos parámetros separados por 
coma al constructor de Punto)
*/

Hemos estado pidiendo memoria dinámica, una vez utilizada lo correcto sería liberarla antes de que finalice el programa para esto utilizaremos el operador delete:

delete ptrEntero;
delete ptrEnteroA;
delete ptrQ;
delete [] arreglo; 
//Si no usaramos [] no se liberaría el arreglo entero

Aquí dejo un programa, con una sencilla clase Punto, y la declaración de algunos objetos en la memoria dinámica.

#include <iostream>
using std::cout;

using std::endl;
#include <new> //para poder utilizar new y delete
class Punto

{
 public:
  Punto(int X=0,int Y=0)

    {
      establecer(X,Y);
    }
  void establecer(int x1,int y1)

  {
    x = x1;
    y = y1;

  }
  void imprimir(void)
  {
    cout << "(" << x << "," << y << ")" << endl;

  }
 private:
  int x;
  int y;

};

int main()
{
  //declaracion e inicializacion
  Punto J(45,-12);

  Punto *ptrQ;
  ptrQ = new Punto(5,7);

  Punto *arreglodePuntos;
  arreglodePuntos = new Punto[10];

  //imprimimos
  cout << "J";
  J.imprimir();

  cout << "ptrQ";
  ptrQ->imprimir();
  for (int i = 0 ; i < 10 ; i++)

    {
      cout << "arreglodePuntos[" << i <<"]";
      arreglodePuntos[i].imprimir();

    }
  //liberamos
  delete ptrQ;
  delete [] arreglodePuntos;

  //fin
  return 0;
}

Para compilar:

g++ memDina.cpp -o memDina.out

Apuntador this en C++

2006-01-24T22:48:00.001-03:00

Cuando hacemos una llamada a una función miembro de un objeto, el compilador se encargará de pasar implícitamente como argumento: a un apuntador que contenga la dirección del objeto.

A este apuntador se lo llama, el apuntador this (palabra reservada del lenguaje C++). Además de este uso implícito por parte del compilador, se puede usar this explícitamente para referirse al objeto.

Dependiendo del tipo de función en la cual se use this, tendrá diferente tipo.

En una función miembro no constante:

NomObjeto * const
//(apuntador constante a un objeto no constante)

En una función miembro constante:

const NomObjeto * const 
//(apuntador constante a un objeto constante)

A continuación veremos cómo utilizar el apuntador this, de manera implícita (como veníamos haciendolo) y de manera explícita.

Cabe recalcar que cuando lo usemos de manera explícita, utilizaremos -> (un menos y el mayor) ya que se trata de un apuntador y no del objeto en sí dónde deberíamos usar simplemente el . (punto).

#include <iostream>
using std::cout;

using std::endl;
class Prueba
{
 public:

  Prueba(int y = 0)
    {
      this->x = y; //usamos apuntador this explicito.

    }
  int Obtener(void)
  {
    return x; //usamos apuntador this implicito

  }
 private:
  int x;
};

int main()

{
  Prueba objeto1(5);
  cout << objeto1.Obtener() << endl;

  return 0;
}

Para compilar este programa utilizaremos:

g++ apuntThis.cpp -o apuntThis.out

Clases y funciones Friend en C++

2005-12-19T21:33:00.001-03:00

Dentro de las clases podemos definir funciones (o clases) como amigas de la clase. Esto significa que le estamos dando acceso a una función (o clase) a que modifique los datos miembros de la clase.

Esto es especialmente útil para la sobrecarga de operadores como veremos más adelante.

Por el momento sólo diremos que una función (o clase) amiga tiene acceso a los datos miembros de la clase que la declara como amiga.

Para ilustrar ésto veremos el siguiente ejemplo. Tenemos una clase llamada Numero, que consta de un dato miembro llamado x. Tiene una función pública mostrar() que saca por pantalla el valor de x. Además declara una función amiga llamada establecer(), que recibe el objeto a modificar y un número de punto flotante double para establecer el valor del objeto.

Como vemos estamos utilizando la función no a través del objeto sino pasandole el objeto pasado como parámetro.

Ejemplo:

#include <iostream>
using std::cout;
using std::endl;
class Numero
{
  friend void establecer(double ,Numero &);//establecer es una funcion amiga.
 public:
  Numero(double);//constructor.
  void mostrar();
 private:
  double x;//dato miembro.
};

Numero::Numero(double b)
{
  x = b;
}
void Numero::mostrar()
{
  cout << "El numero es: " << x << endl;
}
void establecer(double a, Numero &objeto)
{
  objeto.x = a; //puede modificar el dato miembro porque es amiga.
}

int main()
{
  cout << "Creamos el objeto Pi" << endl;
  Numero Pi(7.8);
  Pi.mostrar();
  cout << "Modificamos con la funcion amiga" << endl;
  establecer(3.14,Pi);//utilizamos la funcion amiga.
  Pi.mostrar();
  return 0;
}

Para compilar:

g++ ejFriend.cpp -o ejFriend.out

Parámetros por línea de comandos argc y argv en C++

2005-12-10T20:03:00.001-03:00

Para poder pasar parámetros a un programa a través de la línea de comandos nos valemos de la siguiente declaración de la función main:

int main(int argc, char *argv[])

El primer agumento entero argc, contiene el número de argumentos recibidos por el programa, debemos considerar que siempre será el número de argumentos pasados más 1, ya que el primer agumento se reserva para contener el nombre del programa. El segundo es un apuntador a un array de chars que contiene los parámetros pasados en el mismo orden en que fueron escritors. Supongamos que llamemos a un programa de la siguiente manera:

./mcd entero1 entero2

argc contendrá el valor 3, debido al nombre del programa, y los dos argumentos pasados. argv[0] contendrá el valor mcd arg[1] será entero1 arg[2] será entero2 arg[3] será un puntero NULL Utilicemos el ejemplo del algoritmo de euclides, para calcular fracciones a su mínima expresión pero esta vez recibiremos los parámetros por línea de comandos:

#include <iostream>
//#include <cstdlib>
using namespace std;
int mcd(int x,int y){
  return (!y) ? x : mcd(y,x%y);
}
int main(int argc, char *argv[])
{
  if (argc != 3)
    cout << "Uso: mcd entero1 entero2\n";
  else
    {
      int a,b,MCD;
      a = atoi(argv[1]);
      b = atoi(argv[2]);
      MCD = mcd(a,b);
      cout << a << "/" << b << " = " << a/MCD << "/" << b/MCD << endl;
    }
  return 0;
}

Para compilar hacemos:

g++ mcd.cpp -o mcd

Una salida del programa y su llamada:

/home/chulo/programacion $ ./mcd 45 55
45/55 = 9/11

Código Fuente

Como saber la versión de ubuntu por línea de comandos

El tipo boolean y el objeto Boolean en Java

Ejemplo de foreach en Java

Como pasar de int a un String en Java

Como leer un archivo de texto en Java

Ejemplo de String indexOf de Java

El método SPLIT en Java

Ejemplo de Herencia en Java

Todo sobre jQuery y los checkbox

Saber si un checkbox está checkeado o no

Setear el valor de un checkbox:

Ejecutar código cuando se checkea un checkbox:

El método indexOf de javascript

Función trim en javascript y en jQuery

Ejemplo de trim

Utilizando trim de jQuery

Explicación de SWITCH y CASE en javascript

Ejemplo de switch/case evaluando una variable cadena

Ejemplo de switch/case utilizando el label default

Hacer un redirect con Javascript

Redirect normal utilizando Javascript

Redirect al top desde adentro de un iframe

Ejemplos de setTimeout en Javascript

Ejecutando un callback luego de 2 segundos

Ejecutando código luego de 2 segundos

Ejecutando un callback con parametros luego de 2 segundos

Cancelando el timeout con clearTimeout

case en java

ejemplos de for en javascript

Usando for para iterar un array:

for en javascript y for in

ejemplos de for en javascript

Usando for para iterar un array:

jquery each ejemplos

La función each de jQuery

Utilizando jQuery.each con un array

Utilizando jQuery.each con un objeto

Utilizando jQuery.each con una colección del DOM

javascript split

La función split de Javascript

Ejemplos de split

Javascript replace

La función replace de Javascript

Ejemplos de replace

Javascript substring

La función substring

Ejemplos de substring

Arrays en javascript, ejemplos

Declaración de un array

Conocer el tamaño de un array

Accediendo a los objetos de un array

Algoritmo de ordenación en C [INSERTION SORT]

Conectarse remotamente utilizando GNU/Emacs, SSH y Tramp

Descripción

Por puerto default

Por puerto 60

Tareas por línea de comando en Symfony

Borrar caché

Nuevo proyecto

Nueva aplicación

Nuevo módulo

Nuevo programa BATCH/TASK

Genera las clases del modelo a partir del SCHEMA

Crear todo a partir del SCHEMA

Ejecutar DQL

Ver todas las tareas disponibles para Doctrine

Generar el SCHEMA a partir de la base de datos

Descripción de los status para los archivos versionados con Subversion

Descripción

Mantener un servidor DNS local en Ubuntu

Descripción

Instalación

Copiando servidores DNS actuales para que use DNSMasq

Editamos archivo /etc/resolv.conf y agregamos como primera línea:

Probamos velocidad de las queries ejecutando varias veces:

Aumentamos el tamaño de la cache del servicio:

Ver los archivos de un paquete en Ubuntu

Login por SSH sin password

Descripción

Ejemplo de `trim`

Ejemplo de switch/case utilizando el label `default`

Editamos archivo `/etc/resolv.conf` y agregamos como primera línea:

7. (cond (p₁ e₁)...(p_n e_n))