miércoles, 31 de julio de 2013

[Shell] tee tuberia en T Unix

Bien,si han usado algun tipo Unix a de alguna forma rara o libre un tipo Unix conoceran las tuberias,o pipes Unix de comunicacion,pues esa tuberia es de solo dos lados,entrada y salida,pues bien si conocen los tubos en fotma de T sabran que tienen tres salidas,pues es eso lo que hace el comando tee,combierte nuesta tuberia en una T:

Imagen de : wikipedia

Bien,como vemos en la imagen de arriba lo que hace es tomar el primer comando meterlo en un archivo y luego continuar con el siguiente comando:

Por ejemplo:

wget -O- http://www.pagina.com/dvd.iso | tee dvd.iso | sha1sum > dvd.sha1

Bien,esto es lo que haria el flujo estandar de Unix:

>

Si queremos que haga esto:

>>

Tenemos que añadir -a a tee:

Por ejemplo

 ls ~/Descargas | tee archivos_selectos.txt | less && echo "Documentos : " >> archivos_selectos.txt; ls ~/Documentos | tee -a archivos_selectos.txt | less



Y con esto nos guarda los archivos de Descargas en un archivo,nos los muestra con less,y hace lo mismo con los archivos de Documentos sin rescribir todo el archivo.

También podemos añadir el parametro -i,que lo que hace es que ignore la señal SIGINT,el usado ctrl+c.

Referencia : wikipedia






Leer más...

lunes, 29 de julio de 2013

Mandar notificaciones al escritorio Linux

Muchas veces necesitamos mandar notificaciones al escritorio para enterarnos de lo que pasa,en los sistemas Linux listos para usar siempre vemos avisos de que se esta agotando la bateria,nos desconectamos de la red,etc pero no sabemos como enviar las nuestras(eso creo porque es la razón de esta entrada),asi que aqui aprenderemos a enviar notificaciones:



Bien pero esto de que nos sirve?

Creo que al buscar este tutorial tendrán sus ideas, pero aquí aguas razones por las cuales es bueno aprender a usar notificaciones:

Esto mas que nada es para seguridad informática,ya que las notificaciones mas importantes las tiene definidas el mismo sistema,en la seguridad informática el tiempo de edición es critico,a que me refiero con el tiempo de edición?

A tocar los archivos,en Linux/Unix se le conoce como touch y hay un comando para ello,al tocar un archivo nos esta indicando que lo modificamos,editamos incluso borramos(si no esta),al hacer esto es probable que no se trate de nosotros mismos si no de un intruso,esto lo hace interesante a la hora de escalar privilegios,porque por ejemplo pueden acceder a nuestra cuenta normal pero si quieren acceder a root,deben modificar algún archivo(en un tipo de ataque) y si lo estamos monitoreando no habra problema y podremos detectar al intruso,no solo al ver los archivos modificados si no directamente ver los usuarios,con el comando (who por ejemplo),así que bueno vamos a ver como acceder a las notificaciones.


Tutorial

El comando es simple,solo hay que escribir en la terminal:

notify-send "Mensaje"
Tiene argumentos en la linea de ordenes,el que se me hace interesante es:

-i

Que es para icono:

Por ejemplo:

notify-send "Mensaje" -i firefox

Vamos a ver un ejemplo de ver las tty's conectadas al sistema,osea las interfaces que estemos usando:

Veamos que las interfaces que uso son tres dos shells y un tty en modo grafico:



Ahora me voy a conectar por ssh en local a mi mismo host:



Y las conexiones aumentan en dos(una shell mas y la ssh).

Ahora imaginemos que esa conexion no la efectuamos nosotros,vamos a usar el who para ver las interfaces(pero hay mas maneras):


 #!/bin/bash  
   
 num=`who | tee users.log | wc -l`  
   
 echo $num > num.log # Esto podria ser un base de datos,etc  
   
 while [ 1 ]; do  
   num=`cat num.log`  
   n=`who | wc -l`  
   who > u.log  
   usuario=`diff u.log users.log | sed -n -e 2p`  
   if [ $num -eq $n ] # igual: no pasa nada  
   then  
     continue  
   elif [ $num -gt $n ] # mayor: alguien se desconecto  
   then  
     echo $n > num.log  
     `who > u.log && who > users.log`  
     notify-send echo "Desconectado $usuario"  
   else # Menor: alguien se conecto  
     echo $n > num.log   
     # ^ En cualquier caso recargamos el log o no dejara de mostrar el mensaje   
     `who > u.log && who > users.log`  
     notify-send "Conectado $usuario"  
   fi  
   sleep 5; # tiempo de intervalos  
 done  
   
 #This library is free software; you can redistribute it and/or modify it under  
 #the terms of the GNU Library General Public License as published by the Free  
 #Software Foundation; either version 2.1 of the License, or (at your option) any  
 #later version.  






Eso es todo :D

Mas info:

notify-send --help




Leer más...

lunes, 22 de julio de 2013

Manejo de errores en python parte 1/2


En la programación siempre cuando ejecutamos un  una solución escrita en algún lenguaje de programación lo más seguro es que de algunos errores ,a menos de que sepamos exactamente lo que estamos haciendo y como se va a comportar lo que estemos haciendo ,no es que no haya programadores que no se equivoquen pero esto no se trata de equivocarse si no de desviar problemas a soluciones y aun así un problema mismo podría ser una solución bien manejada.

En python tenemos una gran manera de manejar errores los cuales se basan en probar,con la palabra reservada try, para manejar un error solo es necesario encontrarlo primero, para ello vamos a ver un ejemplo:

Quiero importar el siguiente modulo:

 #!/usr/bin/env python3  
 # Le ponemos de nombre mi_modulo.py  
 def pinta():  
   print ("Hola")  

Y ahora en un script lo intentamos importar,pero accidentalmente nos equivocamos de nombre,o también podría ser que no lo tengamos siempre a la mano,por ejemplo que compartimos un código el cual necesita de ese modulo y las personas que lo descarguen solo descarguen el script y no asi el modulo,entonces en nuestro script lo importamos:

import mi_modulo

Ahora si ejecutamos el script,daria un error:



Mas en especifico el error:

ImportError

Ahora vamos a aprender como manejarlo,por ejemplo ese es un error de importación,en operaciones matemáticas tambien hay errores,en tipos de datos,en IO,etc,pero la misma consola nos dice cual es:

Para manejarlo usamos la palabra reservada except:

except nombre_error:

Pero antes adentro de una sentencia try hacemos lo que causa el error:

 try:  
   import mi_modulo  
 except ImportError:  
   # Aquí hacemos lo que queramos si entra en error,por ejemplo:  
   print ("No existe el modulo")  

:D

Python también nos deja manejar los errores desde el tipo exceptions,un tipo de dato que nos devuelve una tupla, esta tupla devuelve un numero de argumentos los cuales podemos usar,para el manejo de errores,en realidad no es una tupla,ya que el tipo de dato no lo verifica,pero retorna valores de tipo lista,solo que es inmutable:

Para ello usamos la palabra reservada as:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error)  

Para ver los argumentos de error o el nombre que le asignemos usamos esta sintaxis:

print (error.args)

Y podemos hacer esto,por ejemplo:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error[0])  

Ahora,si queremos manejar lo que sucedería después de esto,podemos hacerlo escribiendo fuera del bloque try/except pero si queremos que se ejecute en el mismo,podemos hacer uso de else:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error[0])  
 else:  
   print ("Usando el modulo :D")  
   print ("O cualquier otra cosa")  

Por ejemplo:

 #!/usr/bin/env python3  
   
 try:  
   ar = open ("Archivo.txt","r")  
 except IOError as io:  
   for i in io.args:  
     print ("Error: %s")%(i)  
   print ("Tipo : %s")%(type(io))  
 else:  
   print ar.read()  
   ar.close()  

Otro ejemplo:

 #!/usr/bin/env python3  
   
 while 1:  
   print ("Bucle infinito" + ("-"*30))  
   try:  
     var = input("No puedes salir a menos que escribas salir : ")  
   except EOFError:  
     print ("\n;)")  
   except KeyboardInterrupt:  
     print ("\nSin trucos ;)")  
     continue  
   else:  
     if var.lower() == "salir" or var.lower() == "s":  
       break  

Eso es todo  de esta parte :D




Leer más...

domingo, 21 de julio de 2013

[Shell] chmod permisos en las carpetas Unix/Linux


Cambiar permisos en las carpetas y archivos en sistemas Unix


Los permisos en las carpetas de sistemas Unix son básicos,pero no así sencillos,como me comentaba el redactor de un blog sobre Linux hace un tiempo se podría hacer un libro solo sobre los permisos,ya que no solo es saber otorgar permisos si no que es saber a quien otorgárselos,en este tutorial prenderemos a cambiar permisos de archivos desde la shell usando el comando chmod,lo hare breve y espero que les ayude a entender como funciona el comando chmod  por si tienen problemas con el.

Tutorial

El comando chmod no es parte del código de bash pero aun así esta instalado en todos los sistemas Unix,por defecto.

Para ver los permisos de un archivo usamos el comando:

ls -l

Como vemos nos muestra los permisos en caracteres,como por ejemplo:

-rw-rw-r--

A diferencia de como se ven con ls,no los asignamos así,esto no lo hacemos:

chmod -rw-rw-r--

Lo que hacemos es usar  números octales,los cuales comienzan en 0 y terminan en 7,estos números los usamos sobre tres distintos tipos de usuarios del sistema:

owner => usuario(propietario)

group => grupo

other => otros

Los números octales están asignados de la siguiente manera

4 => lectura => r

2 => escritura => w

1 => ejecucion => x


0            0           0

^ owner ^ group ^ others


Y sumados se asignan los permisos,por ejemplo algo sencillo seria:

44

Que seria:

-r--r--r--



Lo que también significa,que el usuario,el grupo y otros pueden leer pero no pueden ejecutar ni escribir:




Otro ejemplo es 775

A lo que seria

7 = 4 => r + 2 => w  + 1 => x { sobre usuario }

7 = 4 => r + 2 => w  + 1 => x { sobre grupo }

5 = 4 => r + 1 => x { sobre otros }

También existen otro tipo de permisos los cuales ya no usan números octales,los llamados permisos simbólicos en el mundo de Unix y los cuales son mas sencillos,según mi opinión:

Al igual que los numeros tenemos distintas asignaciones:

r  lectura
w  escritura
x  ejecución  o acceso si es directorio
s  usa el id del dueño o grupo del archivo al ejecutar
t  fijar "sticky bit" a un directorio: sólo dueños pueden borrar
u  usuario (dueño)
g  grupo
o  otros
a  todos (dueño grupo y otros)

+  agrega permiso a los permisos existentes
-  quita permisos de los existentes
=  únicos permisos asignados al archivo

El equivalente seria:

000
ugo

Veamos como asignamos 444 con asignación simbólica:

u=r,g=r,o=r




Por ejemplo si han usado este comando:

chmod +x archivo_ejemplo

Y no sabían que es lo que asía,lo que hace es darle permisos de ejecución con asignación simbólica:

+x es igual a + ejecución y conserva los demás permisos

Es lo genial de la asignación simbólica podemos,asignar permisos mas los existentes:

chmod +w

Nos concede el permiso de editar el archivo,lo cual no podíamos con permisos 444.

Eso es todo,como vemos no solo es saber asignar permisos sino saber a que archivo,por ejemplo los archivos de /etc donde se guardan los archivos de configuración muchos de ellos solo tienen permisos de ejecución y lectura para todos los usuarios,y escritura solo para el propietario que es root.





Leer más...

sábado, 20 de julio de 2013

Como usar MongoDB con Perl

Tutorial Perl MongoDB scripting


Como prometí en un comentario,aquí un tutorial de como usar MongoDB desde un script en Perl,el cual luego podemos usar en GUI,Diseño Web,etc en otra ocasión lo haré en python pero de momento en Perl.

Primero que nada se supone que ya debemos tener instalado MongoDB,si no es así consulta lo documentación o busca si ya esta en tu distribución de Linux(Si usas Linux):

Por ejemplo en Ubuntu/Debian:

aptitude search mongo

Gentoo:

emerge –search mongo
Y luego lo instalamos :

sudo apt-get install mongodb

etc


Bueno,también necesitamos el modulo MongoDB de Perl,así que lo instalamos desde CPAN:

En terminal:

sudo cpan install MongoDB


SI usan Windows,pueden instalar desde la GUI que traen las versiones de Perl,dependiendo cual usen,con el nombre MongoDB.

Ahora vamos a crear el script para Shell:

Con su editor favorito:

vim mongo.pl

Y metemos:

 #!/usr/bin/env perl # <-Hashbang  
   
 use MongoDB; # <- Modulo  
 use MongoDB::Database; <- Submodulo  
 use strict;  
   
 use warnings; # <- Para desarrollo  
   
 # Definimos algunas variable para conectarnos a la Base de Datos  
 # Como el nombre de la base de datos   
 # El puerto,etc  
   
 my $database = "test";  
   
 my $puerto = 27017;  
   
 my $host = "localhost";  
   
 # Iniciamos la conexion  
   
 $host = sprintf("%s:%s",$host,$puerto);  
   
 my $cliente = MongoDB::MongoClient->new("host" => $host );  
   
 # Nos conectamos a la base de datos  
   
 my $base_datos = $cliente->get_database( $database );  

Esa es la plantilla basica de conexion,ahora vamos a ver algunas cosas que se pueden hacer:

Listar las collections:

Para ello usamos un array

 my @collections = $base_datos->collection_names;  
   
 for (my $i = 0; $i < scalar(@collections); $i++)  
 {  
   print $collections[$i],"\n";  
 }  

Definir una collection:

 my $collections = {};  
   
 my @collections = $base_datos->collection_names;  
   
 for (my $i = 0; $i < scalar(@collections); $i++)  
 {  
   print $i,":",$collections[$i],"\n";  
 }  
   
 my $coll = {};  
   
 print "Elige una base de datos : ";  
   
 my $R_c = <STDIN>;  
   
 chop($R_c);  
   
 $coll->{$collections[$R_c]} = $base_datos->get_collection($collections[$R_c]);  



Eso se hace mas simple pero yo use una referencia para acceder a barias collections,ahora ya estamos en una collection adentro de la referencia:

$coll;

También podemos hacer algo mas simple manualmente como;

 my $coll = $base_datos->get_collection('collection');

Buscar un objeto:

Para buscar un objeto solo basta con asignar una variable al objeto,ya que solo es uno:

Pero aunque nos devuelva un solo valor covertira la variable a un hashref,ya que al usar formato estilo JSON debemos iterar sobre un valor de tipo diccionario,si usan,usaban MySQL no hay problema se hace lo mismo para recorrer los valores:

 my $object = $coll->{$collections[$R_c]}->find_one();  
   
 foreach my $keys(keys $object)  
  # Con un foreach basta  
 {  
   print $object->{$keys},"\n";  
 }  

Buscar todos los datos de una collection:

Si no queremos buscar uno y queremos ver todos los datos podemos usar un bucle foreach anidado en un while desde la funcion find del modulo MongoDB:

 my $all = $coll->{$collections[$R_c]}->find;  
   
 while (my $doc = $all->next) {  
   foreach my $keys (keys $doc)  
   {  
     print $doc->{$keys}," ";  
   }  
   print "\n";  
 }  

Insertar datos:

Para insertar datos debemos estar en la collection,así que el código iría debajo del anterior o en vez:

 $coll->{$collections[$R_c]}->insert({  
     "_id" => 2,  
     "value" => "Hola Mundo desde Perl y MongoDB"  
   });  


Les dejo un script con todo lo que hicimos:

Enlace

Bueno y eso es lo básico,conexión,consulta y insertar,para mas información visiten el tutorial de CPAN:

http://search.cpan.org/~friedo/MongoDB-0.701.4/lib/MongoDB/Tutorial.pod
Leer más...

miércoles, 17 de julio de 2013

Como usar comodines Unix en Python

Wildcards Unix con python


Esta entrada es rara porque aunque la entrada sea sobre Unix,este tutorial lo realice en Windows:



Así es ese sistema es Windows aunque parezca KDE :P

El hecho es que estoy usando Windows y por eso no he hecho tutoriales últimamente para este blog, pero aunque use Windows no puedo vivir sin Unix y sus wildcards :P,así que programe un script en python que simula esto,el hecho es que no lo programe ya que no lo necesito solo es cuestión de usar un modulo nativo de Python y todo es automático,estoy simulando las wildcards pero aun no las termino por el comodin (?) que se me ha dificultado,pero en fin este tutorial sirve para Linux,OS X y cualquier sistema en el que se pueda instalar Python.

Tutorial

Primero que nada importamos el modulo glob:

from glob import glob

Ahora solo vasta con pasarle un argumento a la función glob del modulo glob,el cual es la wildcard:

Por ejemplo listar todo el directorio:

mi_dir = glob("*")

Eso nos devuleve una lista:

print type(glob)

Ahora solo basta iterar sobre ella:

for  archivo in mi_dir:
   print (archivo)

Eso es todo,como sabemos las wildcards funcionan para listar un contenido especifico fácilmente,mas fácil que con regex y aquí un tutorial.

Aquí un código útil para Linux:
Uno compilado para Windows:

Enlace

Y el código fuente de Windows:

Que usa el compilado:


Enlace

Espero que les funcione,si tienen dudas comenten. 
Leer más...

jueves, 11 de julio de 2013

Clases y objetos python 3 parte (2/4)

Tutorial clases python 3


Ya hablamos de las clases y como se definen y funcionan con sus metodos y variables de clase,ahora toca hablar de la herencia,la cual es cuando tomamos atributos de una clase madre llamada clase super(superclass),la cual le pasa atributos y metodos a nuestra clase hija de la cual deriva de la superclass.


La clase super es la clase a la cual no le pasamos argumentos o solo le pasamos el argumento object:

class Ejemplo(object):

Cuando una clase es creada a base de otra se usa el nombre de la superclase como parametro:

class Ejemplo2(Ejemplo):

Cuando creamos una clase nueva a base de otra clase,la clase hija tiene los atributos y metodos de la clase madre:

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = “Hola mundo”  
 class Hija(Madre):  
   pass  
 ejemplo = Hija()  
 print (ejemplo.hola)  


Como vemos no se ha definido una nueva,cuando esto ocurre se le conoce como sobrecarga(override):

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = “Hola mundo”  
 class Hija(Madre):  
   def __init__(self):  
     self.hola = “Hola otra vez”  
 ejemplo = Hija()  
 print (ejemplo.hola)  

Como podemos ver parece que sobrecargamos la variable,pero en realidad sobrecargamos el constructor,(el metodo constructor),por ejemplo:

Si lo ejecutamos dará un error porque no hemos definido la variable hola en el constructor de la clase hija.

Aun asi podemos sobrecargar el constructor,pero no así los demás métodos:

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = "Hola mundo"  
   def hola(self): # Metodo de clase madre  
     self.hola = "Hola mundo"  
     return self.hola  
 class Hija(Madre):  
   def __init__(self): # Sobrecargacamos el constructor  
     self.otra_var = "Hola otra vez"  
 ejemplo = Hija()  
 print (ejemplo.hola()) # Ahora imprimimos el método  


Veamos un ejemplo,las Pc continen un forma especial,pero existen Laptos,Netbooks y cada una tiene su hardware y software,podriamos definir una Pc de esta manera:

class Pc(object):
   def __init__(self):
       self.partes = ['hardaware','software']
       self.stdout = 'pantalla'
       self.stdin = 'teclado'
       self.nombre = 'Pc'

Ahora definimos una netbook derivada de la clase Pc:

 class Netbook(Pc):  
   def __init__(self,arch,sistema,procesador):  
   Pc.__init__(self)  
 """^Para llamar el los atributos del constructor de la clase madre lo hacemos de esta manera"""  
   self.arch = arch  
   self.portable = 'muy portatil'  
   self.sistema = sistema  
   self.procesador = procesador  
   def ver(self):  
     print ('Una netbook %s arquitectura %s' %(self.procesador,self.arch))  
     print ('Contiene un sistema %s y es %s' %(self.sistema,self.portable))  
     print ('Es de la familia %s' %(self.nombre))  
     for i in self.partes:  
       print ('Partes : %s' %(i))  
 hp_mini = Netbook("x86","GNU/Linux","intel")  
 hp_mini.ver()  



Eso es todo,de momento aun faltan dos partes de clases y objectos,espero que haya quedada clara la idea de como se heredan atributos,en las proxias partes hablaremos de lo que falta,este codigo es el final:


Enlace

Leer más...

domingo, 7 de julio de 2013

Tutorial Perl MySQL Consulta

Bueno,es raro que hable de MySQL en este blog pero en fin,vamos a ver como usarlo en perl,se suponer que debes saber algo de MySQL y de Perl para entender este tutorial,pero aun así lo haré un poco didáctico:

Primero que nada necesitamos instalar el modulo DBI de perl,lo mas seguro es que ya lo tengas,pero si no es así lo instalamos desde terminal con :

sudo cpan DBI 

Bien,ahora vamos a usar un script para ver su funcionamiento,el script se usa desde la terminal,recuerden que la terminal sirve para muchas cosas,entre ellas probar los algoritmos antes de usar GUI o Diseño Web.

Iniciamos(lo que esta en morado iremos escribiendo en el script):

Definimos el hashbang y llamamos a DBI:

#!/usr/bin/env perl

use DBI;

Ahora definimos los datos de acceso:

El usuario:

my $user = "usuario";

La base de datos:

my $db = "base_de_datos";

El host:

my $host = "mi_host";

El puerto(regularmente es el 3306 a menos que tu mismo o el administrador lo hayan cambiado):

my $port = "3306";

Si no sabes cual es y tienes nmap,puedes averiguarlo con:

nmap host | grep --color sql
También vamos a guardar una tabla:

my $table = "tabla"; 

Y el password:

my $pass = "password";

Si no quieres guardarlo a fuego(adentro del script),puedes usar STDIN desde la shell:

print "Password : ";

my $pass = <STDIN>;

chop($pass);

O incluso hacer invisible la shell,o usar un shasum,etc.

Ahora vamos a crear un variable de información para MySQL:

my $info="DBI:mysql:database=$db;$host:$port";

Vamos a crear una variable tipo referencia para guardar la conexión:

my $dbh = DBI->connect($info,$user,$pass);

Por ultimo vamos a preparar un query para consulta:

my $query = "Select * from $table"; # Orden MySQL

Ahora preparamos la query:


my $sth = $dbh->prepare($query); 

Y ejecutamos:

$sth->execute();

Con eso ya establecimos nuestra conexion MySQL,ahora para ver los valores de la tabla,solo hace falta ver en ellos:

Creamos una referencia:

my $referencia = $sth->fetchrow_hashref()

Y podemos recorrer sus valores con un foreach:

foreach my $keys (keys $referencia)
  {
        print  " $keys => $referencia->{$keys}";
  }

Eso en el caso de ser solo una linea si es mas de una se recomienda usar un buble while asi:

my $referencia;
my $n = 0; # Creamos un numero para guardar el nombre de los valores
while($referencia = $sth->fetchrow_hashref())
 # Llenamos el valor de la referencia con nuevos valores
{
if ($n == 0)
{
    foreach my $keys (keys $referencia)
    {
        print  " $keys"; # Imprimimos las columnas
    }
}
print "\n";

foreach my $keys (keys $referencia)
  {
        print  " $referencia->{$keys}"; # Imprimimos las columnas
  }
$n++;
}
print "\n";

Con eso simulamos la impresion de MySQL,tendriamos que ponerle una barras tipo exel,pero con eso nos manda la impresión tabla columna de MySQL.

El script completo queda así:

Enlace
Eso es todo,no lo explico mas porque no tengo tiempo,pero si tienen dudas comenten.

Como ven es un uso de shell,pero así se inicia todo,esto se podría hacer un tipo phpmyadmin en programación web o programa en Gtk/Qt/etc para sistemas operativos:





Eso es todo :D.

Mas información.



Leer más...

martes, 2 de julio de 2013

[Shell] cut tutorial Linux

En esta ocasión veremos este comando de la shell de tipo ejecutable (type cut),el cual nos sirve para hacer filtrado de información basado en delimitadores,y columnas,este comando se puede comparar con algunas funciones de lenguajes de programación como split,explode,map,etc el cual nos maneja datos a partir de un delimitador:

En Perl:

#!/usr/bin/env perl

my @delim = split(":","http://www.itimetux.com");

foreach my $d (@delim)
{
    print "$d\n";
}

Lo que hace ese codigo es crear un arreglo basado en el delimitador :,osea crea dos :

1 . http
2 . //www.itimetux.com

Y el : no lo muestra

En Php se puede con explode,en ruby con split,etc,pero aquí lo importante es hacerlo con cut para ejecutarlo en Tuberias Unix,veamos un ejemplo:

Primero que nada necesitamos saber para que sirve exactamente cut de Unix,si creen que es como cortar y pegar de un explorador de archivos,no lo es si lo que queremos es cortar y pegar un archivo el equivalente seria en Unix mv:

mv archivo ruta_archivo
cut es una herramienta de filtrado de texto basado en delimitadores y especificadores de caracteres o bytes.

Por ejemplo tenemos el comando date que nos muestra el tiempo:

date
Ahora con una tuberia usando cut mostramos l fecha basado en el delimitador espacio:

date | cut -d " " -f 5
Bien que hicimos aquí?

No de hice copy and paste :P

Lo que hicimos fue dividir la salida de date(stdout) con cut basado en el delimitador espacio(" "), esto no lo devuelve en columnas los cuales consultamos con el argumento -f, por ejemplo en ese ejemplo tenemos 7 f(fields)

f1 f2 f3 f4 f5 f6 f7mar jul  2 18:50:41 CDT 2013
Ojo,devuelve columnas aquí si nos muestra solo un valor es porque solo es una linea:


Veamos otro ejemplo:

Llenamos un archivo de texto con el date unas cuantas veces y usamos el mismo comando:

for i in {1..5}; do date >> date.txt; done

cut -d " " -f 5 date.txt
Muestra lo mismo pero en todas las columnas:


Como se arregla esto?

Esto lo podemos arreglar con un pipe usando sed,pero ese ya es otro asunto,ahora a la explicación de cut:

Primero que nada y después de esto tenemos que ver siempre la ayuda del comando con el parámetro help,que trae todo lo que les voy a comentar y mas:

cut --help

Bien,primero que nada debemos saber que se hace con los comandos que acabamos de usar:

-d # Es un delimitador el cual se basa en un solo caracter,en este caso usamos el caracter "/",debe ir entre comillas para evitar problemas con caracteres como \ o ;.

 -f # Nos muestra las columnas creadas por el delimitador,se puede usar con un solo numero como (-f 1),o con rango como (-f 1-5) , que nos mostraría de la columna 1 a la 5 o solo la columna 1 y 5(-f 1,5).

Lo contrario es usar el parámetro (--complement),este parámetro nos indica que lo que queremos ver es lo que no indicamos con el parámetro f,también el parámetro (-s) nos muestra las columnas que no contengan el delimitador.

Los parámetros -c y -b nos muestran los caracteres y los bytes basados en rangos o en un solo numero,por ejemplo mostrar los 5 primeros caracteres:


Eso es todo,es lo mas importante(en mi opinión) y para ver mas info:

man cut && cut --help | less





Leer más...