Spanish (Español) translation by honeymmmm (you can also view the original English article)
En las últimas semanas, NETTUTS ha publicado bastantes excelentes tutoriales sobre cómo comenzar a usar PHP y MySQL para crear aplicaciones web simples, como un buzón de mensajes. Hoy vamos a llevar nuestro conocimiento de PHP y MySQL un paso más allá al crear un blog simple. Si bien hay innumerables plataformas de blogs gratuitas excelentes, el propósito de este tutorial no es hacer un "mejor" blog, sino usar el proceso de hacer un blog para aprender sobre técnicas avanzadas de estructura de bases de datos y cómo usar los datos de manera más eficiente utilizando objetos en PHP
Para este tutorial, se asume que tienes algunos conocimientos básicos de PHP, MySQL, XHTML y más adelante en jQuery / JavaScript.
Parte 1) Creando nuestra base de datos
Antes de pasar a nuestro cliente MySQL y comenzar a crear nuestras tablas, debemos establecer lo que queremos en nuestro blog. Lo obvio que debemos mantener son las publicaciones de blog, y en cada publicación debe contener un título, la publicación, un autor y la fecha en que se publicó.
Ahora solo podríamos hacer una tabla para guardar esa información y lo más probable es que logremos crear un blog básico, pero con una sola tabla no tendremos tanto control sobre nuestros datos. Por ejemplo, podríamos simplemente almacenar el nombre del autor en la misma tabla que la publicación del blog, pero ¿y si también queremos almacenar el correo electrónico del autor? ¡Por supuesto! Solo agregamos otro campo a nuestra mesa sería la solución obvia.
El problema surge cuando en el futuro desea cambiar la dirección de correo electrónico de ese autor. Ahora tienes que cambiarlo para cada publicación de blog que haya creado esa persona.
Entonces, lo que vamos a hacer es crear una tabla separada llamada "Personas" y en esto, almacenaremos toda la información que necesitamos del autor, como correos electrónicos, URL, su nombre y una ID única. Luego, en la tabla de publicaciones de nuestro blog, señalaremos a la persona que deseamos usar la ID única de esa persona. Esta identificación se conoce como clave externa y la relación entre la tabla de publicaciones del blog y la tabla de personas se denomina relación de uno a varios.
Otra cosa que queremos tener en nuestro blog es una etiqueta para cada publicación de blog. Una vez más, queremos que nuestra base de datos sea eficiente, por lo que crearemos una tabla separada para nuestras etiquetas. ¿Ahora que hacemos? ¿Debemos crear un campo en la tabla de publicaciones del blog que sea una clave externa para nuestra etiqueta? El problema con el uso de una relación uno a uno esta vez es que a veces las publicaciones de blog tienen más de una etiqueta; así que de nuevo, usaremos una relación de uno a muchos. Para hacer esto, necesitamos crear otra tabla que se llamará algo así como "blog_post_tags" que contendrá dos claves externas, una será la ID de la publicación del blog y la otra será la ID de etiqueta con la que está asociada la publicación del blog. De esta manera podemos asignar tantas etiquetas como queramos a una publicación de blog, pero aún podemos editar la información sobre esa etiqueta específica en todas las publicaciones con una simple consulta MySQL.
Ahora que hemos descrito cómo queremos que se vea nuestra base de datos, vamos a crearla. Usaré PhpMyAdmin ya que es el cliente de administración de MySQL más utilizado. Hay algunas convenciones de nomenclatura diferentes que puede usar al crear su base de datos, tabla y nombres de campo. Personalmente, me gusta usar todo en minúsculas y guiones bajos en lugar de espacios.
Nota: Si no tiene PHP y MySQL en su sistema o un servidor que pueda ejecutarlo, le recomiendo que descargue una instalación independiente de Apache, PHP y MySQL. MAMP es bueno para Mac y WAMP es bueno para PC.
Primero necesitamos crear nuestra base de datos, la llamaré "nettuts_blog".
A continuación, crearemos nuestras tablas; El primero será "blog_posts".
"blog_posts" tendrá cinco campos: "id", "title", "post", "author_id" y "date_posted". Para "id" vamos a convertirla en la clave principal y establecerla en auto-incremento. Lo que esto hará es generar nuestra identificación única para nosotros. Cada vez que agreguemos una publicación, le daremos un número que comenzará en uno y avanzará por tantas publicaciones como tengamos.
Ahora también necesitamos establecer el tipo de variable para cada campo. El ID se configurará para escribir int, corto para entero, ya que solo puede ser un número y estableceremos la longitud máxima en 11. El campo "título" se configurará para escribir varchar con una longitud máxima de 255. El campo "publicación" será tipo "texto" y no estableceremos una longitud máxima ya que las publicaciones pueden ser muy largas. "author_id" será lo mismo que "id", pero no lo estableceremos como nuestra clave principal ni lo tendremos en incremento automático, y estableceremos "date_posted" para escribir "Date".
Nuestra próxima mesa será "gente". No lo llamamos "autores" porque en el futuro podríamos crear la posibilidad de registrar y publicar comentarios, y esas personas no serían consideradas autores.
"personas" contendrá cinco campos también: "id", "first_name", "last_name", "url" y "email".
"id" se establecerá como un int, la clave principal y para el incremento automático, de la misma manera que configuramos la id de "blog_posts". "first_name", "last_name", "url" y "email" se configurarán para escribir varchar con una longitud máxima de 255
Nuestra siguiente tabla será "etiquetas" y por ahora solo contendrá dos campos: "id" y "nombre". En el futuro, podríamos hacer esto más complejo agregando una descripción, pero para este tutorial no lo haremos. Como lo hicimos antes, "id" se establecerá como int, la clave principal y el incremento automático. "nombre" será de tipo varchar y tendrá una longitud máxima de 255.
Y nuestra última tabla, "blog_post_tags", tendrá solo dos campos: "blog_post_id" y "tag_id". Ambos se configurarán para escribir int con una longitud máxima de 11. Como probablemente notó, no establecimos una clave principal para esta tabla. Esto se debe a que nunca obtendremos datos de esta tabla a menos que solicitemos una publicación de blog específica o todas las publicaciones de una identificación de etiqueta específica.
Parte 2) Creando nuestros objetos en PHP
Antes de comenzar con nuestro código PHP real, necesitamos crear nuestros archivos y carpetas, para este tutorial tendremos nuestro index.php en nuestra carpeta raíz y luego una carpeta de inclusión que contendrá nuestra hoja de estilos CSS, nuestros archivos JavaScript, includes.php que mantendrá referencias a nuestros objetos y a la conexión de MySQL, y blogpost.php que contendrá nuestro objeto BlogPost.
Ahora que tenemos nuestra base de datos establecida, necesitamos crear los objetos en PHP que manejarán los datos por nosotros. Los objetos en la programación son una forma de reunir diferentes atributos (como variables) y métodos que se relacionan con la misma cosa. Los objetos también nos ayudan a organizar nuestros programas mucho más. Antes de saltar a nuestros objetos para nuestro blog, solo creamos un objeto simple para poder ilustrar lo que son en un término más de "vida real".
Nuestro objeto se llamará "Bicicleta", ahora hay dos tipos de cosas que cada objeto tiene, propiedades y métodos. Las propiedades definen el objeto y los métodos son lo que hace el objeto. Por ejemplo, nuestro objeto Bike tendría propiedades como el tamaño de la rueda, el número de engranajes y quizás el tamaño del cuadro. Para los métodos podríamos tener algo como "Pedal".
Ahora para volver a nuestro blog, solo necesitamos un objeto por ahora llamado "BlogPost". BlogPost tendrá seis propiedades, ID, título, publicación, autor, etiquetas y fecha de publicación. Así que vamos a hacerlo en PHP.
Para definir un objeto en PHP lo definimos como una "clase". Una clase es la estructura de cada objeto, o como wikipedia lo describe, "En la programación orientada a objetos, una clase es una construcción de lenguaje de programación que se utiliza como modelo para crear objetos. Este plano incluye atributos y métodos que todos los objetos creados comparten ". (http://en.wikipedia.org/wiki/Concrete_class). Vamos a abrir nuestra página blogpost.php y definir nuestro primer objeto.
Nota: En cada sección del tutorial, voy a dejar de lado las etiquetas PHP de apertura y cierre; "" deberá incluirlos al principio y al final de su documento.
1 |
class BlogPost |
2 |
{
|
3 |
} |
En nuestra clase necesitamos definir primero nuestras propiedades. Para hacer esto, tenemos que crear variables, pero con "público" delante de ellas. Solo una nota rápida, si está usando PHP4, entonces necesitará usar "var" en lugar de "público".
1 |
class BlogPost |
2 |
{
|
3 |
public $id; |
4 |
public $title; |
5 |
public $post; |
6 |
public $author; |
7 |
public $tags; |
8 |
public $datePosted; |
9 |
}
|
Ahora que tenemos todas nuestras propiedades definidas, queremos definir nuestro primer método. Los métodos también se describen como funciones, pero la principal diferencia es que un método es una función dentro de un objeto. Entonces, todos los métodos son también funciones, pero no todas las funciones son métodos.
Nuestro primer método será lo que se llama un constructor; este método se llama automáticamente cada vez que creamos una nueva instancia del objeto BlogPost.
El uso común de un constructor es para que pueda crear un nuevo objeto y establecer las propiedades de ese objeto rápidamente.
Entonces, lo que queremos hacer es crear una nueva función llamada __construct () y pasaremos cinco valores, id, título, publicación, id de autor y fecha de publicación. Para cada nombre de variable vamos a poner "en" antes de la palabra para que podamos decir dentro de nuestras funciones qué variables se están pasando y qué variables ya están presentes.
1 |
class BlogPost |
2 |
{
|
3 |
public $id; |
4 |
public $title; |
5 |
public $post; |
6 |
public $author; |
7 |
public $tags; |
8 |
public $datePosted; |
9 |
|
10 |
function __construct($inId, $inTitle, $inPost, $inAuthorId, $inDatePosted) |
11 |
{
|
12 |
|
13 |
}
|
14 |
}
|
El problema aquí es que, con este código actual, cada vez que creamos una nueva instancia de BlogPost necesitamos proporcionar todas esas propiedades. Pero, ¿qué pasa si queremos hacer una nueva publicación de blog y todavía no hemos definido esas variables? Para manejar esto, necesitamos "sobrecargar" los argumentos de nuestra función, de modo que si llamamos a la función y no pasamos uno de los argumentos, se configurará automáticamente al valor predeterminado.
1 |
function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null) |
2 |
{
|
3 |
}
|
Como puede ver, todo lo que hacemos para cumplir con nuestra tarea es establecer cada argumento en el valor "nulo". Ahora dentro de nuestro constructor, necesitamos establecer cada una de nuestras variables a nuestros valores pasados. Para hacer esto, queremos establecerlos en el objeto en el que estamos ahora; Podemos hacer esto con la palabra clave "this". A diferencia de muchos otros idiomas para acceder a una propiedad en PHP, usa "->" en la mayoría de los idiomas (I.E. JavaScript, ASP.NET) utiliza ".".
1 |
function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null) |
2 |
{
|
3 |
$this->id = $inId; |
4 |
$this->title = $inTitle; |
5 |
$this->post = $inPost; |
6 |
}
|
Esto funciona para ID, título y publicación. Pero ¿qué pasa con nuestros otros? Para la fecha vamos a necesitar reformatear los datos que obtuvimos de MySQL para que sean más legibles. Eso se logra fácilmente; Simplemente lo explotamos (también conocido como división en otros lenguajes de programación) y luego lo volvemos a armar. MySQL nos lo da en este formato yyyy-mm-dd, por lo que si lo explotamos usando "-" como nuestro separador obtendremos una matriz con tres valores. La primera tendrá nuestro año, la próxima será nuestro mes y el último será el día. Ahora todo lo que hacemos es volver a armarlos en el formato que queramos. Voy con mm / dd / aaaa.
1 |
$splitDate = explode("-", $inDatePosted); |
2 |
$this->datePosted = $splitDate[1] . "/" . $splitDate[2] . "/" . $splitDate[0]; |
Para el autor, todo lo que tenemos que hacer es solicitar a la base de datos la persona con el ID de nuestro ID de autor. Podemos hacer esto con una consulta básica de MySQL.
1 |
$query = mysql_query("SELECT first_name, last_name FROM People WHERE id = " . $inAuthorId); |
2 |
$row = mysql_fetch_assoc($query); |
3 |
$this->author = $row["first_name"] . " " . $row["last_name"]; |
Unirse a la izquierda
Ahora las etiquetas serán un poco más difíciles. Vamos a necesitar hablar con la base de datos, por lo que necesitamos crear una consulta de MySQL. No nos preocuparemos por la conexión de la base de datos en este momento, que se definirá fuera de esta clase. Ahora todo lo que tenemos es el ID del post del blog. Podemos comparar eso con las etiquetas de las entradas de blog en nuestra tabla blog_post_tags pero luego solo recuperaremos el ID de la etiqueta y necesitaremos hacer otra consulta para obtener la información sobre la etiqueta. Eso no es bueno; Queremos ser eficientes, así que hagámoslo en una sola consulta.
Para hacer esto, vamos a hacer lo que se llama una unión izquierda, esto significa que también vamos a seleccionar datos de otra tabla, pero solo cuando coincidan con los datos de la "izquierda" o nuestros otros datos seleccionados. Entonces, primero obtengamos todas las ID de etiqueta asociadas con la ID de la publicación de nuestro blog en la tabla blog_post_tags.
1 |
$query = mysql_query("SELECT * FROM blog_post_tags WHERE blog_post_tags.blog_post_id = " . $inId); |
Ahora agreguemos nuestra unión izquierda y digamos a nuestra consulta que solo queremos los datos en la tabla de etiquetas:
1 |
$query = mysql_query("SELECT tags.* FROM blog_post_tags LEFT JOIN (tags) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id = " . $inId); |
Así que ahora la consulta está seleccionando todas las etiquetas y tablas blog_posts_tags donde, primero blog_post_tags.blog_post_id es igual a la que proporcionamos y luego también devuelve la información sobre cada etiqueta que tiene esa etiqueta que está en la misma fila de datos que nuestro blog_post_id.
Ahora queremos procesar esos datos en PHP con un simple bucle while. También crearemos dos matrices que contendrán nuestros datos: uno para el nombre de la etiqueta y el otro para la identificación de la etiqueta. También haremos una cadena para mantener todas nuestras etiquetas. Primero lo estableceremos en "Sin etiquetas", de modo que si no devolvemos datos de nuestra consulta de MySQL, devolverá que no tenemos etiquetas, de lo contrario ese valor se sobrescribirá con los nombres de las etiquetas.
1 |
$postTags = "No Tags"; |
2 |
$tagArray = array(); |
3 |
$tagIDArray = array(); |
4 |
while($row = mysql_fetch_assoc($query) |
5 |
{
|
6 |
array_push($tagArray, $row["name"]); |
7 |
array_push($tagIDArray, $row["id"]); |
8 |
}
|
Ahora verificaremos si la matriz tiene una longitud mayor que cero (no queremos realizar todo este código adicional si no es necesario). A continuación, para cada etiqueta en nuestra matriz de nombre de etiqueta, vamos a concatenar una cadena de etiquetas. Usaremos una declaración simple en caso contrario.
1 |
if (sizeof($tagArray) > 0) |
2 |
{
|
3 |
foreach ($tagArray as $tag) |
4 |
{
|
5 |
if ($postTags == "No Tags") |
6 |
{
|
7 |
$postTags = $tag; |
8 |
}
|
9 |
else
|
10 |
{
|
11 |
$postTags = $postTags . ", " . $tag; |
12 |
}
|
13 |
}
|
14 |
}
|
15 |
$this->tags = $postTags; |
Lo más probable es que haya notado que no usamos las matrices de identificación de etiquetas Vamos a dejarlos solos por ahora y regresaremos a ellos más tarde. Solo queremos que nuestro blog esté en funcionamiento primero.
El último paso para nuestra clase es agregar sentencias if para cada propiedad para que si no pasamos nada, no intentará establecer la propiedad del objeto actual en nada (esto causará un error). Aquí está la clase completa de BlogPost con las declaraciones if agregadas:
1 |
<?php
|
2 |
|
3 |
class BlogPost |
4 |
{
|
5 |
|
6 |
public $id; |
7 |
public $title; |
8 |
public $post; |
9 |
public $author; |
10 |
public $tags; |
11 |
public $datePosted; |
12 |
|
13 |
function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null) |
14 |
{
|
15 |
if (!empty($inId)) |
16 |
{
|
17 |
$this->id = $inId; |
18 |
}
|
19 |
if (!empty($inTitle)) |
20 |
{
|
21 |
$this->title = $inTitle; |
22 |
}
|
23 |
if (!empty($inPost)) |
24 |
{
|
25 |
$this->post = $inPost; |
26 |
}
|
27 |
|
28 |
if (!empty($inDatePosted)) |
29 |
{
|
30 |
$splitDate = explode("-", $inDatePosted); |
31 |
$this->datePosted = $splitDate[1] . "/" . $splitDate[2] . "/" . $splitDate[0]; |
32 |
}
|
33 |
|
34 |
if (!empty($inAuthorId)) |
35 |
{
|
36 |
$query = mysql_query("SELECT first_name, last_name FROM people WHERE id = " . $inAuthorId); |
37 |
$row = mysql_fetch_assoc($query); |
38 |
$this->author = $row["first_name"] . " " . $row["last_name"]; |
39 |
}
|
40 |
|
41 |
$postTags = "No Tags"; |
42 |
if (!empty($inId)) |
43 |
{
|
44 |
$query = mysql_query("SELECT tags.* FROM blog_post_tags LEFT JOIN (tags) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id = " . $inId); |
45 |
$tagArray = array(); |
46 |
$tagIDArray = array(); |
47 |
while($row = mysql_fetch_assoc($query)) |
48 |
{
|
49 |
array_push($tagArray, $row["name"]); |
50 |
array_push($tagIDArray, $row["id"]); |
51 |
}
|
52 |
if (sizeof($tagArray) > 0) |
53 |
{
|
54 |
foreach ($tagArray as $tag) |
55 |
{
|
56 |
if ($postTags == "No Tags") |
57 |
{
|
58 |
$postTags = $tag; |
59 |
}
|
60 |
else
|
61 |
{
|
62 |
$postTags = $postTags . ", " . $tag; |
63 |
}
|
64 |
}
|
65 |
}
|
66 |
}
|
67 |
$this->tags = $postTags; |
68 |
}
|
69 |
|
70 |
}
|
71 |
|
72 |
?>
|
Ahora que nuestra clase de objetos está completa, ¡la mayoría de las cosas difíciles están listas! ¡Ahora todo lo que tenemos que hacer es configurar nuestra conexión de base de datos y el HTML para mostrar nuestras publicaciones!
Parte 3) Obtención de los datos de MySQL y visualización con PHP
Antes de hacer cualquier cosa, necesitamos configurar nuestro archivo includes.php para mantener una referencia a nuestro objeto BlogPost y conectarnos a nuestra base de datos MySQL. Primero vamos a incluir nuestro objeto con una simple declaración de inclusión:
1 |
include 'blogpost.php'; |
Ahora vamos a agregar nuestra conexión de base de datos:
1 |
$connection = mysql_connect("localhost", "username", "password") or die ("<p class='error'>Sorry, we were unable to connect to the database server.</p>"); |
2 |
$database = "nettuts_blog"; |
3 |
mysql_select_db($database, $connection) or die ("<p class='error'>Sorry, we were unable to connect to the database.</p>"); |
A continuación, necesitamos recuperar nuestras publicaciones de blog de la base de datos. Para hacer esto, vamos a hacer una función que puede tomar hasta dos argumentos. Los sobrecargaremos a ambos; para que pueda llamar a la función con 0, 1 o 2 argumentos.
1 |
function GetBlogPosts($inId=null, $inTagId=null) |
2 |
{
|
3 |
|
4 |
}
|
Dentro de nuestra función, debemos verificar para ver qué argumentos se pasaron y crear nuestra consulta MySQL en consecuencia.
1 |
function GetBlogPosts($inId=null, $inTagId =null) |
2 |
{
|
3 |
if (!empty($inId)) |
4 |
{
|
5 |
|
6 |
}
|
7 |
else if (!empty($inTagId)) |
8 |
{
|
9 |
|
10 |
}
|
11 |
else
|
12 |
{
|
13 |
|
14 |
}
|
15 |
}
|
Entonces, lo que estamos haciendo aquí es preguntar si cada argumento no está vacío, la razón por la que estamos usando la función vacía en lugar de hacer la comparación estándar "! = Null" es porque vacía no solo comprueba si la variable es nula, sino vacio tambien (IE ""). Ahora escribiremos una consulta dependiendo de las variables que tengamos. Si pasamos una ID de publicación de blog, solo queremos esa única entrada de blog, si le damos a la función un inTagId queremos todas las publicaciones que tengan esa etiqueta, y de lo contrario solo queremos todas las publicaciones de blog en nuestra base de datos.
1 |
if (!empty($inId)) |
2 |
{
|
3 |
$query = mysql_query("SELECT * FROM blog_posts WHERE id = " . $inId . " ORDER BY id DESC"); |
4 |
}
|
5 |
else if (!empty($inTagId)) |
6 |
{
|
7 |
$query = mysql_query("SELECT blog_posts.* FROM blog_post_tags LEFT JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) WHERE blog_post_tags.tagID =" . $tagID . " ORDER BY blog_posts.id DESC"); |
8 |
}
|
9 |
else
|
10 |
{
|
11 |
$query = mysql_query("SELECT * FROM blog_posts ORDER BY id DESC"); |
12 |
}
|
El siguiente paso es procesar los datos devueltos de cada consulta, crear los objetos y luego agregarlos a una matriz para devolver.
1 |
$postArray = array(); |
2 |
while ($row = mysql_fetch_assoc($query)) |
3 |
{
|
4 |
$myPost = new BlogPost($row["id"], $row['title'], $row['post'], $row['postfull'], $row['firstname'] . " " . $row['lastname'], $row['dateposted']); |
5 |
array_push($postArray, $myPost); |
6 |
}
|
7 |
return $postArray; |
Aquí está el código completo del archivo includes.php:
1 |
<?php
|
2 |
include 'blogpost.php'; |
3 |
|
4 |
$connection = mysql_connect('localhost', 'username', 'password') or die ("<p class='error'>Sorry, we were unable to connect to the database server.</p>"); |
5 |
$database = "nettuts_blog"; |
6 |
mysql_select_db($database, $connection) or die ("<p class='error'>Sorry, we were unable to connect to the database.</p>"); |
7 |
|
8 |
function GetBlogPosts($inId=null, $inTagId =null) |
9 |
{
|
10 |
if (!empty($inId)) |
11 |
{
|
12 |
$query = mysql_query("SELECT * FROM blog_posts WHERE id = " . $inId . " ORDER BY id DESC"); |
13 |
}
|
14 |
else if (!empty($inTagId)) |
15 |
{
|
16 |
$query = mysql_query("SELECT blog_posts.* FROM blog_post_tags LEFT JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) WHERE blog_post_tags.tagID =" . $tagID . " ORDER BY blog_posts.id DESC"); |
17 |
}
|
18 |
else
|
19 |
{
|
20 |
$query = mysql_query("SELECT * FROM blog_posts ORDER BY id DESC"); |
21 |
}
|
22 |
|
23 |
$postArray = array(); |
24 |
while ($row = mysql_fetch_assoc($query)) |
25 |
{
|
26 |
$myPost = new BlogPost($row["id"], $row['title'], $row['post'], $row['postfull'], $row["author_id"], $row['dateposted']); |
27 |
array_push($postArray, $myPost); |
28 |
}
|
29 |
return $postArray; |
30 |
}
|
31 |
?>
|
Ahora podemos pasar a mostrar nuestros datos, abriremos nuestro archivo index.php y configurar una página HTML básica. Dentro de nuestro cuerpo, crearemos una división con un ID de "main" que contendrá nuestro blog. Le daremos un título a nuestro blog y luego tendremos un segundo div dentro de main que se llamará "blogPosts"
1 |
<div id="main"> |
2 |
<h1>My Simple Blog</h1> |
3 |
<div id="blogPosts"> |
4 |
|
5 |
</div>
|
6 |
</div>
|
Dentro de nuestro blogPosts div, pondremos algo de PHP para poder mostrar nuestras publicaciones. Primero vamos a incluir nuestro archivo includes.php y luego llamaremos a nuestra función GetBlogPosts sin argumentos para obtener todas las publicaciones de nuestro blog y establecerlo en una matriz llamada blogPosts.
1 |
<?php
|
2 |
include 'includes/includes.php'; |
3 |
|
4 |
$blogPosts = GetBlogPosts(); |
5 |
?>
|
Ahora, usaremos un bucle foreach para mostrar las publicaciones de nuestro blog. Lo que un bucle foreach hace por nosotros en este momento es tomar una matriz y ejecutar el código en el bucle para cada elemento de la matriz, también podría usar un bucle normal para lograr esto, pero un bucle foreach requiere menos código.
1 |
foreach ($blogPosts as $post) |
2 |
{
|
3 |
|
4 |
}
|
Dentro del bucle, usamos $ post como el elemento de la matriz actual, y como $ blogPosts es una matriz de objetos BlogPost, simplemente podemos usar "->" para acceder a cada propiedad que queramos. Comencemos simplemente haciendo eco del título de cada publicación de blog en nuestra página y simplemente agregue un - como ejemplo.
1 |
foreach ($blogPosts as $post) |
2 |
{
|
3 |
echo $post->title . "<br/>"; |
4 |
}
|
Si vamos a nuestra base de datos e insertamos algunos datos falsos, luego abrimos index.php en un navegador, obtendremos algo como esto:
Vamos a construir realmente nuestras publicaciones en HTML. Cada publicación será envuelta en un div con una clase de "publicación". Luego tendremos el título de la publicación dentro de una etiqueta h1 y la publicación real dentro de una etiqueta .
1 |
foreach ($blogPosts as $post) |
2 |
{
|
3 |
echo "<div class='post'>"; |
4 |
echo "<h2>" . $post->title . "</h2>"; |
5 |
echo "<p>" . $post->post . "</p>"; |
6 |
echo "</div>"; |
7 |
}
|
También asignemos a cada publicación un pie de página que incluya el autor de la publicación, la fecha de publicación y las etiquetas de la publicación. Pondremos toda esta información dentro de una etiqueta span con un "pie de página" de clase.
1 |
foreach ($blogPosts as $post) |
2 |
{
|
3 |
echo "<div class='post'>"; |
4 |
echo "<h1>" . $post->title . "</h1>"; |
5 |
echo "<p>" . $post->post . "</h1>"; |
6 |
echo "<span class='footer'>Posted By: " . $post->author . " Posted On: " . $post->datePosted . " Tags: " . $post->tags . "</span>"; |
7 |
echo "</div>"; |
8 |
}
|
Ahora veamos nuestro archivo index.php nuevamente en un navegador:
¡Parece que todo está funcionando! A continuación, vamos a añadir un poco de estilo.
Mucho mejor; Puede ver esto en línea aquí o hacer clic en los botones grandes de "demostración". Eso es para este tutorial. En un tutorial posterior, agregaremos más funciones a nuestro blog, ¡incluyendo algunas funciones agradables de AJAX!
Espero que ahora tenga una mejor comprensión de cómo funciona la programación orientada a objetos. Incluso si terminas haciendo la mayor parte de tu desarrollo utilizando un marco, es muy importante tener una comprensión básica de los fundamentos. Si tiene alguna pregunta específica sobre este tutorial, no dude en enviarme un correo electrónico a @benemills. Me gustaría agradecer especialmente a James Padolsey por ayudarme con este artículo.
¡Mantente atento a la Parte 2!
- Suscríbase a la fuente RSS de NETTUTS para obtener más artículos y artículos de desarrollo web diarios.
