Lista de comandos en Bash sobre GNU/Linux

Jorge nos dice en un comentario:

hola nache, como ya sabemos todos que juande nos va ha dejar un folio con los commandos que creamos que vayamos a necesitar, podrias dejarnos un pequeño resumen de lo que nos hará falta a la hora del examen, mas que ná es por que seguramente el que hagamos nosotros estará incompleto […].

Bien, de lo que más hay que acordarse es de la sintáxis, es decir, de como se escribe el programa. Al fin y al cabo, con un «ls /bin/» o con un «ls /usr/bin/» podemos ver la mayoría de los comandos disponibles. Además, si todo va bien y Juande no nos quita los «man pages»  (dijo que estarían accesibles) disponemos de una gran ayuda a la hora de hacer el script. Por ejemplo, con «man sh» podemos ver un extenso manual de uso de la shell, lo cual nos indica la sintáxis que debemos usar en los scripts. Estaría bien echarle un vistazo en casa para saber donde se encuentran las cosas y saber interpretar la sintáxis que nos plantea esa página de manual. Podemos encontrar la sintáxis de while, de if, de case, etc etc…

Aun así, debemos recordar que seguramente en nuestros scripts nos pedirá cosas como:

-buscar un fichero

-buscar un contenido dentro de un fichero y mostrar una parte

-contar lineas de un fichero o extraer una linea concreta

-bucles (for o while)

-los case

-manejar información obtenida de un comando (ver quién está conectado con who) y separarla con «cut» y «tr»

-pedir que introduzcamos por teclado  una información (parametros) para tratarla desde dentro del script

-pasar información a un script desde la linea de comandos

Vamos a realizar una lista, vamos a completar la que ya publiqué en esta entrada: http://nachesti.wordpress.com/2009/12/04/manejo-basico-de-la-terminal-en-gnulinux/

Extraer la linea 10 de un archivo:

head -10 /etc/passwd | tail -1

Extraer la linea 10 y el primer dato de una serie de datos separados por dos puntos

head -10 /etc/passwd | tail -1 | cut -d»:» -f1

Compactar espacios en uno solo:

tr -s «» » »

Reemplazar un caracter por otro:

tr «a» «b»

Obtener el segundo dato de una serie de dato separados por dos puntos:

echo «dato1:dato2:dato3:dato4″ | cut -d»:» -f2

Obtener quién está conectado en la máquina (el nombre de usuario):

who | tr -s»» » » | cut -d» » -f1

Obtener la fecha de conexión de los usuaros conectados:

who | tr -s»» » »  | cut -d» » -f3

Obtener la hora de conexión de los usuarios conectados:

who | tr -s»» » »  | cut -d» » -f4

Obtener usuario, fecha y hora a la vez:

who | tr -s»» » »  | cut -d» » -f1,3,4

Con tr y esa sintáxis obligamos al comando who a compactar todos los espacios en uno solo, para luego decirle a cut que usando un espacio como delimitador de datos, obtenga la fila o filas dadas (-f1 o -f1,3,4)


Obtener los usuarios que empiecen por aj dentro del archivo passwd:

grep ^aj /etc/passwd

Hacer lo anterior y obtener la linea 10:

grep ^aj /etc/passwd | head -10 | tail -1

Usando el sombrerito ^ indicamos que lo que buscamos se encuentra justo al principio de la linea y no en otro lugar


Buscar un fichero:

find /proc -name «cpuinfo» 2>/dev/null

Usando 2>/dev/null  le decimos que toda la basura que no nos interesa la mande a otro lugar y no nos la muestre


Pasando información por parametros:

./script parametro1 parametro2 parametro3

los parametros, dentro del script serán las variables $1 $2 y $3


Pasar información leyendo entrada de teclado:

read nombrevariable

El texto introducido estará en la variable $nombrevariable


Comprobando si dos ficheros son iguales:

cmp fichero1 ficharo2

Enlaces duros:

ln /etc/passwd $HOME/passwd

Enlaces blandos:

ln -s /etc/passwd $HOME/passwd2

Listar el arbol de directorios y ficheros de un lugar dado:

tree /etc/

Buscar archivos:

find -name «nombrearchivo» /lugar/donde/buscamos/

find -name «passwd» /etc/

find -name «pass*» /etc/

Almacenar la salida de un comando en una variable:

variable=`cat /etc/passwd`

Se usan las comillas que hay al lado de la «P», la misma tecla que tiene un ^ y un [


Incrementar el valor de una variable dentro de un bucle:

i=`expr $i + 1`

#!/bin/bash
i=0

while (( $i != 10 )); do

     i=`expr $i + 1`
     echo $i

done

Tened especial cuidado con la sintáxis, comprobad que cerrais todas las comillas que habeis abierto, comprobad que todos los if, los while, los for y los case los cerrais correctamente if (fi) while (done) for (done) case (esac) etc etc…  Si os dá un error de sintáxis comprobad eso y que no os falte un espacio en la linea que os indica o la anterior. Comprobad y tened especial cuidado con las variables, cuando le asignamos un valor NO SE PONE DOLAR.

Recordad que cuando un comando nos muestra varias lineas podemos ir manejando cada una de ellas con el bucle for:

#!/bin/bash

for i in `ls /etc/`; do
  echo $i
done

Recordad que si hacemos lo anterior y las lineas mostradas tienen espacios, debemos camuflarlas con un caracter concreto y luego quitarselo con tr:

#!/bin/bash
for i in `cat /etc/passwd | tr " " "¿" `; do
 echo $i | tr "¿" " "

done

Recordad que cuando ejecutamos un comando, para comprobar si ha ido bien se usa $? (cero bien, uno mal). Cuando no esteis seguros de el valor que os tiene que dar, simplemente os vais a la terminal, ejecutais el comando y a continuación escribís «echo $?» y sabreis el valor que os da ese comando. Por ejemplo:

[[email protected] ~]$ cmp /etc/passwd /etc/passwd

[[email protected] ~]$ echo $?
0
[[email protected] ~]$

Nos devuelve 0, por lo tanto el valor cero significa que los archivos son iguales.

Y por último, recordad el PATH en donde está el script y el PATH donde quereis meter o sacar datos. Si el script está en /home/pepito/script.sh y dentro del script haceis «ls datos/» en realidad estáis haciendo «ls /home/pepito/datos/«. Por el contrario, si haceis «ls /datos/» estais buscando el directorio datos al principio del árbol de directorios (observad la barra invertida).

Como ya he dicho antes, tenéis mas comandos en: http://nachesti.wordpress.com/2009/12/04/manejo-basico-de-la-terminal-en-gnulinux/

Y con esto, se finí. Si me acuerdo de algún comando más, lo pondré. Si alguno de vosotros recuerda algún otro comando basta que lo comparta en los comentarios.

Un saludo, see you tomorrow x)

Consultorio PHP, recogida de preguntas

Como ya no se que más explicar de PHP de lo que se supone que debemos saber para el examen de la primera evaluación, dejo este post para que en los comentarios dejeis las preguntas sobre lo que más duda tengais. Preguntas sobre sintáxis, sobre conceptos o métodos para resolver problemas, lo que os venga en gana preguntar.

De modo que si quereis que explique alguna cosa o profundice en otra, dejad un comentario y lo resolveré.

Consultorio nache a la ecucha x)

Scripting básico sobre Bash y GNU/Linux (1ª Parte)

Saludos pequeños seres navegantes. Aquí una nueva entrada sobre scripting básico sobre GNU/Linux utilizando la shell bash.

Los scripts no son mas que archivos que contienen comandos del sistema operativo e instrucciones que nos brinda la shell sobre la que trabajamos. La shell más utilizada en GNU/Linux es la llamada Bash.

Cuando creamos un script en GNU/Linux utilizando Bash, el sistema operativo nos ofrece la posibilidad de utilizar todos sus comandos dentro de nuestro script (ls, rm, cp, cat) y la shell Bash nos ofrece instruciones como while, if, if else, for, además de permitirnos crear variables para almacenar información.

Por lo tanto, un script para nuestro cometido es una conjunción de comandos GNU/Linux junto con controles de flujo y variables sobre Bash.

Cuando creamos un script, debemos SIEMPRE indicar en la primera línea del archivo el tipo de shell que queremos usar. Para esto, usaremos la almoadilla con exclamación (#!) seguida de la ruta donde se encuentra la shell:

#!/bin/bash

No me vale ponerlo en la segunda linea, si digo que en la primera linea, es en la primera linea. De lo contrario, golpe de remo ¿eh?

Bien, una vez hecho esto, el resto del archivo estará destinado a nuestro script. Lo primero que vamos a hacer es crear una variable con información y luego mostrar el contenido de dicha variable con un echo.

#!/bin/bash
variable="caraculo"
echo $variable

Nótese que las variables en bash se crean sin usar el símbolo $ pero cuando queremos acceder a su contenido, le ponemos un $ delante. Nótese también, que en bash no usamos punto y coma (;) al final de cada instrucción.

El echo en bash funciona de forma similar a como funciona en php. Cuando queremos mostrar una sóla variable, prescindimos de comillas. Cuando queremos mostrar texto y una variable; entonces las usamos:

#!/bin/bash
variable="kkfuti"
echo "la variable contiene $cacafuti"

En php, usabamos puntos para separar texto de variable, en bash prescindiremos de éstos. La tarea se simplifica:

#!/bin/bash
variable="tikitiki"
echo "El contenido " $tikitiki " esta almacenado en variable"

Control de flujos con if

La forma de utilizar if en bash es algo mas engorrosa que en php (o C por consecuencia), pero os voy a enseñar un truquito para poder usar la misma sintáxis. Esto es, los dobles parentesis.

#!/bin/bash
variabletexto="hola"
variablenumero=9
if (( $variabletexto == "hola" ));then
echo "la variabletexto contiene hola"
fi

if (( $variablenumero > 5 ));then
echo "la variablenumero es mayor que 5"
fi

Gracias al truquito if (( condicion ));then podemos usar la sintáxis que aprendímos en php. Recordad que if  se cierra con fi (if al revés) y entre estos se aloja el código que se ejecutará si la condición entre los dobles parentesis es cierta (1).

Para comprobar si un archivo o un directorio existe, hay que modificar el truco de antes y reemplazar los parentesis por un «[» y un «]» (corchetes) y usar las expresiones condicionales:

#!/bin/bash
if [   -f   "/etc/resolv.conf"   ];then
echo "el archivo existe"
fi

if [   -d   "/etc/"   ];then
echo "el directorio existe"
fi

Cuidado con esto: las expresiones contenidas dentro de los corchetes DEBEN estar separadas por espacios de los dichos corchetes. De lo contrario fallará.

Ni que decir tiene que podemos usar el método aprendido en clase ayudados del comando brindado por el sistema operativo; test:

#!/bin/bash
if test -f  "/etc/resolv.conf"
then
echo "el archivo existe"
fi


if test -d  "/etc/"
then
echo "el  archivo existe"
fi

Recordad, -f para archivos (file) y -d para directorios (directory).

Antes de terminar, comentar que bash también permite el uso de if else. (si la condición es cierta ejecuta esto, de lo contrario, ejecuta esto otro). Su uso es muy sencillo:

#!/bin/bash
variable="hola"
if (( $variable == "hola" ));then
     echo "La variable contiene hola, condicion cierta"
else
     echo "La variable NO contiene hola, condicion falsa"
fi

Observad que añadiendo la palabra else entre un código y otro, podemos controlar cual ejecutar dependiendo de si la condición es cierta (1) o falsa (0).

Y hasta aquí la primera entrega de Bash Scripting Básico. Continuará… x)

Manejo básico de la terminal en GNU/Linux

Aqui os dejo algunos comandos Unix/Linux  para no ir olvidandonos de lo básico.

listar el contenido de un directorio:

ls : normalito

ls -l :datos adicionales de los directorios

ls -lh :datos adicionales y legibles para los seres humanos

ls -lha :datos adicionales, legibles y los ocultos

crear un archivo vacío

touch archivo

crear un archivo nuevo con contenido dentro

echo «contenido» >archivo

obtener el contenido de un archivo

cat archivo :obtenemos el contenido enterito

more archivo :lo obtenemos poco  a poco

less archivo :igual que lo anterior

copiar archivos y directorios

cp archivo1 archivo2 :copia normal

cp -rf directorio1 directorio2 :copia forzada y recursiva de directorios

moviendo archivos de lugar

mv /lugar1/archivo1 /lugar2/archivo2

borrar archivos y directorios

rm archivo :borrado normal

rm -f archivo :fuerza el borrado en archivos con protección de escritura

rm -rf directorio :fuerza a borrarse un directorio que no esté vacío

buscar archivos

find /ruta/donde/busca -name «*archivoquebuscas*» : los asteriscos son comodines, indican que antes y después del nombre puede haber cualquier cosa

buscar un texto, palabra o caracter en un archivo

grep «loquesea» archivo :busqueda normal

grep -i «loquesea» archivo :busqueda ignorando mayusculas y minusculas

grep -v «loquesea» archivo :busqueda inversa, muestra todo menos lo que le digamos

comparar archivos

diff archivo1 archivo2

cmp archivo1 archivo2

ver quién está conectado en la máquina

who

w

Conceptos básicos de PHP (5)

Ya estoy de vuelta, esta vez para explicar cómo funcionan los formularios. Trataré de explicarlo de una forma clára.

Cuando creamos una página, lo interesante llega cuando permitimos al usuario interactuar con la página, y mostrar resultado según los valores que dicho usuario introduzca mediante unos campos que permiten escribir. Cuando entramos en google, éste nos brinda un campo de formulario con un espacio para escribir nuestra busqueda y uno o dos botones que envían nuestra petición. Al darle al botón, los valores introducidos se envían a otra página escrita en php que trata estos valores para mostrar un resultado. Vamos a tratar de entender cómo son enviados los valores para su posterior tratado en php.

Primero creamos una archivo HTML, que contenga los campos de formularios que serán enviados a otro archivo en php. Algo básico:

<html>
<head><title>Ejemplillo</title></head>
<body>
<form action="paginaenphp.php" method="post" >
<input type="text" name="valor1" />
<input type="submit" value="Enviar" />

</form>

</body>

</html>

Hemos creado una etiqueta <form>, donde le decimos a que página se enviarán nuestros datos (action=»paginaenphp.php») y donde además le decimos de que forma serán enviados estos datos (method=»post»). Dentro de la etiqueta <form> hemos metido dos «input» o elementos de formularios. El primero es de tipo texto (type=»text») que será una entrada que nos permitirá introducir texto. La segunda es de tipo submit (type=»submit») que será un botón encargado de enviar los datos. Para que al enviar el formulario a nuestro archivo php éste sepa que variables tiene que manejar, debemos darle un nombre a cada elemento del formulario donde introduzcamos algún dato. Php recibirá un array llamado $_POST[] donde cada índice será el nombre que hemos puesto en HTML. Este nombre se especifica con name=»nombreindice».

La forma en que se envían estos datos es similar a la forma en que se establece la conexión entre navegador y servidor web cuando escribimos una dirección. El parámetro action=»lugar» actúa como barra de direcciones, si no le especificamos la dirección completa, asume que el archivo paginaenphp.php está en el mismo sito que el archivo HTML que contiene el formulario. De este modo, podriamos realizar una conexión incluso con un servidor diferente indicandolo en action; action=»http://www.google.com/search». Si hicieramos esto, google recibiría los datos de nuestro formulario pero no sabría que hacer con ellos ya que espera una variable $_POST con nombres de índice concretos y no nuestro $_POST[«valor1″] indicado en el input (name=»valor1») de nuestro HTML.

Por lo tanto, podríamos decir que un formulario actua de forma similar a cuando escribimos una dirección web en la barra de direcciones de nuestro navegador, con la particularidad que a la vez que pide un archivo php, le envía unos valores para que los trate y así obtener un resultado en nuestro navegador en función a los datos enviados. Veamos como sería el archivo paginaenphp.php:

<?php
echo "El dato introducido en el formularo es: " . $_POST["valor1"];
?>

Como vemos, la variable de tipo array llamada $_POST no la hemos definido, ya que no somos nosotros quién la tenemos que definir, ésta se crea automáticamente cuando al pedir un archivo php, se envían a su vez datos de formulario. Para nuestro caso, la forma de enviar estos datos es mediante «post», por lo tanto la variable creada automáticamente se llamará $_POST con nombres de índices iguales a los nombres de nuestros elementos de formulario y con el valor que hemos escrito en dicho elemento. Sigamos con otro ejemplo. Supongamos que creamos un formulario con dos elementos para introducir valores y un botón para enviar dichos valores. Los valores introducidos serán numeros y cuando lo enviemos a php, éste sumará los dos numeros y mostrará el resultado. Bien, al lío; creamos primero el archivo en HTML:

<html>
<head><title>Otro Ejemplillo</title></head>
<body>
<form action="archivophp.php" method="post">
     <input type="text" name="valor1" />
     <input type="text" name="valor2" />
     <input type="submit" value="Enviar" />

</form>

</body>

</html>

Hemos creado un formulario similar al anterior, la diferencia es que hemos añadido otro elemento de texto más. Veamos el archivophp.php:

<?php
$resultado=$_POST["valor1"]+$_POST["valor2"];

echo "El resultado de la suma es: " . $resultado;

?>

Bien, obtenemos automáticamente una variable de tipo array llamada $_POST con índices de nombre igual a nuestros elementos en el formulario; valor1 y valor2. En $resultado almacenamos la suma de $_POST[«valor1»] y de $_POST[«valor2»] para luego mostrarla con echo.

Una aclaración. Como podemos observar el nombre de los índices del array se entrecomillan si son de típo texto, esto crea conflictos con echo cuando no lo usamos correctamente. Esto sería incorrecto:

Mal: echo «El valor1 es: $_POST[«valor1″]»;

Recordemos: echo muestra texto desde el inicio de comillas dobles hasta que encuentra otras comillas dobles, por lo tanto al encontrar las comillas dobles iniciales del índice del array, asume que ha terminado de mostrar texto y espera un punto y coma para terminar. Pero no es lo que encuentra, en cambio encuentra: valor1″]»; Lo cual es incorrecto (error de sintáxis). De modo que para solucionar esto, sacaríamos la variable fuera de las comillas:

Bien: echo «El valor1 es: » . $_POST[«valor1»];

Otra forma de solucionar esto sería sustituir las comillas dobles del índice por comillas simples:

Bien: echo «El valor1 es: $_POST[‘valor1’]»;

Al sustituir comillas dobles por comillas simples, no creamos ningún conflicto en el echo y al encontrar el símbolo $ asume que está ante una variable y la reemplaza por su valor.

All right, expliquemos ahora un concepto extraño. En clase hemos visto como crear un formulario en un archivo html y un archivo php que recibe los datos del formulario. Bueno, a mi particularmente me gusta meter el código php y el html en el mismo archivo. Además es lo que se hace en la vida real habitualmente. Tratemos de entender esto.

Sabemos que al enviar un formulario a un archivo php se crea una variable automáticamente llamada $_POST. Si accedieramos a ese archivo mediante la barra de direcciones de nuestro navegador, esta variable no existiría. Gracias a esta particularidad, en un archivo php podemos reconocer cuando estamos pidiendo el archivo mediante el navegador y cuando han sido enviados los datos. Para hacer este reconocimiento nos ayudaremos de nuestro amigo if else y de una función llamada isset(), a la cual le pasamos una variable como parámetro y nos devuelve un uno (1) si la variable existe y un cero (0) si la variable no existe. ¿Recordais que if esperaba un cero o un uno para ejecutar o no una porción de código? Veamos esto con un ejemplo:

<html>
<head><title>HTML y PHP todo juntito</head>
<body>
<form action="" method="post">
     <input type="text" name="valor1" />
     <input type="submit" value="Enviar" />

</form>
<?php
if( isset($_POST) ){
     echo "El formulario ha sido enviado y valor1 contiene: " . $_POST["valor1"];

}else{
     echo "Aun no se han enviado datos mediante formulario";

}

?>

</body>

</html>

Observemos, isset($_POST) comprueba si el array existe. Si existe (1) significa que hemos enviado el formulario por lo que pasamos a mostrar el valor de los datos enviados. Si no existe este array (0), significa que no hemos enviado los datos mediante formulario y muestra la porción de codigo dentro de else. Curioso ¿eh? Para indicar que queremos enviar los datos al mismo archivo, podemos poner en action el nombre del archivo o simplemente dejar este campo vacío action=»».

Para terminar, os dejo un pequeño juguetito. Hemos visto como enviar datos a un php mediante POST. Existe otro método de enviar datos a un php llamado GET. Este método añade a la dirección url escrita en nuestro navegador el nombre de un índice y su valor. La forma de hacerla sería esta: http://www.nasa.com/archivo.php?nombreindice=pepe&nombredeotroindice=perico. Analicemos esto, hemos enviado al archivo.php de la nasa un índice de variable array llamado nombreindice con valor pepe y otro índice llamado nombredeotroindice con valor perico. Observemos un enlace a un vídeo en youtube:

http://www.youtube.com/watch.php?v=rCLYx3nomao

En este enlace, estamos enviando un índice llamado v con valor rCLYx3nomao al archivo llamado watch.php. Bien, notad que tenemos el poder de darle a esta variable el valor que nos venga en gana. Y digo más, si cualquier persona puede dar una valor cualquiera a una variable dentro de un código php, ¿no sería ésto peligroso?, … pues sería, sería.

x)

Conceptos básicos de PHP (4)


Bien bien, antes de pasar a los formularios, en este artículo se van a explicar el bucle while y los arrays.

Los whiles son tambien controladores de flujo, concretamente repiten una porción de código tantas veces como nosotros le digamos. A medida que repite esta porción de código, las variables pueden ir cambiando de valor para ir mostrando resultados diferentes en cada repetición.

La sintáxis de while es idéntica a la sintáxis de if, con la particularidad de que cundo entre en la porción de código, la repetirá tantas veces como le digamos. ¿Y como se lo decimos?, pues igual que se lo decimos a if, con una condición. Esta condición se comprobará cada vez que se repita la porción de código. Por lo tanto, cuando la condición deje de ser cierta, dejará de repetir esta porción de código y seguirá examinando el resto del archivo. Veamos algunos ejemplos:

<?php
$variabledecontrol=0;
while($variabledecontrol != 20){

     $variabledecontrol++;
     echo $variabledecontrol;

}
?>

Leamos este código, que siempre viene bien para no liarnos, sobre todo con el while:

1) Mientras que $variabledecontrol no sea igual a 20, haz esto:

2) Incrementa $variabledecontrol en uno

3) Muestra el contenido actual de $variabledecontrol

Bien, es cierto que $variabledecontrol no es igual a 20, por que si lo fuera, no ejecutaría esa porción de código. Y esto es lo que ocurre cuando $variabledecontrol llega a 20 ya que va cambiando de valor en cada repetición. La primera vez que entramos en la porción de código, incrementamos su valor añadiendo ++ a su nombre, por lo que $variabledecontrol vale 1. La segunda vez, antes de entrar otra vez en la porción de código, $variabledecontrol, que vale 1, no será igual a 20 (condición cierta), por lo que seguirá repitiendo la porción de código. Esta segunda vez, volvemos a incrementar $variabledecontrol, que pasará a tener esta vez un valor de 2. Esto se repetirá una y otra vez hasta llegar a 20, donde la condición será falsa, ya que $variabledecontrol si que vale 20, por lo tanto, el interprete de php se olvida del while y sigue su camino.

Cuando carguemos la página y el php se ejecute, en nuestro navegador obtendremos algo tal que así:

1234567891011121314151617181920

El echo va ejecutando religiosamente lo que nosotros le hemos dicho, mostrar por pantalla el valor de $variabledecontrol, pero nos pone los numeritos juntos. La razón de esto es que lo único que mostramos es el número, no mostramos ningún espacio ni ningún salto de linea. Vamos a modificar el código anterior para que el resultado obtenido sea mas claro:

<?php
$variabledecontrol=0;
while($variabledecontrol != 20){
     $variabledecontrol++;
     echo $variabledecontrol . " - ";
}
?>

Hemos añadido en el echo un texto después de la variable usando un punto para separar variable de texto. Ya vimos con anterioridad las diferentes formas de uscar echo, así que esto queda al gusto del consumidor. El resultado obtenido en el navegador sería este:

1 – 2 – 3 – 4 – 5 – 6 – 7 – 8 – 9 – 10 – 11 – 12 – 13 – 14 – 15 – 16 – 17 – 18 – 19 – 20 –

En HTML para poner un salto de linea no basta con darle al enter, el navegador básicamente se lo pasa por el forro. Si queremos mostrar un salto de línea, debemos usar la etiqueta <br> o <br />. Ambas valen para el caso que nos ocupa. por lo tanto, el echo quedaría así:

echo $variabledecontrol . » <br />»;

El resultado en código HTML sería este:

1<br /> 2 <br /> 3 <br /> 4 <br /> 5 <br /> 6 <br /> 7 <br /> 8 <br /> 9 <br /> 10 <br /> 11 <br /> 12 <br /> 13 <br /> 14 <br /> 15 <br /> 16 <br /> 17 <br /> 18 <br /> 19 <br /> 20 <br />

Nuestro navegador interpretaría este código HTML y nos mostraría cada numero en una linea diferente.

Arrays

Pasemos ahora a los arrays. Los arrays no son mas que -a groso modo- un conjunto de variables con el mismo nombre diferenciadas por un índice. Podemos añadir y quitar tantos valores como queramos en un array. Existen muchas formas de dar valores a los arrays, me centraré sólo en unos pocos.

La sintáxis de los arrays se caracteriza por $nombrevariable[índice]. De este modo, podemos tener dos valores en una misma variable con un índice diferente:

<?php
$variable[0]="soy un texto en un array en el índice 0";
$variable[1]="soy un texto duiferente en un array en el índice 1";

echo $variable[0];
echo $variable[1];

?>

Hemos almacenado dos textos diferentes dentro de una misma variable, pero cada uno tiene su propio índice (cero y uno), por lo tanto podemos acceder a cada valor independientemente indicando ese índice.

Cuando no conocemos la cantidad de índices ni el valor de cada índice, podemos usar un bucle como while (existen formas específicas para recorrer arrays como foreach() pero no lo vamos a tratar). La forma de recorrer un array con un while, sería la siguiente:

<?php
$variable[1]="una cosa";
$variable[2]="otra cosa";
$variable[3]="mas cosas";
$variable[4]="conchinchina";
$variable[5]="pelicano";
$variable[6]="sarpullido";
$variable[7]="perico";
$variable[8]="cacafuti";
$variable[9]="guebin";
$variable[10]="zaratrusta";
$variabledecontrol="0";
while($variabledecontrol != 10){
     $variabledecontrol++;

     echo $variable[$variabledecontrol];

}
?>

Esto nos mostraría el contenido de cada índice gracias al bucle y la $variabledecontrol incrementada. En cada repetición del bucle, $variabledecontrol tiene un valor diferente, (1, 2, 3, 4…) por lo tanto, al meterla dentro de los corchetes del array, le estamos pidiendo el índice con valor igual al de la $variabledecontrol. Por lo tanto, cuando $variabledecontrol valga 5, estamos pidiendole $variable[5].

Vamos a complicar un poco esto, supongamos que tenemos el código anterior, no sabemos en que índice está el texto «pelicano» y queremos encontrarlo. Pues al lío:

<?php
$variable[1]="una cosa";
$variable[2]="otra  cosa";
$variable[3]="mas cosas";
$variable[4]="conchinchina";
$variable[5]="pelicano";
$variable[6]="sarpullido";
$variable[7]="perico";
$variable[8]="cacafuti";
$variable[9]="guebin";
$variable[10]="zaratrusta";
$variabledecontrol="0";
while($variabledecontrol  != 10){
     $variabledecontrol++;
     if ( $variable[$variabledecontrol] == "pelicano"){
          echo "pelicano se encuentra en el índice: " . $variabledecontrol;

     }
}
?>

Como ya se ha dicho, gracias a la $variabledecontrol vamos obteniendo los diferentes valores que tiene el array, cuando encontramos el valor que queremos, con la ayuda de nuestro querido if, mostramos el valor de $variabledecontrol que vale igual que el índice en el momento de encontrar nuestro valor.

Otra particularidad de los arrays es que sus indices pueden ser tanto numéricos como alfanuméricos. Cuando trabajamos con formularios, los índices de los arrays habitualmente son alfanuméricos (texto o texto y numeros). Por lo que recorrer un array con índice alfanumérico se complica. Aquií es donde entra foreach(), pero como ya se ha dicho, no lo vamos a tratar. Para definir un índice con texto, se hace entre comillas, recordad, el texto va entrecomillado. Por lo tanto:

$variable[«valor1″]=»perico»;

$variable[«valor3″]=»joselico»;

$variable[«cualquiercosa»]=9;

Como utilidad y para terminar, cuando un array nos toque las narices, podemos ver el contenido completo de un array con sus indices y sus valores gracias a una función llamada print_r():

<?php
$variable["valor1"]="perico";
$variable["valor3"]="joselico";
$variable["cualquiercosa"]=9;

print_r($variable);

?>

La función print_r() ella sola es capaz de mostrar por pantalla texto, por lo tanto no necesitamos el echo. El resultado sería algo así:

Array

(

[valor1] => perico

[valor3] => joselico

[cualquiercosa] => 9

)

Y con esto, se finí. En el próximo artículo: formularios. Talué! x)

Conceptos básicos de PHP (3)


Siguiendo con el hilo de esta serie de artículos, vamos a explicar que son los controles de flujo.

Cuando creamos un código PHP, el interprete del servidor encargado de examinarlo y ejecutarlo, lee linea por linea en busca de nuestras instrucciones. Cuando encuentra una variable en una linea, memoriza esta variable con su valor y lee la siguiente linea. Si en la segunda linea encuentra un echo, muestra por pantalla el contenido del echo; si en la tercera encuentra un «echo $variable», recuerda el contenido de esa variable y la muestra, etc etc…

Lo interesante llega cuando queremos controlar esto, quizás nos interese que el interprete lea una linea u otra según una condición, o que repita una linea tantas veces como le digamos. Es aqui cuando llega el control de flujos brindandonos el poder de controlar lo que hace el interprete.

Controlando que linea se muestra

Una forma de controlar que linea se muestra, es con if y con if else. Supongamos que queremos mostrar el contenido de una variable si ésta contiene la palabra «cacafuti»:

<?php
$variable="cacafuti";

if ($variable == "cacafuti" )
{     
     echo "la variable contiene $cacafuti";
}
?>

Podemos observar que la variable llamada «variable» contiene el texto o cadena de caracteres «cacafuti». El if hace una comprobación: si $variable es igual a «cacafuti» entonces… echo «la variable contiene $cacafuti». Bien, centremonos en la condición o comprobación de si es cierto o no:

if($variable == «cacafuti»)

Cuando metemos una condición dentro de los parentesis del if(), esta comprobación envía un uno o un cero; uno es cierto, cero es falso. Por lo tanto, si $variable es igual a «cacafuti» esto se convertirá en un uno, ya que es cierto. Si nosotros metieramos un uno a secas entre esos parentesis reservados para una condición, el contenido del if se leería siempre:

<?php
if(1){     
     echo "Soy un texto dentro de un if que siempre es cierto (o uno)";
}
?>

De lo contrario, si metieramos un cero, la condición nunca sería cierta:

<?php
if(0){   
  echo "Este texto nunca será mostrado";
}
?>

¿Por qué explico esto? Para entender que lo que el if() espera es un uno (verdadero) o cero (falso) ya sea una condición con ==  (igual que), != (no igual que) o cualquier otra cosa que su resultado sea uno o cero. Por lo tanto, esto también sería correcto:

<?php
$variableA=1;
$variableB=0;
if($variableA){
   echo "Este texto será mostrado ya que variableA es uno";
}if($variableB){
   echo "este texto nunca en la vida será mostrado";
}
?>

Observese que $variableA vale o contiene un uno y $variableB vale o contiene un cero. Teniendo esto claro, podemos meter la variable a pelo dentro del if, sin condición ni nada, ya que como se ha dicho, el if espera un cero o un uno; le importa tres pepinos como lo obtenga, pero eso es lo que espera.

Pasemos ahora al if else. Cuando queremos mostrar una cosa u otra según una condición, utilizamos if else. De este modo controlamos que se muestra en función, por ejemplo, del valor que tenga una variable:

<?php
$variable="popurri";
if($variable == "popurri"){
     echo "La variable contiene la palabra popurri";
}else{
     echo "La variable no contiene popurri";}
?>

Leamos este código…

1) $variable es igual a «popurri»

2) Si $variable es igual a «popurri» entonces…

3) mostramos «La variable contiene la palabra popurri»

4) de lo contrario…

5) mostramos «La variable no contiene popurri»;

Hay que acordarse de la sintáxis del if, es decir, de como se escribe: if(condicion){codigo si la condición es cierta}. Entre parentesis la condicion y entre corchetes el código si es cierta la condición. Por lo tanto, el if al ser un controlador de flujos, no lleva punto y coma en ningún sitio, pero el código que contiene, si lo lleva; sólo lo que hay entre corchetes. Pasemos ahora a las funciones.

Funciones o metodos

Por ahora no vamos a crear funciones, vamos a trabajar con las funciones que ya vienen de fábrica en php, pero para entender cómo funciona una función, vamos a ver el código de una. La función es aquello que nos permite realizar acciones dandole un valor a ésta para que lo manipule y nos devuelva el resultado de esa manipulación. En clase hemos visto tan() arctan() y alguna mas. El echo no es una función, pero la podemos tratar como tal para no liarnos. Las funciones no son otra cosa que una porción de codigo ya hecho, el cual podemos ejecutar llamando a la función que necesitemos. Veamos una función simple para entender como funciona:

<?php
function suma($numero){
     $resultado=$numero+5;
     return $resultado;
}
?>

Bien, poco a poco… Hemos dicho que las funciones reciben un valor, lo manipulan y devuelven el resultado. La sintáxis de las funciones son iguales que el if, pero en el parentesis no se meten condiciones, en cambio se meten variables que almacenarán los parametros que nosotros le pasemos. En concreto, esta funcion suma un cinco a la variable $numero, que contendrá el valor que nosotros le pasemos, lo almacena en $resultado y nos devuelve dicho resultado. Por lo tanto, las funciones se usan así:

<?php
$valorsumado=suma(9);
?>

Observemos que 9 es el valor que le pasamos a la función para que lo manipule. Hará con este valor lo que tenga que hacer y devuelve el resultado. En concreto, la variable $valorsumado valdrá 14. Nótese que el 9 no tiene comillas, esto es por que los numeros pueden ir entrecomillados, pero no deben para evitar algunos problemas mas complejos que no voy a tratar. Sólo recordarlo: los numeros que usemos para cálculos, sin comillas.

Observar también que estamos igualando $valorsumado con suma(9) y como es lógico, un igual es un igual, por lo tanto $valorsumado y suma(9) valen lo mismo. De modo que esto sería correcto:

<?php
echo suma(9);
?>

Le decimos a echo que muestre el valor de suma(9), y el valor de suma(9) será el resultado del cálculo que hace la función. A groso modo, las funciones pueden ser tratadas como variables con la particularidad de que su valor será el resultado de una manipulación interna de la función. Y ya que esto es así, vamos a demostrarlo:

<?php
$numerico=14;
if(suma(9) == $numerico){
     echo "La variable es igual a la suma de 9 mas 5";
}
?>

Aqui hemos tratado a la función como una variable, y su valor es 14 -igual que $numerico- Por lo tanto, la condición es cierta y pasa a mostrar el echo. Ni que decir tiene que el valor que nosotros le pasamos a la función, puede ser también una variable:

<?php
$numerico=14;
if(suma($numerico) == $numerico){
     echo "La condición es cierta";
}else{
     echo "La condición es falsa";
}
?>

Bien, a suma() le pasamos el valor de $numerico, por lo que suma() vale 19 (14+5=19) y no es igual a $numerico, ya que este vale 14 por lo tanto la condición es falsa.

En PHP existen miles de funciones ya creadas y listas para usarlas nosotros, las cuales aceptan no sólo uno, sino varios parametros. Algunas hacen calculos complejos, otras buscan una palabra en un texto, otras hacen comprobaciones, y así hasta un sinfín de posibilidades. Para saber usar cualquier función, nos basta con saber que parametros debemos darle, y que resultado nos va a devolver. Nos da completamente igual lo que haga por dentro, sabiendo eso y sabiendo como manejar las funciones en nuestro código, es suficiente.

Por último y para terminar, decir que podemos mostrar la funcion usandola como variable con un echo junto con más texto, pero esto se debe hacer con un punto a cada lado:

Bien: echo «Mi periquito me costó » . suma(14) . «centimos»;

Mal: echo «Tu periquito no vale ni suma(14) centimos»;

¿Por que? Por que el echo interpreta suma(14) como un texto normalito, total, son parentesis y un numero. Por esto hay que sacar la función fuera de las comillas, para que lo interprete como una función.

Y se finí. Para los próximos capítulos, bucles y formularios. A pasarlo bien x)