PHP: Objetos III (Encapsulamiento)

Hola, en el siguiente post abordaremos lo que es el Encapsulamiento en php. Aunque este lenguaje de programación no es muy estricto en cuanto a POO, se pueden emular la mayoría de cosas que son necesarias en Objetos, en este caso Encapsulamiento. Para comenzar es bueno tener en cuenta la ocultación de información(encapsulamiento). Muchos dicen que PHP rompe el encapsulamiento debido a que nos permite acceder a cualquier atributo de una clase directamente, pero en si hay una forma de hacer que no se pueda y así generar el encapsulamiento. Para ello tenemos el concepto de visibilidad en php.

El concepto de visibilidad nos dice que hay tres palabras claves/reservadas: public, protected y private que anteponiendolas a cualquier método o atributo/propiedad se podrán modificar o implementar su visibilidad, haciendo posible el encapsulamiento.

Public: Se podrá acceder a ella de cualquier forma, directamente o por métodos de la misma o de otras clases. Ejemplo:

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     public $edad; // Es public por lo que se accede desde 
 5     cualquier parte
 6     public function __construct($nom, $ape, $e){
 7          $this->nombre = $nom;
 8          $this->apellido= $ape;
 9          $this->edad = $e;
10     }
11     public function imprimir(){
12         return $this->edad;
13     }
14 }
15 $persona = new Persona('Pepito','Perez',24);
16  echo $persona->edad;
17  echo $persona->imprimir();

Como vemos es la misma clase persona que se viene trabajando. Creamos el objeto y hacemos echo a la edad directamente, lo que nos imprimira un 24, despues por medio del metodo imprimir() tambien nos pondra en pantalla el mismo dato, teniendo en cuenta el return en la linea 12.

Protected: Si cambiamos el public por el protected y dejamos lo demas igual, nos saldra un fatal error, ya que con protected no nos dejara acceder a la propiedad a menos que sea por métodos de la misma clase, herencia o con el parent.

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     protected $edad; 
 5     public function __construct($nom, $ape, $e){
 6           $this->nombre = $nom;
 7           $this->apellido= $ape;
 8           $this->edad = $e;
 9     }
10     public function imprimir(){
11         return $this->edad;
12     }
13 }
14 $persona = new Persona('Pepito','Perez',24);
15 echo $persona->edad;
16 echo $persona->imprimir();

Si comentamos la linea donde imprimimos directamente la propiedad, nos imprimira el resultado del metodo imprimir().

 1 //echo $persona->edad;
 2 echo $persona->imprimir();

Private: Al poner la propiedad edad en private solo nos dejara acceder desde la misma clase, entonces si hacemos el ejercicio anterior

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     private $edad; 
 5     public function __construct($nom, $ape, $e){
 6           $this->nombre = $nom;
 7           $this->apellido= $ape;
 8           $this->edad = $e;
 9     }
10     public function imprimir(){
11         return $this->edad;
12     }
13 }
14 class trabajo extends Persona{
15     public $trabajos;
16     public $pruebas;
17     public function trabajar($job){
18         $this->trabajos = $job;
19     }
20     public function imprimir(){
21         return 'Mi nombre es '.$this->nombre.' '.$this->
           apellido.' y tengo '.$this->edad.' Años y trabajo 
           en  '.$this->trabajos;
22     }  
23  }
24 $persona = new Persona('Pepito','Perez',24);
25 echo $persona->imprimir();

Si corremos php con el siguiente código, no nos dejara acceder a la propiedad edad de la clase Persona desde trabajo porque es privada, si fuera protected si nos dejaria pero solo por metodos o parent.

Esto es encapsulamiento en PHP.

PHP: Objetos II (Herencia)

Hola, este es el siguiente post de objetos, aqui mostrare lo que es Herencia, una parte fundamental de la POO en php. Entonces suponiendo que leimos el primer post, tenemos una clase persona con dos metodos, el cual uno es el constructor y otro es el metodo imprimir(), entonces dejemos la clase hasta ahi, podemos borras la instancia del objeto, que hicimos posteriormente.

Como lo dice Wikipedia, "Mecanismo por el cual una clase se deriva de otra de manera que extiende su funcionalidad. La clase de la que se hereda se suele denominar clase base, clase padre, superclase, clase ancestro (el vocabulario que se utiliza suele depender en gran medida del lenguaje de programación).". Eso quiere decir es que una clase padre, tiene n metodos, los cuales puede heredar una clase hija para su correcto funcionamiento.

Ya sabemos que es herencia, pero no podemos verlo en forma porque para ello necesitaríamos otro objeto que accediera a nuestro objeto persona. Pues entonces vamos a construir uno, y de una vez veremos el ejemplo de herencia.
Como vemos en el anterior codigo, es una clase de nombre trabajo y despues viene lo importante, la palabra reservada de PHP, extends, nos dice que esa clase heredara de otra, en este caso persona, en ellas hay un atributo llamado $trabajos y dos metodos publicos, los cuales son trabajar() e imprimir(). Con esto ya podemos acceder desde trabajo a Persona, y lo hacemos de la siguiente manera.

01 class trabajo extends Persona{
02     private $trabajos;
03     public function trabajar($job){
04  $this->trabajos = $job;
05     }
06     public function imprimir(){
07   return 'Mi nombre es '.$this->nombre.' '.$this->
08  apellido.' tengo '.
09  $this->edad.' años y trabajo en '.$this->trabajos;
10     }  
11 }

Hemos agregado tres lineas de codigo mas, los cuales son los de instanciar una clase o creando un objeto, este objeto hereda de Persona el contructor y por ello enviamos 3 datos, despues invocamos un metodo que viene de la clase trabajo llamado trabajar() que nos recibe el trabajo que estamos haciendo, y por ultimo 
hacemos un echo al metodo imprimir() de la clase trabajo. Aqui hay dos cosas para ver, para ello veremos todo el codigo que llevamos

01 class Persona{
02     public $nombre;
03     public $apellido;
04     public $edad;
05     public function __construct($nom, $ape, $e){
06         $this->nombre = $nom;
07  $this->apellido= $ape;
08  $this->edad = $e;
09     }
10     public function imprimir(){
11         return 'Mi nombre es '.$this->nombre.' '.$this->
12         apellido.' y tengo '.
13         $this->edad.' Años';
14     }
15 } 
16 class trabajo extends Persona{
17     private $trabajos;
18     public function trabajar($job){
19          $this->trabajos = $job;
20     }
21     public function imprimir(){
22          return 'Mi nombre es '.$this->nombre.' '.$this->
23          apellido.' tengo '.
24          $this->edad.' años y trabajo en '.$this->trabajos;
25     }  
26 }
27 $trabajo = new trabajo('Pepito','Perez','24');
28 $trabajo->trabajar('informatica');
29 echo $trabajo->imprimir(); 

Vemos facilmente las dos clases, una heredando de otra y ademas que tienen cada una un metodo con el mismo nombre, pues cuando llamo un metodo igual que el metodo de una clase base, esto se llama redefinir metodos, que no es mas que sobreescribir el metodo en la clase que hereda, lo siguiente es que PHP ingresa al imprimir redefinido, es decir a la clase que hereda, por lo que en nuestro caso imprimira la parte "y trabajo en .....", en caso de que quisieramos acceder a un metodo de la clase base, lo haremos via parent de la siguiente manera:

01 public function imprimir(){
02     $pruebas = parent::imprimir(); // La variable $pruebas la declare en trabajo
03     return $pruebas;
04 }

Como vemos asignamos a una variable el valor de parent que significa buscar en la clase base, seguido de "::", que trabajaria similar al '->' y por ultimo el metodo que queramos invocar. Hacemos el return de la variable que contiene la respuesta y listo, nos imprimira todo lo que hay en nuestro metodo imprimir de la clase Persona, que en este caso solo nos imprimira hasta Años.

Hasta aqui va este post que esta como largo, en otro explicare lo que es encapsulamiento y polimorfismo.

Instalar Apache + PHP + MySQL en Windows 7 (Avanzado) 64bits

Prerequisitos

Para todas las instalaciones tenemos que tener en cuenta la arquitectura dependiendo si nuestro sistema es de 32bits.
Si bajamos e instalamos Apache desde la web de www.apachelounge.com antes necesitaremos instalar el “Visual C++ 2010 SP1 Redistributable Package” para 32 o 64bits igualmente.

Bajamos Apache y la DLL de Apache para PHP

• Vamos a http://www.apachelounge.com/download/win64/ y bajamos la ultima versión, en mi caso Apache 2.4.3 64bit en zip (httpd-2.4.3-win64.zip)
• Bajate el modulo de fcgid (mod_fcgid-2.3.7-win64.zip)
  Nota: Este Modulo lo usaremos cuando vayamos a configurar Apache para que pueda trabajar con PHP.

Bajamos PHP

• Vamos a http://windows.php.net/download/ y bajamos la última versión de PHP, en mi caso la 5.4.8 thread safe en zip (php-5.4.8-nts-Win32-VC9-x86.zip)
  

Bajamos MySQL

• Vamos a http://www.mysql.com/downloads/installer/ y bajamos la ultima versión del MySQL

Descomprimimos todo

• Descomprimimos Apache para que quede en c:\apache24 (carpeta por defecto para esta compilación)
• Descomprimimos PHP en c:\php
• Descomprimimos mod_fcgid-2.3.7-win64.zip y copiamos el modulo que se encuentra en mod_fcgid/mod_fcgid.so en C:\Apache24\modules\

Definir las variables de entorno

Vamos a inicio > Panel de control > Sistema > Configuración avanzada del sistema > Variables de entorno > Seleccionamos la variable del sistema “Path” en la segunda lista de la ventana > pulsamos el botón que dice “Editar...” > Donde dice valor de la variable añadimos al final las siguientes rutas separadas por “;”:

c:\php
c:\apache24\bin

Así:

(Lo que quiera que sea que haya ya);C:\php;c:\apache24\bin;

set path=”%path%;C:\php;c:\apache24\bin”

Esto nos permitirá dos cosas, primero que si Apache PHP necesitan estas rutas para encontrar sus librerías las encuentren, y segundo que podremos usarlos desde la ruta de comandos sin necesidad de escribir la ruta cada vez.Nota: Para que estos cambios se apliquen lo más cómodo es reiniciar. Es una idea muy extendida aunque en teoría no hace falta... Si en vez de editar las variables de entorno así se hubiese hecho por terminal (cmd.exe), bastaría con cerrar dicha terminal y volverla a abrir.


Configuración básica de Apache

Abrimos a C:\apache24\conf\httpd.conf y verifica que estas directivas esten igual que aquí:

ServerRoot "c:/Apache24"
ServerName localhost:80

DocumentRoot "c:/Apache24/htdocs"

Y para configurar PHP en Apache le ponemos al final esto:

<IfModule fcgid_module> FcgidInitialEnv PATH "c:/php;C:/WINDOWS/system32;C:/WINDOWS;C:/WINDOWS/System32/Wbem;" FcgidInitialEnv SystemRoot "C:/Windows" FcgidInitialEnv SystemDrive "C:" FcgidInitialEnv TEMP "C:/WINDOWS/Temp" FcgidInitialEnv TMP "C:/WINDOWS/Temp" FcgidInitialEnv windir "C:/WINDOWS" FcgidIOTimeout 40 FcgidConnectTimeout 10 FcgidMaxProcesses 8 FcgidOutputBufferSize 64 ProcessLifeTime 240 FcgidMaxRequestsPerProcess 500 FcgidMinProcessesPerClass 0 <Files ~ "\.php$>" Options Indexes FollowSymLinks ExecCGI AddHandler fcgid-script .php SetEnv PHPRC "C:/php" FcgidWrapper "C:/php/php-cgi.exe" .php </Files> </IfModule> 

Configuración básica de PHP

Vamos a c:\php\ y renombramos el php-production.ini o el php-development.ini a php.ini lo abrimos y nos aseguramos que esta directiva este así extension_dir = "ext" y descomentada (sin el ; delante).

Buscamos la lista de extensiones en el archivo php.ini y descomentamos la de php_pdo_mysql:
;extension=php_bz2.dll

;extension=php_curl.dll

;extension=php_fileinfo.dll

extension=php_gd2.dll

;extension=php_gettext.dll

;extension=php_gmp.dll

;extension=php_intl.dll

;extension=php_imap.dll

;extension=php_interbase.dll

;extension=php_ldap.dll

extension=php_mbstring.dll  ; Sin esto el phpmyadmin podría fallar al manejar strings

;extension=php_exif.dll      ; Must be after mbstring as it depends on it

;extension=php_mysql.dll

extension=php_mysqli.dll

;extension=php_oci8.dll      ; Use with Oracle 10gR2 Instant Client

;extension=php_oci8_11g.dll  ; Use with Oracle 11gR2 Instant Client

;extension=php_openssl.dll

;extension=php_pdo_firebird.dll

extension=php_pdo_mysql.dll

;extension=php_pdo_oci.dll

;extension=php_pdo_odbc.dll

;extension=php_pdo_pgsql.dll

;extension=php_pdo_sqlite.dll

;extension=php_pgsql.dll

;extension=php_pspell.dll

;extension=php_shmop.dll

; The MIBS data available in the PHP distribution must be installed.

; See http://www.php.net/manual/en/snmp.installation.php

;extension=php_snmp.dll

;extension=php_soap.dll

;extension=php_sockets.dll

extension=php_sqlite3.dll

;extension=php_sybase_ct.dll

;extension=php_tidy.dll

;extension=php_xmlrpc.dll

;extension=php_xsl.dll

;extension=php_zip.dll

En PHP 5.4 en teoría ya viene configurado todo lo que es mysqli, mysqlnd, de serie... De todas formas al final, cuando estemos de todo pondré un script para comprobar que Apache, MySQLnd, PDO etc están activados.
Guarda el documento

Con Apache iniciado ya deberías poder acceder desde http://localhost/ 

Iniciar y parar Apache y MySQL

Abrimos dos terminales (pulsamos Windows + R y escribimos cmd.exe) y escribimos httpd -k start y mysqld en cada terminal para iniciar Apache y MySQL.

Para cerrar Apache y MySQL httpd -k stop y mysqld -u root shutdown respectivamente.

También podemos instalar los dos servidores como servicios del sistema. httpd -k install y mysqld --installLuego puede iniciarse y pararse con net start/stop Apache2.4 y net start/stop mysql


Comprobar que los tres servers funcionan

Creamos un archivo index.php en c:\apache24\htdocs y le ponemos esto dentro:

<?php

echo "Apache enabled!"; echo '<br />';

if (function_exists('mysqli_fetch_all')) { echo 'MySQLnd enabled!'; echo '<br />'; }

if (defined('PDO::ATTR_DRIVER_NAME')) { echo 'PDO enabled!'; echo '<br />'; }

try {

   $dbh = new PDO('mysql:host=localhost;dbname=test', 'root', '');

   

   if (strpos($dbh->getAttribute(PDO::ATTR_CLIENT_VERSION), 'mysqlnd') !== false) {

   echo 'PDO MySQLnd enabled!';

}

} catch (PDOException $e) {

   echo 'Connection failed: ' . $e->getMessage();

}

Luego vamos a http://localhost/index.php

PHP: Objetos

Hola, ahora vamos a ver como php trabaja con objetos, este manual es muy basico, vamos a crear lo que es una clase junto con sus metodos, definiremos un metodo contructor, iremos dandole forma a lo que son los conceptos de la programacion orientada a objetos explicando despues como crear una conexion a base de datos con mysql.

Creamos un archivo php con el nombre que quieran, ahora el ejercicio es simple, vamos a hacer una clase llamada persona que tendra ciertos atributos y a su vez metodos. Creamos la clase persona:

01 class Persona{
02 
03 }

Como vemos en el anterior codigo, una clase se define por la palabra reservada class, seguido del nombre que se quiera dar, se crean las llaves que encerraran las intrucciones para esta clase. Cabe decir que esto es una clase normal, no estamos hablando de clases abstractas ni interfaces, es una clase normalita.

Vamos a crear atributos, que no son mas que variables predefinidas que utilizaremos en los metodos, en este caso crearemos los atributos: nombre, apellido, edad y nuestra clase quedara asi:

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 }

Hay que resaltar que segun la programacion orientada a objetos, los atributos tienen que ser private, bueno en realidad no tienen, pero es mucho mejor que sean de este tipo, si queremos cambiarlos de valor o asiganerles uno simplemente lo haremos por medio de un metodo publico(public). Ahora vamos a crear el constructor, que en si es el metodo con el cual podemos inicializar nuestra clase a la hora de instanciarla. Vamos a utilizar constructor para que en un futuro podamos hacer el ejemplo de polimorfismo.

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 
06  public function __construct($nom, $ape, $e){
07       $this->nombre = $nom;
08       $this->apellido= $ape;
09       $this->edad = $e;
10  } 
11 }

Ahora explicaremos las lineas donde se creo el metodo o como pueden ver una funcion publica con un nombre prederminado. PHP utiliza el nombre __construct para indicarle a la clase que se inicializa por este metodo, no es necesario crear un constructor o al menos definirlo, ya que en muchos lenguajes el contructor se llama como la misma clase, pero es mejor comenzar a utilizarlos, este constructor nos dice que va a recibir tres parametros que son $nom, $ape y $e. Dentro de la funcion esta una serie de asiganciones, estas asignaciones lo que estan diciendo es que lo que contenga  $nom, lo asignamos al atributo previamente definido, esto para controlar los datos que ingresan, las asignaciones a atributos se hacen siempre con la variable $this seguida de guion(-) y el signo mayor que(>) dejando por ultimo el nombre del atributo sin el signo $. Esto se hace para poder trabajar dentro de otros metodos ya que tenemos los datos asignados en el objeto en sus atributos propios. Ahora ya que tenemos los tres datos, vamos a hacer algo con ellos y es imprimirlos.

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 
06  public function __construct($nom, $ape, $e){
07   $this->nombre = $nom;
08   $this->apellido= $ape;
09   $this->edad = $e;
10  } 
11 }

En las lineas anteriores vemos como escribimos un nuevo metodo llamado imprimir, este es publico, pero a diferencia del constructor, no recibe datos en cambio hace un return para que nos retorne una respuesta de una cadena o string de datos que llevan consigo los atributos definidos y asignados anteriormente. Ya tenemos nuestra clase persona, pero ahora necesitamos crear el objeto, es decir instanciar la clase y crear el objeto. Para ello hacemos lo siguiente, puede ser despues del cierre de la clase, es solo una prueba.

01 class Persona{
02     private $nombre;
03     private $apellido;
04     private $edad;
05    
06  public function __construct($nom, $ape, $e){
07     $this->nombre = $nom;
08     $this->apellido= $ape;
09     $this->edad = $e;
10  }
11  public function imprimir(){
12     return 'Mi nombre es '.$this->nombre.' '.$this->apellido.' y tengo '.$this->edad.' Años'
13     $this->edad.' Años';
14  }
15 }
16 $persona1 = new Persona('Fulanito', 'de tal', '24');
17 echo $presona1->imprimir();

En las lineas nuevas creadas despues de nuestra clase, estamos instanciando la clase para crear un objeto, es decir creamos un objeto de tipo persona, este se creó debido a la instruccion new de PHP  seguido del nombre de la clase. Ahora vamos a ver la funcion del constructor, como tenemos un metodo constructor, podemos de una vez enviar ciertos datos a la clase, sin necesidad de despues llamar el metodo por separado, asi que simplemente como el contructor recibe 3 atributos, esos mismos le enviamos. Con esto, ya en la variable $persona1 se crea el objeto, por lo que podemos acceder a los metodos de la clase Persona, para ello llamamos los metodos de la sigueinte manera $persona->imprimir(), es decir, el nombre del objeto que se creo al instanciar la clase seguido de guion(-) y mayor que(>), y despues viene el nombre del metodo en nuestro caso imprimir(). Le anteponemos a todos un echo, para que imprima lo que retorne este metodo y listo. Para el siguiente post, sabiendo algo ya de POO, haremos la conexion a la base de datos y en otro explicaremos con mas detalle mas tecnicas, como lo son la herencia, encapsulamiento, polimorfismo y mucho mas.

PHP + Mysql: Conexion

Hola, ahora en esta ocasión mostraremos como hacer un script de conexión para Mysql desde PHP.

Básicamente el código es similar, pero para explicarlo mejor, haremos una conexion via objetos, y otra estructurada.

Abrimos el editor de texto que tengamos y creamos un archivo .php, ahora, php tiene funciones preestablecidas para la conexion a gestores de bases de datos, para hoy utilizaremos la de mysql, en otro momento haremos para mas gestores de base de datos, que puede no ser muy distinto pero algunos como Oracle tienen ciertas especificaciones y pasos a seguir.

En este link estan las funciones que tiene php para no solo la conexion, sino para el manejo de los datos que tengamos en mysql, pero ahora haremos una conexion solamente, para esto vamos a utilizar la funcion mysql_connect, segun el site de php, nos sugiere que utilicemos Mysqli o la api mejorada de mysql (esta funcion no esta obsoleta ni nada por el estilo), para practicar con esta nos basta, mas adelante miraremos como utilizar mysqli, que esta orientada al desarrollo por objetos.

En el archivo creado php ingresando las etiquetas de apertura y cierre de php, ingresamos el siguiente codigo:

01 $conexion = mysql_connect('localhost', 'usuario', 'password');
02 if (!$conexion) {
03     die('No se pudo conectar a la base de datos');
04 }else{
05     echo 'Conectado';
06 }
07 mysql_close($conexion);

Ahora procedere a explicar cada linea del codigo.

Linea 1: En esta linea creamos una variable llamada "$conexion", la cual le asignamos a la funcion mysql_connect los parametros minimos para crear la conexion a nuestra base de datos mysql, los cuales son
'localhost' -> Servidor de Mysql,
'usuario'   -> Usuario de Mysql,
'password' -> Password de Mysql.

Linea 2-3: Como ya tenemos el resultado de nuestra conexion necesitamos saber si es exitosa o no, y para ello vamos a validar la variable $conexion, para validarla lo podemos hacer por medio de un if, ya que mysql_connect nos devuelve true o false. En la condicion if, el simbolo ! antes de una variable nos dice si el valor es false, entonces en el if estamos preguntando, si($conexion es false), sino tuviera el simbolo validaria si es true, como estamos preguntando si es false, entonces al ser asi, ingresa y se encuentra con una funcion global de php llamada die, el die para el sistema de inmediato y muestra lo que contiene en su interior.

Linea 4-5-6: En caso de que la conexion nos devuelva true, es decir el else, entonces imprime en pantalla "conectado", despues cerramos la condicion.

Linea 7: Cerramos la conexion a la base por medio de la funcion nativa de php mysql_close, simplemente tomando la variable que le asignamos la conexion e ingresandola como parametro. mysql_close($conexion);

Con esto ya nos hemos conectado a la base de datos, para comenzar a hacer busquedas, inserciones, ediciones o borrar registros de ella, por este metodo estructurado, su uso puede ser cargarlo en las cabeceras de nuestros archivos html o php por la funcion include o require dos nativas de php. En otro post veremos como hacer la conexion, un poco mas compleja, por medio de objetos.

Lo basico: ¡Hola Mundo!

Esta es la segunda parte de este minitutorial básico  si no has leido la primera parte, es mejor que la leas aqui, claro sabiendo que eres nuevo en esto.

Ya tenemos instalado nuestro servidor y corriendo. Entonces ahora, vamos a la direccion donde se instalo el paquete, alli ingresamos y buscamos la carpeta llamada www o htdocs, ¡atencion aqui es donde estaran nuestros script, nuestro codigo para crear paginas web en nuestro servidor local, ya sea por medio de archivos con la extension .php, .html, js, etc. Tambien podemos crear carpetas con el nombre de nuestro proyecto y acceder directamente desde la url.

Ejemplo:

          Si creamos una carpeta con el nombre "misitio", podremos ingresar desde el navegador con http://localhost/misitio/.


Entonces ya tenemos visualizado donde va a quedar nuestros archivos con codigo PHP, ya creamos nuestra carpeta para nuestro primer proyecto.

Ahora vamos a crear nuestro primer script, para ello necesitamos donde escribir, en este punto en editores de texto hay infinidad de posibilidades, desde los profesionales(dreamweaver, sublime text, etc) como los mas basicos (bloc de notas), asi que usa el que quieras.

Ingresa al editor y crea un archivo con cualquier nombre, yo le voy poner index.php, cabe decir que cuando ingresas a http://localhost/misitio/, si hay un archivo index, de inmediato se carga este, sino, mostrara el directorio.

Entonces en nuestro archivo, agregaremos lo siguiente dentro de las etiquetas <?php ---- ?>:

01 /*la instruccion echo imprime en pantalla lo que se encuentre dentro de las comillas.*/
02 echo "¡Hola Mundo!"; 

Si ingresan al sitio desde el navegador, veran la impresion en pantalla. Espero que lo hallan entendido y les haya facilitado la idea, mas adelante un tutorial de conexion.

Lo basico: Instalando un servidor Local

Primero lo primero, este es un manual muy básico para instalar un servidor local, para practicar programación.

Para comenzar a programar tenemos que saber en que lenguaje vamos a aprender, y pues a mi parecer uno de los mas difundidos es PHP. Digamos que escogemos PHP por ahora, ya que después veremos Python, pero ahora vamos a utilizar PHP.

PHP es un lenguaje interpretado vía web que requiere un servidor para funcionar, entonces necesitamos servidor HTTP, y vamos a escoger Apache.

Ya tenemos el lenguaje de programación, el servidor para el lenguaje y ahora necesitamos una base de datos y un gestor de base de datos, miramos en Internet, hay un montón ellos,  por ahora utilizaremos uno que se maneje  por lenguaje SQL, el mas común en la comunidad de desarrolladores web es Mysql.

Si descargamos PHP por un lado(recuerden descargar siembre los archivos, y no el instalador), MySQL por otro y Apache ademas, nos vamos a topar con una configuración algo tediosa y muchas veces frustrante, ya que deberemos modificar algunas cosas, cuando llegues a cierto nivel lo haremos, vamos a descargar ciertos paquetes que nos instalan Apache + PHP + MySQL en nuestro pc, para ¡PRACTICAR!, para ello, por preferencias personales recomiendo WAMP, pero hay otros, como XAMPP, APPSERV o AMPPS, así que escojan el que deseen. Si no estoy mal creo que todos ya tienen sus versiones para 32 o 64 bits, para tener en cuenta utilizaremos en PHP una versión > 5.3, ya en Mysql y Apache para practicar
 pueden ser la versión que traen los paquetes por default.

Cuando ya tenemos instalado alguno de los paquetes, vamos al navegador de preferencia y en la url le damos localhost, en todos los paquetes siempre aparece la presentación de estos, unos describen con mas detalles que otros, pero en si son similares, en caso de que no sirva algun paquete, pero se instalo todo de manera acertada, es sin duda porque el puerto 80/TCP esta ocupado, si esta conectado en Skype, de seguro es por ello, sino trata de desconectarte de los programas que manejen este puerto y asi arrancara el Apache y comenzaremos a programar.