Header php redireccion de una web a otra a traves de php

Si quiere redirigir su pagina web a otra pagina web por ejemplo al entrar en el dominio y no tiene forma de como realizarlo, lo mejor para esto es copiar este codigo fuente en su index.php y subirlo por ftp, lo unico que tiene que cambiar es el parametro que tiene el Location para redirigirlo por una cabecera a otra página web!!

 
<html>
<?php
/* This will give an error. Note the output
 * above, which is before the header() call */
header('Location: http://www.tuweb.com/');
exit;
?>

Posted on

Tareas de mantenimiento en una web sirve para WordPress

Cuando nos disponemos a hacerle cambios en una plataforma un poco delicada como puede ser moodle o un desarrollo a medida, hay a veces que para implementar dichos cambios en dichas plataformas necesitas tambien interactuar con tu base de datos, estos cambios hacen que los usuarios puedan entrar a registrarse y hacer alguna modificacion en sus perfiles o bien hacer alguna intervencion y al estar tu tocando dicha base de datos puedes ocasionar perdidas en tu web, para evitar esto aqui os dejo un .htaccess que lo que hace es que todos los usuarios que entren a la plataforma entren en actualizando.html menos tu ip para que compruebes dicha intervencion y que los codigos que estan implementando estan todos correctos.

Estos cambiso tambien sirven para plataformas en wordpress y tambien utilizando * y demas cosas necesarias del .htaccess sirven para otras plataformas.

RewriteCond %{REQUEST_URI} !/actualizando.html$
 
  RewriteCond %{REMOTE_HOST} !^72\.010\.238\.66
RewriteRule $ http://tuweb.com/actualizando.html
 [R=302,L]

Aqui os dejo otro comentario o aporte para web que no sea wordpress y querais tambien realizar las tareas de mantenimiento.

(adsbygoogle = window.adsbygoogle || []).push({});

RewriteEngine On
ErrorDocument 403 http://www.tuweb.com/actualizando.html
Order deny,allow
Deny from all
Allow from xx.xx.xx.xx #ip que quieres permitir

 
(adsbygoogle = window.adsbygoogle || []).push({});

Posted on

Que hacer con una memoria usb, con un pendrive

Una memoria usb, pendrive, memory stick tienen muchos nombres pero todo el mundo ya los conoce, esos dispositivos que conectando simplemente al usb del ordenador sea nuestro o del amigo, nos permite copiar de un sitio a otro toda la información que necesitamos, como documentos de texto, películas, series, mp3 en fin todo lo que sea para llevar de un sitio a otro.

Ahora bien te imaginas poderte llevar tu msn, skype, el navegador con todos tus favoritos, tu cliente de correo electrónico con todos tus mail, todos perfectamente configurados, listos para usar nada mas conectarlo al usb. Pues sorprendentemente acabo de encontrar un programa que es capaz de ello, se instala en el usb y al conectarlo nos hace aparecer un menú el en systray de Windows, con todas las aplicaciones instaladas en el.

Tiene una infinidad de programas para elegir gratis, otros con licencia freeware y unos pocos shareware pero vale la pena echarle el ojo la verdad.

PortableApps es la aplicación que te estoy hablando, esta aplicación no contiene spyware mi te pedirá el correo electrónico para inundarlo de spam, parece ser que te da mucho por muy poco.

Posted on

Evitar que Windows pida contraseña para iniciar sesión

Nunca os a pasado que tras instalar los drivers de la tarjeta grafica o algún software Windows pide nombre de usuario y contraseña. Quizás simplemente sois el único usuario de ese PC y Windows os pide contraseña para entrar en el sistema. Lo que explicare a continuación sirve para que Windows no pida usuario ni contraseña al iniciar el sistema y por lo tanto podréis encender el PC y dejarlo mientras arranca sin preocupaciones que os pida ninguna confirmación. La necesidad hace que perdamos mucho tiempo buscando soluciones a pequeños problemas yo he estado navegando por la pagina de Microsoft y he encontrado dos sistemas de solucionar la confirmación de usuario, de todas formas os explicare solo 1 el mas simple sin tocar registros

1.- clic en inicio > clic en ejecutar y en el texbox que aparece escribe control userpasswords2 y pulsamos aceptar Con eso hemos conseguido arrancar un programilla que trae Windows por defecto, bien lo que debemos hacer es simple

1.- seleccionamos a nuestro usuario

2.- deseleccionamos la casilla que dice “Los usuarios deben escribir su nombre y contraseña para usar el equipo”

3.- clic en aceptar, nos pedirá la contraseña de ese usuario, se introduce y listo nunca mas os pedirá la contraseña

Posted on

10 años de esunbichito.com

Doy las gracias a todos vosotros

Posted on

Conseguir que firefox navegue mas rápido

Este truco te servirá para navegar mas rápido, alto digo navegar no descargar que cambia mucho el tema, por lo que he podido leer en el post original encontrado en www.freerepublic.com la idea es muy simple, se trata de conseguir que firefox haga varias peticiones al servidor html y que este te las devuelva a la vez firefox ira mostrando el resultado sin esperar a tener la pagina lista como pasa actualmente.

De este truco os podréis veneficiar sobre todo, aquellas personas que tienen conexiones de mas de 4M pero al hacer descargas su proveedor de Internet no le da el ancho de banda al completo y solo tienes una porción de su ancho de banda total, al modificar lo que os explicara firefox hará tantas peticiones como le digamos de esta forma conseguiremos sacarle todo el partido posible a nuestra conexión.

La cosa va de la siguiente forma:
1. Escribe donde normalmente introducimos la dirección de Internet about:config y pulsa intro
1.2 busca y si no la tienes introdece las siguientes cadenas
1.3 network.http.pipelining valor true
1.4 network.http.proxy.pipelining valor true
1.5 network.http.pipelining.maxrequests valor 10
1.6 nglayout.initialpaint.delay valor 0
Que hemos hecho?
Bien la respuesta es simple activando el pipeling hacemos que firefox realice tantas conexiones como le hemos dicho en nuestro caso 10 hay sitios que ponen 100 o 30 pero yo creo que con 10 es mas que suficiente, con la ultima línea modificada le hemos dicho que no espere a tener la pagina descargada para mostrar el resultado.

He de decir ahora que habéis llegado aquí, que siempre hay una forma de hacer las cosas fáciles XD en freepublic en uno de los comentarios había un link a la propia pagina de firefox hacia la sección de adonis, en esa pagina había un addon para modificar todo esto como parte de la configuración de firefox. El addon es Tweak Network pero ya sabéis que pasa que abecés no funciona como deberían por eso os he puesto la versión casera sin addon

Posted on

como hacer una barra superior en html

introducción

Las nuevas tendencias web respecto a versiones móviles nos dicen que es muy cómodo tener una barra superior en HTML fija, de esta manera tenemos muchísima pantalla para cargar nuestro contenido y ocupamos un mínimo para menús.

Evidentemente todo esto también es exportable a cabecera fija en HTML y css, menú fijo superior en HTML y css o como lo quieras llamar.

Crear una barra superior fija con CSS y HMTL es realmente sencillo solo necesita 3 líneas de código css, así de simple el resto es para decorar como se puede ver en esta demo y puedes descargar desde este link

Preparando el código css para crear la barra superior

.barra-superior {
  width: 100%; /* esto hace que la barra ocupe el 100% del espacio*/
  position: fixed;/*esto hace que la barra quede fija donde está situada*/
  z-index: 10; /*la magia del código, hace que quede por encima del resto de elementos*/
}
/*La siguiente clase solo es para dar formato a la barra*/
/*Se le aplicara una ligera transparencia*/
/*Para dar el efecto que el texto pasa por debajo*/
.formato-barra-superior{
	 background: rgba(0,0,0,0.9); 
}

Codigo HTML para conseguir la barra superior fija

El código HTML para conseguir la barra superior fija es muy simple solo hay que tener en cuenta que hay que sacarlo del resto del flujo HTML

  <section class="wrapper barra-superior formato-barra-superior">
		<nav>
			<ul>
				<li><a href="#">opcion 1</a></li>
				<li><a href="#">opcion 2</a></li>
				<li><a href="#">opcion 3</a></li>
				<li><a href="#">opcion 4</a></li>
				<li><a href="#">opcion 5</a></li>
			</ul>
    </nav>
    </section>

Conclusión

Con estos sencillos códigos que se pueden copiar y pegar conseguirás headers y barras superiores fijas que no se moverán de esta manera tu visitante siempre tendrá disponible las herramientas necesarias para navegar cómodamente por tu web

Posted on

Ruby on Rails desde Cero: Instalación & Configuración

Bienvenidos a Git desde cero, esta serie de tutoriales tratará explicar y alejar el miedo que algunos de nosotros sentimos cuando comenzamos a utilizar un controlador de versiones por primera vez.

¿Qué es Git?

Git en pocas palabras es un controlador de versiones distribuido. Para ampliar este significado debemos responder primero la siguiente pregunta. ¿Qué es un controlador de versiones? Un controlador de versiones es un sistema que registra los cambios en un archivo o conjunto de archivos a través del tiempo para que se puedan recuperar versiones específicas de los mismos más adelante.

Ahora, ¿Por qué es distribuido? Cuando los usuarios descargan la última versión de los archivos no solo están descargando los archivos; sino también realizando una copia fiel y exacta (copia de seguridad) del repositorio (carpeta donde se alojan estos archivos) de esta manera si dicho repositorio muere, cualquiera de los usuarios que descargaron estos archivos pueden restaurar el estado de ese del mismo haciendo uso de su copia de seguridad. Por otra parte esto permite que se puedan tener varios repositorios remotos para poder trabajar y colaborar con diferentes grupos de personas al mismo tiempo en un mismo proyecto, cosa que no es posible con los sistemas centralizados.

Características que destacan de Git como control de versiones:

Fotografías rápidas, NO diferencias – A la hora de guardar la información de varios archivos, Git toma una fotografía rápida del estado de los mismos y guarda las referencias de esta fotografía. Luego para ser eficiente revisa los archivos que no fueron modificados y cambia las referencias de los mismos a su versión anterior.
Casi todas las operaciones son locales – Sí ya descargaste un repositorio no es necesario estar conectado a una red o conexión a internet para trabajar sobre archivos, todo lo necesario se encuentra en tu computadora.
Integridad de la data – Git antes de guardar la fotografía del estado de un archivo realiza un checksum de la data. De esta manera es imposible cambiar el contenido de cualquier archivo sin que Git lo note.
Git generalmente solo añade data – Al trabajar en cualquier archivo y almacenar los cambios se está agregando data a la base de datos de Git. Esto nos da la seguridad de que si estos cambios fueron persistidos es muy difícil que se pierdan.
Trabaja con tres estados – Lo más importante para recordar de Git son los tres(3) estados en que los archivos residen: consolidada (committed), modificados y en escenario (stage). Modificado, se han detectado cambios en el archivo pero no se han consolidado. Consolidado, el archivo y su data han sido guardados satisfactoriamente en la base de datos de Git. En escenario se han marcado las modificaciones de un archivo y su próximo paso será consolidar la data.

Instalación

Ya que conocemos un poco sobre Git, es hora de instalarlo. Dependiendo del Sistema Operativo en que nos encontremos utilizaremos la instalación apropiada.

Mac OS

Método Recomendado: Para realizar la instalación en este Sistema Operativo es recomendable tener instalado Homebrew. Haciendo uso del Terminal.app y de hombrew, escribimos el siguiente comando:

$ brew install git

Si el terminal no es de tú preferencia puede hacer uso de un cliente de interfaz gráfica para realizar la instalación de Git. El cliente de Github nos facilita esta tarea.

Linux

Si nos encontramos en distribuciones como Fedora, podemos hacer uso del manejador de paquetes de dicha distribución y mediante el siguiente comando instalaremos Git:

$ yum install git-core

Si nos encontramos en distribuciones basadas en Debian, tal como Ubuntu, utilizamos el siguiente comando:

$ apt-get install git

Windows

Si nos encontramos el Windows la manera más sencilla de realizar la instalación es descargar el Instalador y seguir los pasos.

Configuración

Ya que tenemos Git instalado, es tiempo de configurarlo. Para esto, tenemos que abrir el Terminal.
Configuración del nombre de usuario

Lo primero que de debe hacer es decirle a Git cual será nombre de la persona que hará uso de él:

$ git config --global user.name "Pedro Perez"

Configuración del email

Git hace uso del email del usuario cuando consolida la data, por esta razón necesitamos configurarlo:

$ git config --global user.email "pedroperez@ejemplo.com"

Podemos revisar que estén bien escritos haciendo uso del siguiente comando:

$ git config --list
user.name=Pedro Perez
user.email=pedroperez@ejemplo.com

También debemos conocer que Git guarda esta información dentro del archivo oculto .gitconfig en el Home del usuario. Utilizando el siguiente comando podemos observar la información suministramos durante la configuración:

$ cat ~/.gitconfig
[user]
        name = Pedro Perez
        email = pedroperez@ejemplo.com

Cuenta en Github.com

Previamente explicamos que no es necesario estar conectado a una red o tener conexión a internet para poder hacer uso de Git. Con esto no queremos decir que únicamente haremos uso de esta herramienta manera local, sino más bien queremos que nuestros archivos (código, fotos, etc.…) se encuentren tanto en nuestro computador como en un servidor remoto. Por esta razón se recomienda abrir una cuenta en Github.com de manera gratuita para el alojamiento remoto de nuestros archivos.

Comandos básicos

Tenemos Git instalado y listo para usar, ha llegado el momento de conocer los pasos necesarios para la inicialización de un repositorio, agregar archivos al escenario y consolidarlos.

Inicialización de un repositorio

Un repositorio no es más que una carpeta o conjunto de carpetas que contienen archivos.

Podemos crear una carpeta y luego iniciar el repositorio dentro, utilizando los siguientes comandos:

$ mkdir Ejemplo && cd Ejemplo
$ git init .

Con el comando git init se crea una carpeta oculta llamada .git (se encuentra dentro de la carpeta Ejemplo) y contiene toda la información necesaria para que podamos realizar las versiones (copias de seguridad) de nuestro proyecto. En este punto Git no está llevando el control de ningún archivo.

Agregar archivos al escenario

Con nuestro repositorio listo, queremos llevar el control de nuestro primer archivo. Para esto debemos crearlo dentro de nuestra carpeta Ejemplo y agregarlo al escenario:

$ touch Archivo1.txt # Creamos el archivo vacío
$ echo 'Hola Mundo' >> Archivo1.txt  # Le agregamos texto al archivo
$ git add Archivo1.txt # colocamos el archivo en escenario

Al ejecutar el comando git add Archivo1.txt estamos confirmando (agregando el archivo al escenario) que los cambios que realizamos sobre Archivo1.txt se quieren respaldar la próxima vez que consolidemos la data.

Consolidar la información.

Para consolidar el archivo previamente creado y puesto en escenario debemos utilizar el siguiente comando:

$ git commit -m "Commit Inicial"

nota: La bandera -m indica que se debe consolidar el archivo con un mensaje informativo.

Conclusión

En este capítulo aprendimos los conceptos básicos de Git; tales como instalación en múltiples Sistemas Operativos, configuración desde cero y a persistir información en su base de datos. En los próximo capítulos iremos conociendo más comandos y trataremos de enseñarle al usuario el flujo de trabajo que utilizamos en Codehero cuando hacemos uso de esta herramienta.

Posted on

Curso Ruby desde Cero: Mi primera aplicación en Ruby

Bienvenidos una vez más a Ruby desde cero, curso con el cual aprendemos del lenguaje sin necesidad de tener previo conocimiento en el tema. Hasta este capítulo ya abarcamos todos los puntos del curso, lo que nos hace héroes en Ruby desde Cero.

Para finalizar con este curso desarrollaremos una pequeña aplicación en la que tocaremos muchos de los conceptos vistos en la serie. La aplicación consiste en una simple lista de estudiantes donde tendremos funcionalidad de agregar, buscar, listar y ordenar a los estudiantes guardados en un archivo plano.

NOTA: En las líneas de código se omitirán los acentos.

Estructura principal

Para empezar con nuestro proyecto final prepararemos la estructura de nuestro proyecto empezando con un archivo que inicia el sistema (la llamaremos init.rb), un controlador (llamado controlador.rb) dentro de un directorio (lib) y nuestro archivo de texto plano (estudiantes.txt), el cual funcionará como base de datos. Empecemos con el código de init.rb:

## Declaramos la ruta del proyecto
APP_ROOT = File.dirname(__FILE__)

# Agregamos la ruta del directorio lib a nuestro proyecto para despreocuparnos
# al agregarla en todo momento
# File.join(APP_ROOT, 'lib') =>  APP_ROOT/lib
$:.unshift( File.join(APP_ROOT, 'lib') )

# Le decimos a Ruby que vamos a utilizar el controlador
require 'controlador'

# Inicializamos nuestro controlador
controlador = Controlador.new('estudiantes.txt')

# Disparamos nuestro proceso principal
controlador.launch!

Luego configuramos nuestra clase controlador, que tendrá el constructor de la clase, un par de métodos para el encabezado y pie del sistema y por último el método que dispara los eventos del sistema.

class Controlador
  # constructor de la clase. En esta verificaremos
  # si existe el archivo plano con los estudiantes
  # y si no creamos uno nuevo
  def initialize(path=nil)
  end

  # launch! este metodo tiene un loop que va a recibir las acciones
  # que tendra la aplicacion para procesarlas,
  # llama al encabezado y pie de aplicacion al principio y al final
  def launch!
    introduction
    conclusion
  end

  # Encabezado de la aplicacion
  def introduction
    puts "#" * 60
    puts "\n\n--- Bienvenido a al tutorial de CODEHERO ---\n"
    puts "Este ejemplo pertenece a la serie Ruby desde Cero.\n\n"
  end

  # Pie de la aplicacion
  def conclusion
    puts "#" * 60
    puts "\n\n--- Bienvenido a al tutorial de CODEHERO ---\n\n"
    puts "Este ejemplo pertenece a la serie Ruby desde Cero.\n\n"
  end
end

Hasta este momento ya utilizamos algunos conceptos estudiados en el curso como manejo de directorios, clases y objetos. Al ejecutar nuestra aplicación, así como la tenemos, tendremos lo siguiente:

############################################################
--- Bienvenido a al tutorial de CODEHERO ---
Este ejemplo pertenece a la serie Ruby desde Cero.

--- Hasta luego y recuerda visitarnos en www.CodeHero.co! ---
############################################################

Lógica y modelos de la aplicación

Esta etapa es de las más importante de nuestra aplicación, crearemos una nueva clase modelo (“estudiante.rb“) donde tendremos toda la lógica correspondiente al estudiante y editaremos brevemente nuestro controlador para que el sistema funcione bien. Empecemos con el modelo:

class Estudiante

  # Variable de clases con la direccion del archivo plano
  @@filepath = nil
  def self.filepath=(path=nil)
    @@filepath = File.join(APP_ROOT, path)
  end

  attr_accessor :nombre, :identificador, :fecha_nacimiento

  # Verificamos que el archivo exista
  def self.existe_archivo?
    if @@filepath && File.exists?(@@filepath)
      return true
    else
      return false
    end
  end

  # Validamos que el archivo exista, sea legible y modificable
  def self.validar_archivo?
    return false unless @@filepath
    return false unless File.exists?(@@filepath)
    return false unless File.readable?(@@filepath)
    return false unless File.writable?(@@filepath)
    return true
  end

  # Crea un archivo con permisos de escritura
  def self.crear_archivo
    File.open(@@filepath, 'w') unless existe_archivo?
    return validar_archivo?
  end

  # Recorremos el archivo plano y retornamos un arreglo con los
  # objetos estudiantes que esten en el
  def self.restaurantes_guardados
    estudiantes = []
    if validar_archivo?
      file = File.new(@@filepath, 'r')
      file.each_line do |line|
        estudiantes << Estudiante.new.importar_linea(line.chomp)
      end
      file.close
    end
    return estudiantes
  end

  # Constructor de la aplicacion, recibe los datos introducidos
  # desde la aplicacion
  def initialize(args={})
    @nombre           = args[:nombre]    || ""
    @identificador    = args[:identificador] || ""
    @fecha_nacimiento = args[:fecha_nacimiento]   || ""
  end

  # Guarda el archivo el estudiante en el archivo plano
  def guardar
    return false unless Estudiante.validar_archivo?
    File.open(@@filepath, 'a') do |file|
      file.puts "#{[@nombre, @identificador, @fecha_nacimiento].join("\t")}\n"
    end
    return true
  end
end

Una vez tenemos nuestro modelo Estudiante con la funcionalidad de agregar y listar sus objetos y todas las funciones que verifican el archivo, plano donde vamos almacenar la información, modificamos nuestro controlador para agregarle funcionalidad launch! y empiece a tomar color nuestra aplicación.

# launch! este metodo tiene un loop que va a recibir las acciones
# que tendra la aplicacion para procesarlas
# llama al encabezado y pie de aplicacion al principio y al final
def launch!
  introduction

  result = nil
  until result == :quit
    action, args = acciones
    result = hacer_accion(action, args)
  end
  conclusion
end

# Nos da las acciones que vamos a utilizar en nuestro proyecto
# y nos prepara el sistema para recibir las acciones por el usuario
def acciones
  action = nil

  puts "Acciones: " + ['listar', 'buscar', 'agregar', 'salir'].join(", ")
  print "> "
  user_response = gets.chomp
  args = user_response.downcase.strip.split(' ')
  action = args.shift

  return action, args
end

# Recibe la accion que se solicito por pantalla y
# se llama a las funciones que cumplan los requisitos del usuario
def hacer_accion(action, args=[])
  case action
  when 'listar'
    puts "listamos a los estudiantes"
  when 'buscar'
    puts "Buscamos por palabra clave"
  when 'agregar'
    puts "Agregamos un estudiante"
  when 'salir'
    return :quit
  else
    puts "\nel comando no es valido\n"
  end
end

Una vez modificadas estas clases con unos ajustes extras, que podrán ver en nuestro repositorio establecido para el proyecto, tendremos el siguiente resultado.

############################################################
--- Bienvenido a al tutorial de CODEHERO ---
Este ejemplo pertenece a la serie Ruby desde Cero.

Acciones: listar, buscar, agregar, salir
> listar
listamos a los estudiantes

Acciones: listar, buscar, agregar, salir
> buscar
Buscamos por palabra clave

Acciones: listar, buscar, agregar, salir
> agregar
Agregamos un estudiante

Acciones: listar, buscar, agregar, salir
> CodeHero

El comando no es valido

Acciones: listar, buscar, agregar, salir
> salir

--- Hasta luego y recuerda visitarnos en www.CodeHero.co! ---
############################################################

Por último, le agregamos a nuestro controlador las acciones del proyecto (agregar, listar y buscar) que llaman a funciones dentro del modelo Estudiante, veamos estos métodos:

# trae todos los estudiantes que esten en la base de datos
def listar(args=[])

  puts "Listando usuarios"
  estudiantes = Estudiante.restaurantes_guardados
      prepara_tabla(estudiantes)
  puts "Ordena escribiendo: 'listar nombre' o 'listar por identificador'\n\n"
end

# primero consulta todos los estudiantes del archivo de texto
# luego busca que en alguno de sus atributos tenga la palabra clave
# que se esta buscando.
def buscar(keyword="")
  puts "Buscar usaurio"
  if keyword
    estudiantes = Estudiante.restaurantes_guardados
    found = estudiantes.select do |estd|
      estd.nombre.downcase.include?(keyword.downcase) ||
      estd.identificador.downcase.include?(keyword.downcase) ||
      estd.fecha_nacimiento.downcase.include?(keyword.downcase)
    end
    prepara_tabla(found)
  else
    puts "Examples: 'buscar Ricardo', 'buscar 12345', 'buscar sampayo'\n\n"
  end
end

# Crea la estructura para recibir los datos en una especie de formulario
# los recibe crea un objeto Estudiante y lo guarda en el archivo
def agregar
  puts "Agregar estudiante"
      args = {}
  print "Nombre del estudiante: "
  args[:nombre] = gets.chomp.strip

  print "identificador: "
  args[:identificador] = gets.chomp.strip

  print "fecha de nacimiento: "
  args[:fecha_nacimiento] = gets.chomp.strip

  estudiante = Estudiante.new(args)

  if estudiante.guardar
    puts "\nBien! Se agrego el usuario\n\n"
  else
    puts "\nError: No se agrego el usuario\n\n"
  end
end

Utilizando módulos

En este caso utilizaremos módulos para agregarle una funcionalidad extra a la clase String que nos edite nuestra cadena de caracteres para que cada palabra empiece en mayúscula. La clase para esto es la siguiente:

class String
  def titleize
    self.split(' ').collect {|word| word.capitalize}.join(" ")
  end
end

El método donde hacemos uso del módulo anterior para imprimir el nombre de los usuarios, es el siguiente:

def prepara_tabla(estudiantes=[])
print ” ” + “Identificador”.ljust(30)
print ” ” + “Nombre”.ljust(20)
print ” ” + “Fecha”.rjust(6) + “\n”
puts “-” * 60
estudiantes.each do |rest|
line = ” ” << rest.identificador.ljust(30) line << " " + rest.nombre.titleize.ljust(20) line << " " + rest.fecha_nacimiento.rjust(6) puts line end puts "No hay estudiantes" if estudiantes.empty? puts "-" * 60 end [ruby][/ruby]

Conclusión

En este último capítulo vimos cómo crear una aplicación sencilla en Ruby para listar y agregar estudiantes a una lista escolar. Este capítulo tiene grandes bloques de código donde se explica en cada uno de los comentarios la funcionalidad del código. Te invito a que te descargues el código de nuestro repositorio de GitHub para que pruebes el proyecto y estoy seguro que entenderás mucho mejor este capítulo.

Felicidades por lograr el nivel máximo en nuestra serie Ruby desde cero y te recomiendo que no te quedes solo con la teoría que aquí te damos, si no, que sigas practicando y te volverás un verdadero héroe en este lenguaje.

Te recordamos que Ruby es un lenguaje de programación potente y flexible que te recomiendo siempre tener en cuenta a la hora de cualquier desarrollo por sus características, orden, facilidad de aprendizaje y comprensión del código.

También te recomiendo si quieres seguir con este lenguaje le eches un vistazo a nuestra serie Ruby on Rails desde cero, para aprender del famoso Ruby on Rails, framework de desarrollo web de código abierto, siguiendo el paradigma de la arquitectura Modelo Vista Controlador (MVC), el cual permite un desarrollo más eficiente, desacoplado y sostenible de las aplicaciones.

¡Hasta el próximo capítulo!

Posted on

Curso Ruby desde Cero: Manejo de Archivos y Directorios

Bienvenidos una vez más a Ruby desde cero, curso con el cual aprendemos del lenguaje sin necesidad de tener previo conocimiento en el tema. En el capítulo anterior estuvimos estudiando el concepto de módulos aplicado al lenguaje. En este nuevo capítulo estaremos estudiando el manejo de archivos en Ruby, desde como abrirlo hasta como escribir y leer información del mismo.

Rutas y Directorios

La rutas son las direcciones que nos indican cómo llegar a un archivo o directorio en el sistema. Para este capítulo aprenderemos una serie de conceptos básicos para manejarnos entre directorios con Ruby.

A continuación estudiaremos una serie de comandos básicos para el manejo de rutas y directorios con Ruby.

Ruta actual pwd()

Para los que están familiarizados con comandos SHELL, seguramente reconocerán este método. pwd simplemente nos da la ruta del directorio actual donde estemos trabajando, aunque este concepto es bastante sencillo. Veamos un ejemplo para comprender mejor el concepto de ruta actual.

$ irb
>> Dir.pwd
   "/Users/ricardosampayo/Desktop"

Como ven el método pwd de la clase Dir nos da la información de la ruta actual donde se ejecute ese comando. En el caso del ejemplo está ubicado en mi escritorio.

Cambiar de Directorio chdir()

chdir simplemente nos permite movernos a un directorio siempre y cuando sepamos la ruta. Este método es similar al cd en SHELL. Veamos un ejemplo:

Todos los ejemplos utilizados en este curso son mediante el REPL irb o pry.

>> Dir.pwd              #ruta actual
   "/Users/ricardosampayo/Desktop"
#nos cambiamos al directorio test dentro del directorio actual
>> Dir.chdir "test"
   0
>> Dir.pwd              #nueva ruta actual
   "/Users/ricardosampayo/Desktop/test"

>> Dir.pwd              #ruta actual
   "/Users/ricardosampayo"
# nos cambiamos a la carptea test utilizando la ruta absoluta
>> Dir.chdir "/Users/ricardosampayo/Desktop/test"
   0
>> Dir.pwd              #nueva ruta actual
   "/Users/ricardosampayo/Desktop/test"

Como pueden ver en los ejemplos, es posible cambiarnos de directorio utilizando tanto la ruta relativa como absoluta del sistema.

Buscar en un directorio glob()

glob nos permite buscar archivos dentro del directorio de trabajo. Veamos un ejemplo para probar este método:

>> Dir.glob "*.rb"          # Consultamos todos los archivos con extensión rb
   ["codeheroRuby.rb", "codeheroRubyClases.rb", "modulo_ruby.rb"]

Como vemos en el ejemplo podemos utilizar un asterisco ** ( * ) ** como un comodín para buscar cualquier coincidencia, por eso en este caso nos lista todos los archivos que terminen en .rb, si colocáramos ** Dir.glob “*” ** nos listaría todos los archivos dentro del directorio que estemos manejando.

Crear nuevos directorios mkdir()

Al igual que en sistemas operativos basados en Unix mkdir nos crea nuevos directorios o carpetas. Este método recibe como variable la ruta y el nombre de la nueva carpeta que estamos creando, veamos el siguiente ejemplo:

# consultamos la carpeta
>> Dir.glob "*"
   []
# creamos la nueva carpeta, no colocamos ruta por lo tanto
# se crea en la carpeta donde estemos trabajando
>> Dir.mkdir "test"
   0
# consultamos nuevamente la dirección para verificar que efectivamente
# creamos una nueva carpeta o directorio
>> Dir.glob "*"
   ["test"]

Archivos

Una vez entendamos cómo manipular los directorios nos vamos a la gestión de archivos. En esta parte del capítulo aprenderemos todo lo relacionado con el manejo de archivos.

¿Cómo crear un archivo?

Para abrir un archivo simplemente debemos crear un objeto de la clase File (File.new()) o utilizar el método estático open (File.open()) y esto nos devolverá un objeto de tipo File al que podremos manipular.

Para acceder a los archivos debemos pasarle un segundo valor por parámetros que nos indica como vamos abrir el archivo. Veamos los parámetros para abrir y crear un archivo:

  • r: (sólo lectura) Modo por defecto.
  • r+: (lectura y escritura) Comienza la escritura al principio del archivo.
  • w: (sólo escritura) Borra el contenido del archivo o crea un nuevo archivo para escritura.
  • w+: (lectura y escritura) Borra el contenido del archivo o crea un nuevo archivo para lectura y escritura.
  • a: (sólo escritura) Comienza la escritura al final del archivo si existe y si no crea uno nuevo.
  • a+: (lectura y escritura) permite leer y escribir ubicando el cursor al final del archivo si éste existe y si no crea uno nuevo.

Veamos ejemplos de cómo crear y obtener un archivo:

#consultamos el directorio donde estamos trabajando
>> Dir.glob "*"
   ["test"]
#creamos y obtenemos un archivo nuevo
>> archivo =File.new("pruebaCodeHero.txt","w")
   File:pruebaCodeHero.txt
#intentamos crear un archivo pasándole por parámetro solo lectura
>> archivo =File.new("pruebaCodeHeroError.txt","r")
   Errno::ENOENT: No such file or directory - pruebaCodeHeroError.txt
# consultamos nuevamente la carpeta
>> Dir.glob "*"
   ["pruebaCodeHero.txt", "test"]

Como vemos en el ejemplo es importante el uso de los parámetros que nos dan los permisos para manejar los archivos. En el ejemplo vemos claramente cómo intentamos crear un archivo otorgándole permisos únicamente de lectura y éste nos da un error ya que el archivo no existe y no tiene permisos de crear uno nuevo.

¿Cómo leer un archivo?

En Ruby el comando para leer un archivo es read().

Es importante tener en cuenta que las cadenas de caracteres(strings) de Ruby pueden tener datos binarios y no sólo de texto.

Veamos un ejemplo simple para ver cómo funciona bien esto. En el ejemplo preparamos un archivo de texto con dos lineas escritas.

#tomamos el archivo (ya estaba creado con las dos lineas escritas)
>> archivo =File.new("pruebaCodeHero.txt","r")
   File:pruebaCodeHero.txt
#leemos el archivo
>> archivo.read
   "Esto es Codehero\nLa mejor herramienta para aprender a programar en espaniol"

Como vemos el read() nos da la lectura completa del archivo pero, ¿qué pasa si necesitamos más, Si necesitamos leer línea por línea?. En Ruby disponemos de una serie de métodos que nos hacen la vida fácil para leer los archivos.

rewind – Nos regresa a la primera línea del archivo
readline – Nos lee una línea y nos ubica en la siguiente línea
readlines – Nos da un arreglo de las líneas que tenemos por delante en el archivo y nos ubica al final.
lineno – Nos da la línea donde estamos ubicados.

Veamos estos métodos aplicados a nuestro ejemplo anterior:

#tomamos el archivo (ya estaba creado con las dos lineas escritas)
>> archivo =File.new("pruebaCodeHero.txt","r")
   File:pruebaCodeHero.txt
#leemos la primera linea
>> archivo.readline
  "Esto es Codehero\n"
#leemos la segunda linea
>> archivo.readline
   "La mejor herramienta para aprender a programar en espaniol"
#en que linea estamos?
>> archivo.lineno
   2
#pedimos una tercera linea (obviamente error)
>> archivo.readline
   EOFError: end of file reached
#regresamos al principio
>> archivo.rewind
   0
#pedimos todas las lineas en un array
>> archivo.readlines
   ["Esto es Codehero\n", "La mejor herramienta para aprender a programar en espaniol"]

En Ruby una vez hayamos leído una línea no la veremos más a menos que regresemos en el archivo.

¿Cómo escribir un archivo?

En Ruby para escribir información en un archivo usamos el método write() o puts(). La principal diferencia es que puts añade un salto de línea luego de escribirla y write no.

Vemos un ejemplo de cómo escribir en nuestro archivo

#tomamos el archivo (al colocar w+ lo limpia)
>> archivo =File.new("pruebaCodeHero.txt","w+")
   File:pruebaCodeHero.txt
#escribimos con un salto de linea al final
>> archivo.puts "Codehero"
   nil
#escribimos
>> archivo.write "los mejores cursos"
   18
#escribimos con un salto de linea al final
>> archivo.puts " en espaniol"
   nil
#escribimos
>> archivo.write "por Ricardo Sampayo"
   19
#regresamos al comienzo de la linea
>> archivo.rewind
   0
#imprimimos un arras con las lineas dentro del archivo
>> archivo.readlines
   ["Codehero\n", "los mejores cursos en espaniol\n", "por Ricardo Sampayo"]

¿Cómo eliminar y renombrar un archivo?

En Ruby podemos remover un archivo usando el método delete(nombre) y renombrarlo con el método rename(nombre_viejo, nombre_nuevo), Veamos un ejemplo de esto

#consultamos el directorio
>> Dir.glob "*"
   ["pruebaCodeHero.txt", "test"]
#renombramos el archivo
>> File.rename("pruebaCodeHero.txt","listoParaBorrar.txt")
   0
#consultamos nuevamente el directorio para ver los cambios
>> Dir.glob "*"
   ["listoParaBorrar.txt", "test"]
#borramos el archivo
>> File.delete("listoParaBorrar.txt")
   1
#consultamos nuevamente el directorio para ver los cambios
>> Dir.glob "*"
   ["test"]

Conclusión

En este capítulo aprendimos todo lo relacionado con el manejo de archivos y directorios en Ruby, funciones básicas como abrirlos, leerlos, editarlos y eliminarlos.

Si te surgen dudas con nuestros cursos, no te detengas y danos tus comentarios, que con gusto estamos dispuestos a resolver tus inquietudes.

¡Hasta el próximo capítulo!

Posted on